Revert "feat(fts5): get rid of search comparison code"

This reverts commit 41f6fedc61.

.editorconfig

@@ -1,6 +1,6 @@
 root = true
 
-[*.{js,cjs,ts,tsx,css}]
+[*.{js,ts,tsx,css}]
 charset = utf-8
 end_of_line = lf
 indent_size = 4

.github/actions/build-electron/action.yml

@@ -85,7 +85,6 @@ runs:
       APPLE_ID: ${{ env.APPLE_ID }}
       APPLE_ID_PASSWORD: ${{ env.APPLE_ID_PASSWORD }}
       WINDOWS_SIGN_EXECUTABLE: ${{ env.WINDOWS_SIGN_EXECUTABLE }}
-      WINDOWS_SIGN_ERROR_LOG: ${{ env.WINDOWS_SIGN_ERROR_LOG }}
       TRILIUM_ARTIFACT_NAME_HINT: TriliumNotes-${{ github.ref_name }}-${{ inputs.os }}-${{ inputs.arch }}
       TARGET_ARCH: ${{ inputs.arch }}
     run: pnpm run --filter desktop electron-forge:make --arch=${{ inputs.arch }} --platform=${{ inputs.forge_platform }}

.github/actions/build-server/action.yml

@@ -8,7 +8,7 @@ inputs:
 runs:
   using: composite
   steps:
-  - uses: pnpm/action-setup@v5
+  - uses: pnpm/action-setup@v4
   - name: Set up node & dependencies
     uses: actions/setup-node@v6
     with:

.github/actions/report-size/action.yml

@@ -69,7 +69,7 @@ runs:
 
     # Post github action comment
     - name: Post comment
-      uses: marocchino/sticky-pull-request-comment@v3
+      uses: marocchino/sticky-pull-request-comment@v2
       if: ${{ steps.bundleSize.outputs.hasDifferences == 'true' }} # post only in case of changes
       with:
         number: ${{ github.event.pull_request.number }}

.github/copilot-instructions.md

@@ -1,7 +1,5 @@
 # Trilium Notes - AI Coding Agent Instructions
 
-> **Note**: When updating this file, also update `CLAUDE.md` in the repository root to keep both AI coding assistants in sync.
-
 ## Project Overview
 
 Trilium Notes is a hierarchical note-taking application with advanced features like synchronization, scripting, and rich text editing. Built as a TypeScript monorepo using pnpm, it implements a three-layer caching architecture (Becca/Froca/Shaca) with a widget-based UI system and supports extensive user scripting capabilities.
@@ -117,15 +115,6 @@ class MyNoteWidget extends NoteContextAwareWidget {
 
 **Important**: Widgets use jQuery (`this.$widget`) for DOM manipulation. Don't mix React patterns here.
 
-### Reusable Preact Components
-Common UI components are available in `apps/client/src/widgets/react/` — prefer reusing these over creating custom implementations:
-- `NoItems` - Empty state placeholder with icon and message (use for "no results", "too many items", error states)
-- `ActionButton` - Consistent button styling with icon support
-- `FormTextBox` - Text input with validation and controlled input handling
-- `Slider` - Range slider with label
-- `Checkbox`, `RadioButton` - Form controls
-- `CollapsibleSection` - Expandable content sections
-
 ## Development Workflow
 
 ### Running & Testing
@@ -197,14 +186,6 @@ When adding query parameters to ETAPI endpoints (`apps/server/src/etapi/`), main
 
 **Auth note**: ETAPI uses basic auth with tokens. Internal API endpoints trust the frontend.
 
-### Adding New LLM Tools
-Tools are defined using `defineTools()` in `apps/server/src/services/llm/tools/` and automatically registered for both the LLM chat and MCP server.
-
-1. Add the tool definition in the appropriate module (`note_tools.ts`, `attribute_tools.ts`, `hierarchy_tools.ts`) or create a new module
-2. Each tool needs: `description`, `inputSchema` (Zod), `execute` function, and optionally `mutates: true` for write operations or `needsContext: true` for tools that need the current note context
-3. If creating a new module, wrap tools in `defineTools({...})` and add the registry to `allToolRegistries` in `tools/index.ts`
-4. Add a client-side friendly name in `apps/client/src/translations/en/translation.json` under `llm.tools.<tool_name>` — use **imperative tense** (e.g. "Search notes", "Create note", "Get attributes"), not present continuous
-
 ### Database Migrations
 - Add scripts in `apps/server/src/migrations/YYMMDD_HHMM__description.sql`
 - Update schema in `apps/server/src/assets/db/schema.sql`
@@ -232,12 +213,6 @@ Tools are defined using `defineTools()` in `apps/server/src/services/llm/tools/`
 
 10. **Attribute inheritance can be complex** - When checking for labels/relations, use `note.getOwnedAttribute()` for direct attributes or `note.getAttribute()` for inherited ones. Don't assume attributes are directly on the note.
 
-## MCP Server
-- Trilium exposes an MCP (Model Context Protocol) server at `http://localhost:8080/mcp`, configured in `.mcp.json`
-- The MCP server is **only available when the Trilium server is running** (`pnpm run server:start`)
-- It provides tools for reading, searching, and modifying notes directly from the AI assistant
-- Use it to interact with actual note data when developing or debugging note-related features
-
 ## TypeScript Configuration
 
 - **Project references**: Monorepo uses TypeScript project references (`tsconfig.json`)
@@ -300,12 +275,6 @@ View types are configured via `#viewType` label (e.g., `#viewType=table`). Each
 - Register in `packages/ckeditor5/src/plugins.ts`
 - See `ckeditor5-admonition`, `ckeditor5-footnotes`, `ckeditor5-math`, `ckeditor5-mermaid` for examples
 
-### Updating PDF.js
-1. Update `pdfjs-dist` version in `packages/pdfjs-viewer/package.json`
-2. Run `npx tsx scripts/update-viewer.ts` from that directory
-3. Run `pnpm build` to verify success
-4. Commit all changes including updated viewer files
-
 ### Database Migrations
 - Add migration scripts in `apps/server/src/migrations/YYMMDD_HHMM__description.sql`
 - Update schema in `apps/server/src/assets/db/schema.sql`
@@ -330,29 +299,9 @@ Trilium provides powerful user scripting capabilities:
 - Translation files in `apps/client/src/translations/`
 - Use translation system via `t()` function
 - Automatic pluralization: Add `_other` suffix to translation keys (e.g., `item` and `item_other` for singular/plural)
-- When a translated string contains **interpolated components** (e.g. links, note references) whose order may vary across languages, use `<Trans>` from `react-i18next` instead of `t()`. This lets translators reorder components freely (e.g. `"<Note/> in <Parent/>"` vs `"in <Parent/>, <Note/>"`)
-- When adding a new locale, follow the step-by-step guide in `docs/Developer Guide/Developer Guide/Concepts/Internationalisation  Translations/Adding a new locale.md`
-
-#### Client vs Server Translation Usage
-- **Client-side**: `import { t } from "../services/i18n"` with keys in `apps/client/src/translations/en/translation.json`
-- **Server-side**: `import { t } from "i18next"` with keys in `apps/server/src/assets/translations/en/server.json`
-- **Interpolation**: Use `{{variable}}` for normal interpolation; use `{{- variable}}` (with hyphen) for **unescaped** interpolation when the value contains special characters like quotes that shouldn't be HTML-escaped
-
-### Storing User Preferences
-- **Do not use `localStorage`** for user preferences — Trilium has a synced options system that persists across devices
-- To add a new user preference:
-  1. Add the option type to `OptionDefinitions` in `packages/commons/src/lib/options_interface.ts`
-  2. Add a default value in `apps/server/src/services/options_init.ts` in the `defaultOptions` array
-  3. **Whitelist the option** in `apps/server/src/routes/api/options.ts` by adding it to `ALLOWED_OPTIONS` (required for client updates)
-  4. Use `useTriliumOption("optionName")` hook in React components to read/write the option
-- Available hooks: `useTriliumOption` (string), `useTriliumOptionBool`, `useTriliumOptionInt`, `useTriliumOptionJson`
-- See `docs/Developer Guide/Developer Guide/Concepts/Options/Creating a new option.md` for detailed documentation
 
 ## Testing Conventions
 
-- **Write concise tests**: Group related assertions together in a single test case rather than creating many one-shot tests
-- **Extract and test business logic**: When adding pure business logic (e.g., data transformations, migrations, validations), extract it as a separate function and always write unit tests for it
-
 ```typescript
 // ETAPI test pattern
 describe("etapi/feature", () => {

.github/workflows/deploy-app.yml

@@ -1,70 +0,0 @@
-name: Deploy Standalone App
-
-on:
-  # Trigger on push to main branch
-  push:
-    branches:
-      - standalone
-    # Only run when app files change
-    paths:
-      - 'apps/client/**'
-      - 'apps/client-standalone/**'
-      - 'packages/trilium-core/**'
-      - '.github/workflows/deploy-app.yml'
-
-  # 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/**'
-      - '.github/workflows/deploy-app.yml'
-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: Update build info
-        run: pnpm run chore:update-build-info
-
-      - 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/deploy-docs.yml

@@ -45,7 +45,7 @@ jobs:
         uses: actions/checkout@v6
 
       - name: Setup pnpm
-        uses: pnpm/action-setup@v5
+        uses: pnpm/action-setup@v4
 
       - name: Setup Node.js
         uses: actions/setup-node@v6

.github/workflows/dev.yml

@@ -1,15 +1,9 @@
 name: Dev
 on:
   push:
-    branches:
-      - main
-      - standalone
-      - "release/*"
+    branches: [ main ]
   pull_request:
-    branches:
-      - main
-      - standalone
-      - "release/*"
+    branches: [ main ]
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -32,7 +26,7 @@ jobs:
       - name: Checkout the repository
         uses: actions/checkout@v6
 
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Set up node & dependencies
         uses: actions/setup-node@v6
         with:
@@ -43,42 +37,8 @@ jobs:
       - name: Typecheck
         run: pnpm typecheck
 
-      - name: Run the client-side tests
-        run: pnpm run --filter=client test
-
-      - name: Upload client test report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: client-test-report
-          path: apps/client/test-output/vitest/html/
-          retention-days: 30
-
-      - name: Run the server-side tests
-        run: pnpm run --filter=server test
-
-      - name: Upload server test report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: server-test-report
-          path: apps/server/test-output/vitest/html/
-          retention-days: 30
-
-      - name: Run the client-standalone tests
-        # Runs the same trilium-core spec set as the server suite, but in
-        # happy-dom + sql.js WASM via BrowserSqlProvider (see
-        # apps/client-standalone/src/test_setup.ts). Catches differences
-        # between the Node-side and browser-side runtimes.
-        run: pnpm run --filter=client-standalone test
-
-      - name: Run CKEditor e2e tests
-        run: |
-          pnpm run --filter=ckeditor5-mermaid test
-          pnpm run --filter=ckeditor5-math test
-
-      - name: Run the rest of the tests
-        run: pnpm run --filter=\!client --filter=\!client-standalone --filter=\!server --filter=\!ckeditor5-mermaid --filter=\!ckeditor5-math test
+      - name: Run the unit tests
+        run: pnpm run test:all
 
   build_docker:
     name: Build Docker image
@@ -87,7 +47,7 @@ jobs:
       - test_dev
     steps:
       - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
       - name: Update build info
@@ -102,8 +62,8 @@ jobs:
           key: ${{ secrets.RELATIVE_CI_CLIENT_KEY }}
       - name: Trigger server build
         run: pnpm run server:build
-      - uses: docker/setup-buildx-action@v4
-      - uses: docker/build-push-action@v7
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/build-push-action@v6
         with:
           context: apps/server
           cache-from: type=gha
@@ -122,7 +82,7 @@ jobs:
       - name: Checkout the repository
         uses: actions/checkout@v6
 
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
@@ -137,10 +97,10 @@ jobs:
         run: echo "TEST_TAG=${TEST_TAG,,}" >> $GITHUB_ENV
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@v3
 
       - name: Build and export to Docker
-        uses: docker/build-push-action@v7
+        uses: docker/build-push-action@v6
         with:
           context: apps/server
           file: apps/server/${{ matrix.dockerfile }}

.github/workflows/i18n.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Set up node & dependencies
         uses: actions/setup-node@v6
         with:

.github/workflows/main-docker.yml

@@ -40,9 +40,9 @@ jobs:
         run: echo "TEST_TAG=${TEST_TAG,,}" >> $GITHUB_ENV
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@v3
 
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Set up node & dependencies
         uses: actions/setup-node@v6
         with:
@@ -59,7 +59,7 @@ jobs:
         run: pnpm run server:build
 
       - name: Build and export to Docker
-        uses: docker/build-push-action@v7
+        uses: docker/build-push-action@v6
         with:
           context: apps/server
           file: apps/server/${{ matrix.dockerfile }}
@@ -86,12 +86,12 @@ jobs:
 
       - name: Upload Playwright trace
         if: failure()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
         with:
           name: Playwright trace (${{ matrix.dockerfile }})
           path: test-output/playwright/output
 
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@v6
         if: ${{ !cancelled() }}
         with:
           name: Playwright report (${{ matrix.dockerfile }})
@@ -142,7 +142,7 @@ jobs:
 
       - name: Checkout repository
         uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Set up node & dependencies
         uses: actions/setup-node@v6
         with:
@@ -164,9 +164,11 @@ jobs:
 
       - name: Docker meta
         id: meta
-        uses: docker/metadata-action@v6
+        uses: docker/metadata-action@v5
         with:
-          images: ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}
+          images: |
+            ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}
+            ${{ env.DOCKERHUB_REGISTRY }}/${{ env.IMAGE_NAME }}
           tags: |
             type=ref,event=branch
             type=ref,event=tag
@@ -175,21 +177,28 @@ jobs:
             latest=false
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
+        uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@v3
 
       - name: Login to GHCR
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           registry: ${{ env.GHCR_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.DOCKERHUB_REGISTRY }}
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
       - name: Build and push by digest
         id: build
-        uses: docker/build-push-action@v7
+        uses: docker/build-push-action@v6
         with:
           context: apps/server
           file: apps/server/${{ matrix.dockerfile }}
@@ -204,7 +213,7 @@ jobs:
           touch "/tmp/digests/${digest#sha256:}"
 
       - name: Upload digest
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
         with:
           name: digests-${{ env.PLATFORM_PAIR }}-${{ matrix.dockerfile }}
           path: /tmp/digests/*
@@ -218,7 +227,7 @@ jobs:
       - build
     steps:
       - name: Download digests
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v7
         with:
           path: /tmp/digests
           pattern: digests-*
@@ -228,86 +237,79 @@ jobs:
       - name: Set TEST_TAG to lowercase
         run: echo "TEST_TAG=${TEST_TAG,,}" >> $GITHUB_ENV
 
-      - name: Set up crane
-        uses: imjasonh/setup-crane@v0.5
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}
+            ${{ env.DOCKERHUB_REGISTRY }}/${{ env.IMAGE_NAME }}
+          flavor: |
+            latest=false
 
       - name: Login to GHCR
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           registry: ${{ env.GHCR_REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Login to DockerHub
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           registry: ${{ env.DOCKERHUB_REGISTRY }}
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v6
-        with:
-          images: ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}
-          tags: |
-            type=ref,event=branch
-            type=ref,event=tag
-            type=sha
-          flavor: |
-            latest=false
-
-      - name: Verify digests exist on GHCR
+      - name: Create manifest list and push
         working-directory: /tmp/digests
         run: |
-          echo "Verifying all digests are available on GHCR..."
-          for DIGEST_FILE in *; do
-            DIGEST="sha256:${DIGEST_FILE}"
-            echo -n "  ${DIGEST}: "
-            crane manifest "${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}@${DIGEST}" > /dev/null
-            echo "OK"
-          done
+          # Extract the branch or tag name from the ref
+          REF_NAME=$(echo "${GITHUB_REF}" | sed 's/refs\/heads\///' | sed 's/refs\/tags\///')
 
-      - name: Create and push multi-arch manifest
-        working-directory: /tmp/digests
-        run: |
-          GHCR_IMAGE="${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}"
-          DOCKERHUB_IMAGE="${{ env.DOCKERHUB_REGISTRY }}/${{ env.IMAGE_NAME }}"
+          # Create and push the manifest list with both the branch/tag name and the commit SHA
+          # Note: Images are only pushed to GHCR during build, so we always reference GHCR sources
+          # and copy to DockerHub using imagetools create
+          docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
+            -t ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}:${REF_NAME} \
+            $(printf '${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}@sha256:%s ' *)
 
-          # Build -m flags for crane index append from digest files
-          MANIFEST_ARGS=""
-          for d in *; do
-            MANIFEST_ARGS="${MANIFEST_ARGS} -m ${GHCR_IMAGE}@sha256:${d}"
-          done
+          # Copy from GHCR to DockerHub (source digests only exist on GHCR)
+          docker buildx imagetools create \
+            -t ${{ env.DOCKERHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${REF_NAME} \
+            $(printf '${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}@sha256:%s ' *)
 
-          # Create multi-arch manifest for each tag from metadata, plus copy to DockerHub
-          while IFS= read -r TAG; do
-            echo "Creating manifest: ${TAG}"
-            crane index append ${MANIFEST_ARGS} -t "${TAG}"
-
-            SUFFIX="${TAG#*:}"
-            echo "Copying to DockerHub: ${DOCKERHUB_IMAGE}:${SUFFIX}"
-            crane copy "${TAG}" "${DOCKERHUB_IMAGE}:${SUFFIX}"
-          done <<< "${{ steps.meta.outputs.tags }}"
-
-          # For stable releases (tags without hyphens), also create stable + latest
-          REF_NAME="${GITHUB_REF#refs/tags/}"
+          # If the ref is a tag, also tag the image as stable as this is part of a 'release'
+          # and only go in the `if` if there is NOT a `-` in the tag's name, due to tagging of `-alpha`, `-beta`, etc...
           if [[ "${GITHUB_REF}" == refs/tags/* && ! "${REF_NAME}" =~ - ]]; then
-            echo "Creating stable tags..."
-            crane index append ${MANIFEST_ARGS} -t "${GHCR_IMAGE}:stable"
-            crane copy "${GHCR_IMAGE}:stable" "${DOCKERHUB_IMAGE}:stable"
+            # First create stable tags
+            docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
+              -t ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}:stable \
+              $(printf '${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}@sha256:%s ' *)
+
+            # Copy stable tag from GHCR to DockerHub
+            docker buildx imagetools create \
+              -t ${{ env.DOCKERHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:stable \
+              $(printf '${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}@sha256:%s ' *)
+
+            # Small delay to ensure stable tag is fully propagated
+            sleep 5
+
+            # Now update latest tags
+            docker buildx imagetools create \
+              -t ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}:latest \
+              ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}:stable
+
+            docker buildx imagetools create \
+              -t ${{ env.DOCKERHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:latest \
+              ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}:stable
 
-            echo "Creating latest tags..."
-            crane copy "${GHCR_IMAGE}:stable" "${GHCR_IMAGE}:latest"
-            crane copy "${GHCR_IMAGE}:latest" "${DOCKERHUB_IMAGE}:latest"
           fi
 
-      - name: Inspect manifests
+      - name: Inspect image
         run: |
-          REF_NAME="${GITHUB_REF#refs/heads/}"
-          REF_NAME="${REF_NAME#refs/tags/}"
-          echo "=== GHCR ==="
-          crane manifest "${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}:${REF_NAME}"
-          echo ""
-          echo "=== DockerHub ==="
-          crane manifest "${{ env.DOCKERHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${REF_NAME}"
+          docker buildx imagetools inspect ${{ env.GHCR_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.meta.outputs.version }}
+          docker buildx imagetools inspect ${{ env.DOCKERHUB_REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.meta.outputs.version }}

.github/workflows/nightly.yml

@@ -61,7 +61,7 @@ jobs:
     runs-on: ${{ matrix.os.image }}
     steps:
       - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Set up node & dependencies
         uses: actions/setup-node@v6
         with:
@@ -69,8 +69,6 @@ jobs:
           cache: 'pnpm'
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
-        env:
-          npm_config_package_import_method: copy
       - name: Update nightly version
         run: pnpm run chore:ci-update-nightly-version
       - name: Run the build
@@ -89,11 +87,10 @@ jobs:
           APPLE_ID: ${{ secrets.APPLE_ID }}
           APPLE_ID_PASSWORD: ${{ secrets.APPLE_ID_PASSWORD }}
           WINDOWS_SIGN_EXECUTABLE: ${{ vars.WINDOWS_SIGN_EXECUTABLE }}
-          WINDOWS_SIGN_ERROR_LOG: ${{ vars.WINDOWS_SIGN_ERROR_LOG }}
           GPG_SIGNING_KEY: ${{ secrets.GPG_SIGN_KEY }}
 
       - name: Publish release
-        uses: softprops/action-gh-release@v2.6.1
+        uses: softprops/action-gh-release@v2.5.0
         if: ${{ github.event_name != 'pull_request' }}
         with:
           make_latest: false
@@ -105,7 +102,7 @@ jobs:
           name: Nightly Build
 
       - name: Publish artifacts
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
         if: ${{ github.event_name == 'pull_request' }}
         with:
           name: TriliumNotes ${{ matrix.os.name }} ${{ matrix.arch }}
@@ -134,7 +131,7 @@ jobs:
           arch: ${{ matrix.arch }}
 
       - name: Publish release
-        uses: softprops/action-gh-release@v2.6.1
+        uses: softprops/action-gh-release@v2.5.0
         if: ${{ github.event_name != 'pull_request' }}
         with:
           make_latest: false

.github/workflows/playwright.yml

@@ -38,7 +38,7 @@ jobs:
           filter: tree:0
           fetch-depth: 0
 
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - uses: actions/setup-node@v6
         with:
           node-version: 24
@@ -77,7 +77,7 @@ jobs:
 
       - name: Upload test report
         if: failure()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
         with:
           name: e2e report ${{ matrix.arch }}
           path: apps/server-e2e/test-output

.github/workflows/release.yml

@@ -17,22 +17,10 @@ jobs:
     steps:
       - uses: actions/checkout@v6
 
-      - uses: pnpm/action-setup@v5
-      - name: Set up node & dependencies
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: 'pnpm'
-
-      - name: Install dependencies
-        run: pnpm install --filter source --frozen-lockfile --ignore-scripts
-
       - name: Check version consistency
         run: pnpm tsx ${{ github.workspace }}/scripts/check-version-consistency.ts ${{ github.ref_name }}
   make-electron:
     name: Make Electron
-    needs:
-      - sanity-check
     strategy:
       fail-fast: false
       matrix:
@@ -66,7 +54,7 @@ jobs:
     runs-on: ${{ matrix.os.image }}
     steps:
       - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Set up node & dependencies
         uses: actions/setup-node@v6
         with:
@@ -90,19 +78,16 @@ jobs:
           APPLE_ID: ${{ secrets.APPLE_ID }}
           APPLE_ID_PASSWORD: ${{ secrets.APPLE_ID_PASSWORD }}
           WINDOWS_SIGN_EXECUTABLE: ${{ vars.WINDOWS_SIGN_EXECUTABLE }}
-          WINDOWS_SIGN_ERROR_LOG: ${{ vars.WINDOWS_SIGN_ERROR_LOG }}
           GPG_SIGNING_KEY: ${{ secrets.GPG_SIGN_KEY }}
 
       - name: Upload the artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
         with:
           name: release-desktop-${{ matrix.os.name }}-${{ matrix.arch }}
           path: apps/desktop/upload/*.*
 
   build_server:
     name: Build Linux Server
-    needs:
-      - sanity-check
     strategy:
       fail-fast: false
       matrix:
@@ -123,7 +108,7 @@ jobs:
           arch: ${{ matrix.arch }}
 
       - name: Upload the artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
         with:
           name: release-server-linux-${{ matrix.arch }}
           path: upload/*.*
@@ -143,14 +128,14 @@ jobs:
             docs/Release Notes
 
       - name: Download all artifacts
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v7
         with:
           merge-multiple: true
           pattern: release-*
           path: upload
 
       - name: Publish stable release
-        uses: softprops/action-gh-release@v2.6.1
+        uses: softprops/action-gh-release@v2.5.0
         with:
           draft: false
           body_path: docs/Release Notes/Release Notes/${{ github.ref_name }}.md

.github/workflows/web-clipper.yml

@@ -32,7 +32,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Set up node & dependencies
         uses: actions/setup-node@v6
         with:
@@ -48,7 +48,7 @@ jobs:
           pnpm --filter web-clipper zip:firefox
 
       - name: Upload build artifacts
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
         if: ${{ !startsWith(github.ref, 'refs/tags/web-clipper-v') }}
         with:
           name: web-clipper-extension
@@ -58,7 +58,7 @@ jobs:
           compression-level: 0
 
       - name: Release web clipper extension
-        uses: softprops/action-gh-release@v2.6.1
+        uses: softprops/action-gh-release@v2.5.0
         if: ${{ startsWith(github.ref, 'refs/tags/web-clipper-v') }}
         with:
           draft: false

.github/workflows/website.yml

@@ -26,7 +26,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
       - name: Set up node & dependencies
         uses: actions/setup-node@v6
         with:

.gitignore

@@ -46,11 +46,9 @@ upload
 
 /.direnv
 /result
+.svelte-kit
 
 # docs
 site/
 apps/*/coverage
 scripts/translation/.language*.json
-
-# AI
-.claude/settings.local.json

.mcp.json

@@ -1,8 +0,0 @@
-{
-  "mcpServers": {
-    "trilium": {
-      "type": "http",
-      "url": "http://localhost:8080/mcp"
-    }
-  }
-}

.nvmrc

@@ -1 +1 @@
-24.14.1
+24.13.0

.vscode/launch.json

@@ -1,57 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "Launch client (Chrome)",
-      "request": "launch",
-      "type": "chrome",
-      "url": "http://localhost:8080",
-      "webRoot": "${workspaceFolder}/apps/client"
-    },
-    {
-      "name": "Launch server",
-      "type": "node",
-      "request": "launch",
-      "program": "${workspaceFolder}/apps/server/src/main.ts",
-      "runtimeExecutable": "${workspaceFolder}/node_modules/.bin/tsx",
-      "env": {
-        "NODE_ENV": "development",
-        "TRILIUM_ENV": "dev",
-        "TRILIUM_DATA_DIR": "${input:trilium_data_dir}",
-        "TRILIUM_RESOURCE_DIR": "${workspaceFolder}/apps/server/src"
-      },
-      "autoAttachChildProcesses": true,
-      "cwd": "${workspaceFolder}",
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "skipFiles": ["<node_internals>/**", "${workspaceFolder}/node_modules/**"]
-    },
-    {
-      "name": "Launch Vitest with current test file",
-      "type": "node",
-      "request": "launch",
-      "autoAttachChildProcesses": true,
-      "program": "${workspaceFolder}/node_modules/vitest/vitest.mjs",
-      "args": ["run", "${relativeFile}"],
-      "smartStep": true,
-      "console": "integratedTerminal",
-      "skipFiles": ["<node_internals>/**", "**/node_modules/**"],
-      "cwd": "${workspaceFolder}"
-    }
-  ],
-  "compounds": [
-    {
-      "name": "Launch client (Chrome) and server",
-      "configurations": ["Launch server","Launch client (Chrome)"],
-      "stopAll": true
-    }
-  ],
-  "inputs": [
-    {
-      "id": "trilium_data_dir",
-      "type": "promptString",
-      "description": "Select Trilum Notes data directory",
-      "default": "${workspaceFolder}/apps/server/data"
-    }
-  ]
-}

.vscode/settings.json

@@ -42,8 +42,5 @@
     },
     "eslint.rules.customizations": [
         { "rule": "*", "severity": "warn" }
-    ],
-    "cSpell.words": [
-      "Trilium"
     ]
-}
+}

CLAUDE.md

@@ -2,318 +2,151 @@
 
 This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
 
-> **Note**: When updating this file, also update `.github/copilot-instructions.md` to keep both AI coding assistants in sync.
-
 ## Overview
 
-Trilium Notes is a hierarchical note-taking application with synchronization, scripting, and rich text editing. TypeScript monorepo using pnpm with multiple apps and shared packages.
+Trilium Notes is a hierarchical note-taking application with advanced features like synchronization, scripting, and rich text editing. It's built as a TypeScript monorepo using pnpm, with multiple applications and shared packages.
 
 ## Development Commands
 
-```bash
-# Setup
-corepack enable && pnpm install
+### Setup
+- `pnpm install` - Install all dependencies
+- `corepack enable` - Enable pnpm if not available
 
-# Run
-pnpm server:start              # Dev server at http://localhost:8080
-pnpm desktop:start             # Electron dev app
-pnpm standalone:start          # Standalone client dev
+### Running Applications
+- `pnpm run server:start` - Start development server (http://localhost:8080)
+- `pnpm run server:start-prod` - Run server in production mode
 
-# Build
-pnpm client:build              # Frontend
-pnpm server:build              # Backend
-pnpm desktop:build             # Electron
+### Building
+- `pnpm run client:build` - Build client application
+- `pnpm run server:build` - Build server application
+- `pnpm run electron:build` - Build desktop application
 
-# Test
-pnpm test:all                  # All tests (parallel + sequential)
-pnpm test:parallel             # Client + most package tests
-pnpm test:sequential           # Server, ckeditor5-mermaid, ckeditor5-math (shared DB)
-pnpm --filter server test      # Single package tests
-pnpm coverage                  # Coverage reports
+### Testing
+- `pnpm test:all` - Run all tests (parallel + sequential)
+- `pnpm test:parallel` - Run tests that can run in parallel
+- `pnpm test:sequential` - Run tests that must run sequentially (server, ckeditor5-mermaid, ckeditor5-math)
+- `pnpm coverage` - Generate coverage reports
 
-# Lint & Format
-pnpm dev:linter-check          # ESLint check
-pnpm dev:linter-fix            # ESLint fix
-pnpm dev:format-check          # Format check (stricter stylistic rules)
-pnpm dev:format-fix            # Format fix
-pnpm typecheck                 # TypeScript type check across all projects
-```
+## Architecture Overview
 
-**Running a single test file**: `pnpm --filter server test spec/etapi/search.spec.ts`
+### Monorepo Structure
+- **apps/**: Runnable applications
+  - `client/` - Frontend application (shared by server and desktop)
+  - `server/` - Node.js server with web interface
+  - `desktop/` - Electron desktop application
+  - `web-clipper/` - Browser extension for saving web content
+  - Additional tools: `db-compare`, `dump-db`, `edit-docs`
 
-## Main Applications
+- **packages/**: Shared libraries
+  - `commons/` - Shared interfaces and utilities
+  - `ckeditor5/` - Custom rich text editor with Trilium-specific plugins
+  - `codemirror/` - Code editor customizations
+  - `highlightjs/` - Syntax highlighting
+  - Custom CKEditor plugins: `ckeditor5-admonition`, `ckeditor5-footnotes`, `ckeditor5-math`, `ckeditor5-mermaid`
 
-The four main apps share `packages/trilium-core/` for business logic but differ in runtime:
+### Core Architecture Patterns
 
-- **client** (`apps/client/`): Preact frontend with jQuery widget system. Shared UI layer used by both server and desktop.
-- **server** (`apps/server/`): Node.js backend (Express, better-sqlite3). Serves the client and provides REST/WebSocket APIs.
-- **desktop** (`apps/desktop/`): Electron wrapper around server + client, running both in a single process.
-- **standalone** (`apps/client-standalone/` + `apps/standalone-desktop/`): Runs the entire stack in the browser — server logic compiled to WASM via sql.js, executed in a service worker. No Node.js dependency at runtime.
+#### Three-Layer Cache System
+- **Becca** (Backend Cache): Server-side entity cache (`apps/server/src/becca/`)
+- **Froca** (Frontend Cache): Client-side mirror of backend data (`apps/client/src/services/froca.ts`)
+- **Shaca** (Share Cache): Optimized cache for shared/published notes (`apps/server/src/share/`)
 
-## Monorepo Structure
+#### Entity System
+Core entities are defined in `apps/server/src/becca/entities/`:
+- `BNote` - Notes with content and metadata
+- `BBranch` - Hierarchical relationships between notes (allows multiple parents)
+- `BAttribute` - Key-value metadata attached to notes
+- `BRevision` - Note version history
+- `BOption` - Application configuration
 
-```
-apps/
-  client/               # Preact frontend (shared by server, desktop, standalone)
-  server/               # Node.js backend (Express, better-sqlite3)
-  desktop/              # Electron (bundles server + client)
-  client-standalone/    # Standalone client (WASM + service workers, no Node.js)
-  standalone-desktop/   # Standalone desktop variant
-  server-e2e/           # Playwright E2E tests for server
-  web-clipper/          # Browser extension
-  website/              # Project website
-  db-compare/, dump-db/, edit-docs/, build-docs/, icon-pack-builder/
-
-packages/
-  trilium-core/         # Core business logic: entities, services, SQL, sync
-  commons/              # Shared interfaces and utilities
-  ckeditor5/            # Custom rich text editor bundle
-  codemirror/           # Code editor integration
-  highlightjs/          # Syntax highlighting
-  share-theme/          # Theme for shared/published notes
-  ckeditor5-admonition/, ckeditor5-footnotes/, ckeditor5-math/, ckeditor5-mermaid/
-  ckeditor5-keyboard-marker/, express-partial-content/, pdfjs-viewer/, splitjs/
-  turndown-plugin-gfm/
-```
-
-Use `pnpm --filter <package-name> <command>` to run commands in specific packages.
-
-## Core Architecture
-
-### Three-Layer Cache System
-
-All data access goes through cache layers — never bypass with direct DB queries:
-
-- **Becca** (`packages/trilium-core/src/becca/`): Server-side entity cache. Access via `becca.notes[noteId]`.
-- **Froca** (`apps/client/src/services/froca.ts`): Client-side mirror synced via WebSocket. Access via `froca.getNote()`.
-- **Shaca** (`apps/server/src/share/`): Optimized cache for shared/published notes.
-
-**Critical**: Always use cache methods, not direct DB writes. Cache methods create `EntityChange` records needed for synchronization.
-
-### Entity System
-
-Core entities live in `packages/trilium-core/src/becca/entities/` (not `apps/server/`):
-
-- `BNote` — Notes with content and metadata
-- `BBranch` — Multi-parent tree relationships (cloning supported)
-- `BAttribute` — Key-value metadata (labels and relations)
-- `BRevision` — Version history
-- `BOption` — Application configuration
-- `BBlob` — Binary content storage
-
-Entities extend `AbstractBeccaEntity<T>` with built-in change tracking, hash generation, and date management.
-
-### Entity Change & Sync Protocol
-
-Every entity modification creates an `EntityChange` record driving sync:
-1. Login with HMAC authentication (document secret + timestamp)
-2. Push changes → Pull changes → Push again (conflict resolution)
-3. Content hash verification with retry loop
-
-Sync services: `packages/trilium-core/src/services/sync.ts`, `syncMutexService`, `syncUpdateService`.
-
-### Widget-Based UI
-
-Frontend widgets in `apps/client/src/widgets/`:
-- `BasicWidget` / `TypedBasicWidget` — Base classes (jQuery `this.$widget` for DOM)
-- `NoteContextAwareWidget` — Responds to note changes
-- `RightPanelWidget` — Sidebar widgets with position ordering
+#### Widget-Based UI
+Frontend uses a widget system (`apps/client/src/widgets/`):
+- `BasicWidget` - Base class for all UI components
+- `NoteContextAwareWidget` - Widgets that respond to note changes
+- `RightPanelWidget` - Widgets displayed in the right panel
 - Type-specific widgets in `type_widgets/` directory
 
-**Widget lifecycle**: `doRenderBody()` for initial render, `refreshWithNote()` for note changes, `entitiesReloadedEvent({loadResults})` for entity updates. Uses jQuery — don't mix React patterns.
+#### API Architecture
+- **Internal API**: REST endpoints in `apps/server/src/routes/api/`
+- **ETAPI**: External API for third-party integrations (`apps/server/src/etapi/`)
+- **WebSocket**: Real-time synchronization (`apps/server/src/services/ws.ts`)
 
-#### Reusable Preact Components
-Common UI components are available in `apps/client/src/widgets/react/` — prefer reusing these over creating custom implementations:
-- `NoItems` - Empty state placeholder with icon and message (use for "no results", "too many items", error states)
-- `ActionButton` - Consistent button styling with icon support
-- `FormTextBox` - Text input with validation and controlled input handling
-- `Slider` - Range slider with label
-- `Checkbox`, `RadioButton` - Form controls
-- `CollapsibleSection` - Expandable content sections
+### Key Files for Understanding Architecture
 
-Fluent builder pattern: `.child()`, `.class()`, `.css()` chaining with position-based ordering.
+1. **Application Entry Points**:
+   - `apps/server/src/main.ts` - Server startup
+   - `apps/client/src/desktop.ts` - Client initialization
 
-### API Architecture
+2. **Core Services**:
+   - `apps/server/src/becca/becca.ts` - Backend data management
+   - `apps/client/src/services/froca.ts` - Frontend data synchronization
+   - `apps/server/src/services/backend_script_api.ts` - Scripting API
 
-- **Internal API** (`apps/server/src/routes/api/`): REST endpoints, trusts frontend
-- **ETAPI** (`apps/server/src/etapi/`): External API with basic auth tokens — maintain backwards compatibility
-- **WebSocket** (`apps/server/src/services/ws.ts`): Real-time sync
+3. **Database Schema**:
+   - `apps/server/src/assets/db/schema.sql` - Core database structure
 
-### Platform Abstraction
+4. **Configuration**:
+   - `package.json` - Project dependencies and scripts
 
-`packages/trilium-core/src/services/platform.ts` defines `PlatformProvider` interface with implementations in `apps/desktop/`, `apps/server/`, and `apps/client-standalone/`. Singleton via `initPlatform()`/`getPlatform()`.
+## Note Types and Features
 
-**PlatformProvider** provides:
-- `crash(message)` — Platform-specific fatal error handling
-- `getEnv(key)` — Environment variable access (server/desktop use `process.env`, standalone maps URL query params like `?safeMode` → `TRILIUM_SAFE_MODE`)
-- `isElectron`, `isMac`, `isWindows` — Platform detection flags
+Trilium supports multiple note types, each with specialized widgets:
+- **Text**: Rich text with CKEditor5 (markdown import/export)
+- **Code**: Syntax-highlighted code editing with CodeMirror
+- **File**: Binary file attachments
+- **Image**: Image display with editing capabilities
+- **Canvas**: Drawing/diagramming with Excalidraw
+- **Mermaid**: Diagram generation
+- **Relation Map**: Visual note relationship mapping
+- **Web View**: Embedded web pages
+- **Doc/Book**: Hierarchical documentation structure
 
-**Critical rules for `trilium-core`**:
-- **No `process.env` in core** — use `getPlatform().getEnv()` instead (not available in standalone/browser)
-- **No `import path from "path"` in core** — Node's `path` module is externalized in browser builds. Use `packages/trilium-core/src/services/utils/path.ts` for `extname()`/`basename()` equivalents
-- **No Node.js built-in modules in core** — core runs in both Node.js and the browser (standalone). Use platform-agnostic alternatives or platform providers
-- **Platform detection via functions** — `isElectron()`, `isMac()`, `isWindows()` from `utils/index.ts` are functions (not constants) that call `getPlatform()`. They can only be called after `initializeCore()`, not at module top-level. If used in static definitions, wrap in a closure: `value: () => isWindows() ? "0.9" : "1.0"`
-- **Barrel import caution** — `import { x } from "@triliumnext/core"` loads ALL core exports. Early-loading modules like `config.ts` should import specific subpaths (e.g. `@triliumnext/core/src/services/utils/index`) to avoid circular dependencies or initialization ordering issues
-- **Electron IPC** — In desktop mode, client API calls use Electron IPC (not HTTP). The IPC handler in `apps/server/src/routes/electron.ts` must be registered via `utils.isElectron` from the **server's** utils (which correctly checks `process.versions["electron"]`), not from core's utils
-
-### Binary Utilities
-
-Use utilities from `packages/trilium-core/src/services/utils/binary.ts` for string/buffer conversions instead of manual `TextEncoder`/`TextDecoder` or `Buffer.from()` calls:
-
-- **`wrapStringOrBuffer(input)`** — Converts `string` to `Uint8Array`, returns `Uint8Array` unchanged. Use when a function expects `Uint8Array` but receives `string | Uint8Array`.
-- **`unwrapStringOrBuffer(input)`** — Converts `Uint8Array` to `string`, returns `string` unchanged. Use when a function expects `string` but receives `string | Uint8Array`.
-- **`encodeBase64(input)`** / **`decodeBase64(input)`** — Base64 encoding/decoding that works in both Node.js and browser.
-- **`encodeUtf8(string)`** / **`decodeUtf8(buffer)`** — UTF-8 encoding/decoding.
-
-Import via `import { binary_utils } from "@triliumnext/core"` or directly from the module.
-
-### Database
-
-SQLite via `better-sqlite3`. SQL abstraction in `packages/trilium-core/src/services/sql/` with `DatabaseProvider` interface, prepared statement caching, and transaction support.
-
-- Schema: `apps/server/src/assets/db/schema.sql`
-- Migrations: `apps/server/src/migrations/YYMMDD_HHMM__description.sql`
+## Development Guidelines
 
 ### Testing Strategy
 - Server tests run sequentially due to shared database
 - Client tests can run in parallel
 - E2E tests use Playwright for both server and desktop apps
 - Build validation tests check artifact integrity
-- **Write concise tests**: Group related assertions together in a single test case rather than creating many one-shot tests
-- **Extract and test business logic**: When adding pure business logic (e.g., data transformations, migrations, validations), extract it as a separate function and always write unit tests for it
+
+### Scripting System
+Trilium provides powerful user scripting capabilities:
+- Frontend scripts run in browser context
+- Backend scripts run in Node.js context with full API access
+- Script API documentation available in `docs/Script API/`
 
 ### Internationalization
 - Translation files in `apps/client/src/translations/`
 - Supported languages: English, German, Spanish, French, Romanian, Chinese
-- **Only add new translation keys to `en/translation.json`** — translations for other languages are managed via Weblate and will be contributed by the community
-- Third-party components (e.g., mind-map context menu) should use i18next `t()` for their labels, with the English strings added to `en/translation.json` under a dedicated namespace (e.g., `"mind-map"`)
-- When a translated string contains **interpolated components** (e.g. links, note references) whose order may vary across languages, use `<Trans>` from `react-i18next` instead of `t()`. This lets translators reorder components freely (e.g. `"<Note/> in <Parent/>"` vs `"in <Parent/>, <Note/>"`)
-- When adding a new locale, follow the step-by-step guide in `docs/Developer Guide/Developer Guide/Concepts/Internationalisation  Translations/Adding a new locale.md`
-- **Server-side translations** (e.g. hidden subtree titles) go in `apps/server/src/assets/translations/en/server.json`, not in the client `translation.json`
 
-#### Client vs Server Translation Usage
-- **Client-side**: `import { t } from "../services/i18n"` with keys in `apps/client/src/translations/en/translation.json`
-- **Server-side**: `import { t } from "i18next"` with keys in `apps/server/src/assets/translations/en/server.json`
-- **Interpolation**: Use `{{variable}}` for normal interpolation; use `{{- variable}}` (with hyphen) for **unescaped** interpolation when the value contains special characters like quotes that shouldn't be HTML-escaped
+### Security Considerations
+- Per-note encryption with granular protected sessions
+- CSRF protection for API endpoints
+- OpenID and TOTP authentication support
+- Sanitization of user-generated content
 
-### Electron Desktop App
-- Desktop entry point: `apps/desktop/src/main.ts`, window management: `apps/server/src/services/window.ts`
-- IPC communication: use `electron.ipcMain.on(channel, handler)` on server side, `electron.ipcRenderer.send(channel, data)` on client side
-- Electron-only features should check `isElectron()` from `apps/client/src/services/utils.ts` (client) or `utils.isElectron` (server)
+## Common Development Tasks
 
-Three inheritance mechanisms:
-1. **Standard**: `note.getInheritableAttributes()` walks parent tree
-2. **Child prefix**: `child:label` on parent copies to children
-3. **Template relation**: `#template=noteNoteId` includes template's inheritable attributes
+### Adding New Note Types
+1. Create widget in `apps/client/src/widgets/type_widgets/`
+2. Register in `apps/client/src/services/note_types.ts`
+3. Add backend handling in `apps/server/src/services/notes.ts`
 
-### Attribute Inheritance
+### Extending Search
+- Search expressions handled in `apps/server/src/services/search/`
+- Add new search operators in search context files
 
-Use `note.getOwnedAttribute()` for direct, `note.getAttribute()` for inherited.
-### Client-Side API Restrictions
-- **Do not use `crypto.randomUUID()`** or other Web Crypto APIs that require secure contexts - Trilium can run over HTTP, not just HTTPS
-- Use `randomString()` from `apps/client/src/services/utils.ts` for generating IDs instead
-
-### Storing User Preferences
-- **Do not use `localStorage`** for user preferences — Trilium has a synced options system that persists across devices
-- To add a new user preference:
-  1. Add the option type to `OptionDefinitions` in `packages/commons/src/lib/options_interface.ts`
-  2. Add a default value in `apps/server/src/services/options_init.ts` in the `defaultOptions` array
-  3. **Whitelist the option** in `apps/server/src/routes/api/options.ts` by adding it to `ALLOWED_OPTIONS` (required for client updates)
-  4. Use `useTriliumOption("optionName")` hook in React components to read/write the option
-- Available hooks: `useTriliumOption` (string), `useTriliumOptionBool`, `useTriliumOptionInt`, `useTriliumOptionJson`
-- See `docs/Developer Guide/Developer Guide/Concepts/Options/Creating a new option.md` for detailed documentation
-
-### Shared Types Policy
-- Types shared between client and server belong in `@triliumnext/commons` (`packages/commons/src/lib/`)
-- Import shared types directly from `@triliumnext/commons` - do not re-export them from app-specific modules
-- Keep app-specific types (e.g., `LlmProvider` for server, `StreamCallbacks` for client) in their respective apps
-
-## Important Patterns
-
-- **Protected notes**: Check `note.isContentAvailable()` before accessing content; use `note.getTitleOrProtected()` for safe title access
-- **Long operations**: Use `TaskContext` for progress reporting via WebSocket
-- **Event system** (`packages/trilium-core/src/services/events.ts`): Events emitted in order (notes → branches → attributes) during load for referential integrity
-- **Search**: Expression-based, scoring happens in-memory — cannot add SQL-level LIMIT/OFFSET without losing scoring
-- **Widget cleanup**: Unsubscribe from events in `cleanup()`/`doDestroy()` to prevent memory leaks
-
-## Code Style
-
-- 4-space indentation, semicolons always required
-- Double quotes (enforced by format config)
-- Max line length: 100 characters
-- Unix line endings
-- Import sorting via `eslint-plugin-simple-import-sort`
-
-## Testing
-
-- **Server tests** (`apps/server/spec/`): Vitest, must run sequentially (shared DB), forks pool, max 6 workers
-- **Client tests** (`apps/client/src/`): Vitest with happy-dom environment, can run in parallel
-- **E2E tests** (`apps/server-e2e/`): Playwright, Chromium, server started automatically on port 8082
-- **ETAPI tests** (`apps/server/spec/etapi/`): External API contract tests
-
-## Documentation
-
-- `docs/Script API/` — Auto-generated, never edit directly
-- `docs/User Guide/` — Edit via `pnpm edit-docs:edit-docs`, not manually
-- `docs/Developer Guide/` and `docs/Release Notes/` — Safe for direct Markdown editing
-
-## Key Entry Points
-
-- `apps/server/src/main.ts` — Server startup
-- `apps/client/src/desktop.ts` — Client initialization
-- `packages/trilium-core/src/becca/becca.ts` — Backend data management
-- `apps/client/src/services/froca.ts` — Frontend cache
-- `apps/server/src/routes/routes.ts` — API route registration
-- `packages/trilium-core/src/services/sql/sql.ts` — Database abstraction
-
-### Adding Hidden System Notes
-The hidden subtree (`_hidden`) contains system notes with predictable IDs (prefixed with `_`). Defined in `apps/server/src/services/hidden_subtree.ts` via the `HiddenSubtreeItem` interface from `@triliumnext/commons`.
-
-1. Add the note definition to `buildHiddenSubtreeDefinition()` in `apps/server/src/services/hidden_subtree.ts`
-2. Add a translation key for the title in `apps/server/src/assets/translations/en/server.json` under `"hidden-subtree"`
-3. The note is auto-created on startup by `checkHiddenSubtree()` — uses deterministic IDs so all sync cluster instances generate the same structure
-4. Key properties: `id` (must start with `_`), `title`, `type`, `icon` (format: `bx-icon-name` without `bx ` prefix), `attributes`, `children`, `content`
-5. Use `enforceAttributes: true` to keep attributes in sync, `enforceBranches: true` for correct placement, `enforceDeleted: true` to remove deprecated notes
-6. For launcher bar entries, see `hidden_subtree_launcherbar.ts`; for templates, see `hidden_subtree_templates.ts`
-
-### Writing to Notes from Server Services
-- `note.setContent()` requires a CLS (Continuation Local Storage) context — wrap calls in `cls.init(() => { ... })` (from `apps/server/src/services/cls.ts`)
-- Operations called from Express routes already have CLS context; standalone services (schedulers, Electron IPC handlers) do not
-
-### Adding New LLM Tools
-Tools are defined using `defineTools()` in `apps/server/src/services/llm/tools/` and automatically registered for both the LLM chat and MCP server.
-
-1. Add the tool definition in the appropriate module (`note_tools.ts`, `attribute_tools.ts`, `attachment_tools.ts`, `hierarchy_tools.ts`) or create a new module
-2. Each tool needs: `description`, `inputSchema` (Zod), `execute` function, and optionally `mutates: true` for write operations
-3. If creating a new module, wrap tools in `defineTools({...})` and add the registry to `allToolRegistries` in `tools/index.ts`
-4. Add a client-side friendly name in `apps/client/src/translations/en/translation.json` under `llm.tools.<tool_name>` — use **imperative tense** (e.g. "Search notes", "Create note", "Get attributes"), not present continuous
-5. Use ETAPI (`apps/server/src/etapi/`) as inspiration for what fields to expose, but **do not import ETAPI mappers** — inline the field mappings directly in the tool so the LLM layer stays decoupled from the API layer
-
-### Updating PDF.js
-1. Update `pdfjs-dist` version in `packages/pdfjs-viewer/package.json`
-2. Run `npx tsx scripts/update-viewer.ts` from that directory
-3. Run `pnpm build` to verify success
-4. Commit all changes including updated viewer files
+### Custom CKEditor Plugins
+- Create new package in `packages/` following existing plugin structure
+- Register in `packages/ckeditor5/src/plugins.ts`
 
 ### Database Migrations
 - Add migration scripts in `apps/server/src/migrations/`
 - Update schema in `apps/server/src/assets/db/schema.sql`
 
-### Server-Side Static Assets
-- Static assets (templates, SQL, translations, etc.) go in `apps/server/src/assets/`
-- Access them at runtime via `RESOURCE_DIR` from `apps/server/src/services/resource_dir.ts` (e.g. `path.join(RESOURCE_DIR, "llm", "skills", "file.md")`)
-- **Do not use `import.meta.url`/`fileURLToPath`** to resolve file paths — the server is bundled into CJS for production, so `import.meta.url` will not point to the source directory
-- **Do not use `__dirname` with relative paths** from source files — after bundling, `__dirname` points to the bundle output, not the original source tree
-
-## MCP Server
-- Trilium exposes an MCP (Model Context Protocol) server at `http://localhost:8080/mcp`, configured in `.mcp.json`
-- The MCP server is **only available when the Trilium server is running** (`pnpm run server:start`)
-- It provides tools for reading, searching, and modifying notes directly from the AI assistant
-- Use it to interact with actual note data when developing or debugging note-related features
-
 ## Build System Notes
 - Uses pnpm for monorepo management
 - Vite for fast development builds
 - ESBuild for production optimization
 - pnpm workspaces for dependency management
-- Docker support with multi-stage builds
+- Docker support with multi-stage builds

SECURITY.md

@@ -2,87 +2,12 @@
 
 ## Supported Versions
 
-Only the latest stable minor release receives security fixes.
+In the (still active) 0.X phase of the project only the latest stable minor release is getting bugfixes (including security ones).
 
-For example, if the latest stable version is 0.92.3 and the latest beta is 0.93.0-beta, then only the 0.92.x line will receive security patches. Older versions (like 0.91.x) will not receive fixes.
+So e.g. if the latest stable version is 0.42.3 and the latest beta version is 0.43.0-beta, then 0.42 line will still get security fixes but older versions (like 0.41.X) won't get any fixes.
 
-This policy may be altered on a case-by-case basis for critical vulnerabilities.
+Description above is a general rule and may be altered on case by case basis.
 
 ## Reporting a Vulnerability
 
-**Please report all security vulnerabilities through [GitHub Security Advisories](https://github.com/TriliumNext/Notes/security/advisories/new).**
-
-We do not accept security reports via email, public issues, or other channels. GitHub Security Advisories allows us to:
-- Discuss and triage vulnerabilities privately
-- Coordinate fixes before public disclosure
-- Credit reporters appropriately
-- Publish advisories with CVE identifiers
-
-### What to Include
-
-When reporting, please provide:
-- A clear description of the vulnerability
-- Steps to reproduce or proof-of-concept
-- Affected versions (if known)
-- Potential impact assessment
-- Any suggested mitigations or fixes
-
-### Response Timeline
-
-- **Initial response**: Within 7 days
-- **Triage decision**: Within 14 days
-- **Fix timeline**: Depends on severity and complexity
-
-## Scope
-
-### In Scope
-
-- Remote code execution
-- Authentication/authorization bypass
-- Cross-site scripting (XSS) that affects other users
-- SQL injection
-- Path traversal
-- Sensitive data exposure
-- Privilege escalation
-
-### Out of Scope (Won't Fix)
-
-The following are considered out of scope or accepted risks:
-
-#### Self-XSS / Self-Injection
-Trilium is a personal knowledge base where users have full control over their own data. Users can intentionally create notes containing scripts, HTML, or other executable content. This is by design - Trilium's scripting system allows users to extend functionality with custom JavaScript.
-
-Vulnerabilities that require a user to inject malicious content into their own notes and then view it themselves are not considered security issues.
-
-#### Electron Architecture (nodeIntegration)
-Trilium's desktop application runs with `nodeIntegration: true` to enable its powerful scripting features. This is an intentional design decision, similar to VS Code extensions having full system access. We mitigate risks by:
-- Sanitizing content at input boundaries
-- Fixing specific XSS vectors as they're discovered
-- Using Electron fuses to prevent external abuse
-
-#### Authenticated User Actions
-Actions that require valid authentication and only affect the authenticated user's own data are generally not vulnerabilities.
-
-#### Denial of Service via Resource Exhaustion
-Creating extremely large notes or performing many operations is expected user behavior in a note-taking application.
-
-#### Missing Security Headers on Non-Sensitive Endpoints
-We implement security headers where they provide meaningful protection, but may omit them on endpoints where they provide no practical benefit.
-
-## Coordinated Disclosure
-
-We follow a coordinated disclosure process:
-
-1. **Report received** - We acknowledge receipt and begin triage
-2. **Fix developed** - We develop and test a fix privately
-3. **Release prepared** - Security release is prepared with vague changelog
-4. **Users notified** - Release is published, users encouraged to upgrade
-5. **Advisory published** - After reasonable upgrade window (typically 2-4 weeks), full advisory is published
-
-We appreciate reporters allowing us time to fix issues before public disclosure. We aim to credit all reporters in published advisories unless they prefer to remain anonymous.
-
-## Security Updates
-
-Security fixes are released as patch versions (e.g., 0.92.1 → 0.92.2) to minimize upgrade friction. We recommend all users keep their installations up to date.
-
-Subscribe to GitHub releases or watch the repository to receive notifications of new releases.
+You can report low severity vulnerabilities as GitHub issues, more severe vulnerabilities should be reported to the email [contact@eliandoran.me](mailto:contact@eliandoran.me)

apps/build-docs/package.json

@@ -1,30 +1,22 @@
 {
   "name": "build-docs",
   "version": "1.0.0",
-  "description": "Build documentation from Trilium notes",
+  "description": "",
   "main": "src/main.ts",
-  "bin": {
-    "trilium-build-docs": "dist/cli.js"
-  },
   "scripts": {
-    "start": "tsx .",
-    "cli": "tsx src/cli.ts",
-    "build": "tsx scripts/build.ts"
+    "start": "tsx ."
   },
   "keywords": [],
   "author": "Elian Doran <contact@eliandoran.me>",
   "license": "AGPL-3.0-only",
-  "packageManager": "pnpm@10.33.0",
-  "dependencies": {
-    "@triliumnext/core": "workspace:*",
-    "@triliumnext/server": "workspace:*"
-  },
+  "packageManager": "pnpm@10.28.2",
   "devDependencies": {
-    "@redocly/cli": "2.25.4",
+    "@redocly/cli": "2.15.0",
     "archiver": "7.0.1",
-    "fs-extra": "11.3.4",
-    "js-yaml": "4.1.1",
-    "typedoc": "0.28.18",
-    "typedoc-plugin-missing-exports": "4.1.3"
+    "fs-extra": "11.3.3",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "typedoc": "0.28.16",
+    "typedoc-plugin-missing-exports": "4.1.2"
   }
 }

apps/build-docs/scripts/build.ts

@@ -1,23 +0,0 @@
-import BuildHelper from "../../../scripts/build-utils";
-
-const build = new BuildHelper("apps/build-docs");
-
-async function main() {
-    // Build the CLI and other TypeScript files
-    await build.buildBackend([
-        "src/cli.ts",
-        "src/main.ts",
-        "src/build-docs.ts",
-        "src/swagger.ts",
-        "src/script-api.ts",
-        "src/context.ts"
-    ]);
-
-    // Copy HTML template
-    build.copy("src/index.html", "index.html");
-
-    // Copy node modules dependencies if needed
-    build.copyNodeModules([ "better-sqlite3", "bindings", "file-uri-to-path" ]);
-}
-
-main();

apps/build-docs/src/backend_script_entrypoint.ts

@@ -13,26 +13,24 @@
  * Make sure to keep in line with backend's `script_context.ts`.
  */
 
-export type {
-    AbstractBeccaEntity,
-    BAttachment,
-    BAttribute,
-    BBranch,
-    BEtapiToken,
-    BNote,
-    BOption,
-    BRecentNote,
-    BRevision
-} from "@triliumnext/core";
+export type { default as AbstractBeccaEntity } from "../../server/src/becca/entities/abstract_becca_entity.js";
+export type { default as BAttachment } from "../../server/src/becca/entities/battachment.js";
+export type { default as BAttribute } from "../../server/src/becca/entities/battribute.js";
+export type { default as BBranch } from "../../server/src/becca/entities/bbranch.js";
+export type { default as BEtapiToken } from "../../server/src/becca/entities/betapi_token.js";
+export type { BNote };
+export type { default as BOption } from "../../server/src/becca/entities/boption.js";
+export type { default as BRecentNote } from "../../server/src/becca/entities/brecent_note.js";
+export type { default as BRevision } from "../../server/src/becca/entities/brevision.js";
 
-import { BNote, BackendScriptApi, type BackendScriptApiInterface as Api } from "@triliumnext/core";
+import BNote from "../../server/src/becca/entities/bnote.js";
+import BackendScriptApi, { type Api } from "../../server/src/services/backend_script_api.js";
 
 export type { Api };
 
 const fakeNote = new BNote();
 
 /**
- * The `api` global variable allows access to the backend script API,
- * which is documented in {@link Api}.
+ * The `api` global variable allows access to the backend script API, which is documented in {@link Api}.
  */
 export const api: Api = new BackendScriptApi(fakeNote, {});

apps/build-docs/src/build-docs.ts

@@ -1,123 +1,19 @@
 process.env.TRILIUM_INTEGRATION_TEST = "memory-no-store";
-// Only set TRILIUM_RESOURCE_DIR if not already set (e.g., by Nix wrapper)
-if (!process.env.TRILIUM_RESOURCE_DIR) {
-    process.env.TRILIUM_RESOURCE_DIR = "../server/src";
-}
+process.env.TRILIUM_RESOURCE_DIR = "../server/src";
 process.env.NODE_ENV = "development";
 
-import { getContext, initializeCore } from "@triliumnext/core";
-import ClsHookedExecutionContext from "@triliumnext/server/src/cls_provider.js";
-import NodejsCryptoProvider from "@triliumnext/server/src/crypto_provider.js";
-import ServerPlatformProvider from "@triliumnext/server/src/platform_provider.js";
-import BetterSqlite3Provider from "@triliumnext/server/src/sql_provider.js";
-import NodejsZipProvider from "@triliumnext/server/src/zip_provider.js";
-import archiver from "archiver";
-import { execSync } from "child_process";
-import { readFileSync } from "fs";
+import cls from "@triliumnext/server/src/services/cls.js";
+import { dirname, join, resolve } from "path";
 import * as fs from "fs/promises";
 import * as fsExtra from "fs-extra";
-import yaml from "js-yaml";
-import { dirname, join, resolve } from "path";
-
+import archiver from "archiver";
+import { WriteStream } from "fs";
+import { execSync } from "child_process";
 import BuildContext from "./context.js";
 
-let initialized = false;
-
-async function initializeBuildEnvironment() {
-    if (initialized) return;
-    initialized = true;
-
-    const dbProvider = new BetterSqlite3Provider();
-    dbProvider.loadFromMemory();
-
-    const { serverZipExportProviderFactory } = await import("@triliumnext/server/src/services/export/zip/factory.js");
-
-    await initializeCore({
-        dbConfig: {
-            provider: dbProvider,
-            isReadOnly: false,
-            onTransactionCommit: () => {},
-            onTransactionRollback: () => {}
-        },
-        crypto: new NodejsCryptoProvider(),
-        zip: new NodejsZipProvider(),
-        zipExportProviderFactory: serverZipExportProviderFactory,
-        executionContext: new ClsHookedExecutionContext(),
-        platform: new ServerPlatformProvider(),
-        schema: readFileSync(require.resolve("@triliumnext/core/src/assets/schema.sql"), "utf-8"),
-        translations: (await import("@triliumnext/server/src/services/i18n.js")).initializeTranslations,
-        getDemoArchive: async () => null
-    });
-}
-
-interface NoteMapping {
-    rootNoteId: string;
-    path: string;
-    format: "markdown" | "html" | "share";
-    ignoredFiles?: string[];
-    exportOnly?: boolean;
-}
-
-interface Config {
-    baseUrl: string;
-    noteMappings: NoteMapping[];
-}
-
 const DOCS_ROOT = "../../../docs";
 const OUTPUT_DIR = "../../site";
 
-// Load configuration from edit-docs-config.yaml
-async function loadConfig(configPath?: string): Promise<Config | null> {
-    const pathsToTry = configPath
-        ? [resolve(configPath)]
-        : [
-            join(process.cwd(), "edit-docs-config.yaml"),
-            join(__dirname, "../../../edit-docs-config.yaml")
-        ];
-
-    for (const path of pathsToTry) {
-        try {
-            const configContent = await fs.readFile(path, "utf-8");
-            const config = yaml.load(configContent) as Config;
-
-            // Resolve all paths relative to the config file's directory
-            const CONFIG_DIR = dirname(path);
-            config.noteMappings = config.noteMappings.map((mapping) => ({
-                ...mapping,
-                path: resolve(CONFIG_DIR, mapping.path)
-            }));
-
-            return config;
-        } catch (error) {
-            if (error.code !== "ENOENT") {
-                throw error; // rethrow unexpected errors
-            }
-        }
-    }
-
-    return null; // No config file found
-}
-
-async function exportDocs(
-    noteId: string,
-    format: "markdown" | "html" | "share",
-    outputPath: string,
-    ignoredFiles?: string[]
-) {
-    const zipFilePath = `output-${noteId}.zip`;
-    try {
-        const { zipExportService } = await import("@triliumnext/core");
-        await zipExportService.exportToZipFile(noteId, format, zipFilePath, {});
-
-        const ignoredSet = ignoredFiles ? new Set(ignoredFiles) : undefined;
-        await extractZip(zipFilePath, outputPath, ignoredSet);
-    } finally {
-        if (await fsExtra.exists(zipFilePath)) {
-            await fsExtra.rm(zipFilePath);
-        }
-    }
-}
-
 async function importAndExportDocs(sourcePath: string, outputSubDir: string) {
     const note = await importData(sourcePath);
 
@@ -125,12 +21,15 @@ async function importAndExportDocs(sourcePath: string, outputSubDir: string) {
     const zipName = outputSubDir || "user-guide";
     const zipFilePath = `output-${zipName}.zip`;
     try {
-        const { zipExportService, TaskContext } = await import("@triliumnext/core");
-        const { waitForStreamToFinish } = await import("@triliumnext/server/src/services/utils.js");
+        const { exportToZip } = (await import("@triliumnext/server/src/services/export/zip.js")).default;
         const branch = note.getParentBranches()[0];
-        const taskContext = new TaskContext("no-progress-reporting", "export", null);
+        const taskContext = new (await import("@triliumnext/server/src/services/task_context.js")).default(
+            "no-progress-reporting",
+            "export",
+            null
+        );
         const fileOutputStream = fsExtra.createWriteStream(zipFilePath);
-        await zipExportService.exportToZip(taskContext, branch, "share", fileOutputStream);
+        await exportToZip(taskContext, branch, "share", fileOutputStream);
         await waitForStreamToFinish(fileOutputStream);
 
         // Output to root directory if outputSubDir is empty, otherwise to subdirectory
@@ -143,70 +42,45 @@ async function importAndExportDocs(sourcePath: string, outputSubDir: string) {
     }
 }
 
-async function buildDocsInner(config?: Config) {
-    const { sql_init, becca_loader } = await import("@triliumnext/core");
-    await sql_init.createInitialDatabase(true);
+async function buildDocsInner() {
+    const i18n = await import("@triliumnext/server/src/services/i18n.js");
+    await i18n.initializeTranslations();
+
+    const sqlInit = (await import("../../server/src/services/sql_init.js")).default;
+    await sqlInit.createInitialDatabase(true);
 
     // Wait for becca to be loaded before importing data
-    await becca_loader.beccaLoaded;
+    const beccaLoader = await import("../../server/src/becca/becca_loader.js");
+    await beccaLoader.beccaLoaded;
 
-    if (config) {
-        // Config-based build (reads from edit-docs-config.yaml)
-        console.log("Building documentation from config file...");
+    // Build User Guide
+    console.log("Building User Guide...");
+    await importAndExportDocs(join(__dirname, DOCS_ROOT, "User Guide"), "user-guide");
 
-        // Import all non-export-only mappings
-        for (const mapping of config.noteMappings) {
-            if (!mapping.exportOnly) {
-                console.log(`Importing from ${mapping.path}...`);
-                await importData(mapping.path);
-            }
-        }
+    // Build Developer Guide
+    console.log("Building Developer Guide...");
+    await importAndExportDocs(join(__dirname, DOCS_ROOT, "Developer Guide"), "developer-guide");
 
-        // Export all mappings
-        for (const mapping of config.noteMappings) {
-            if (mapping.exportOnly) {
-                console.log(`Exporting ${mapping.format} to ${mapping.path}...`);
-                await exportDocs(
-                    mapping.rootNoteId,
-                    mapping.format,
-                    mapping.path,
-                    mapping.ignoredFiles
-                );
-            }
-        }
-    } else {
-        // Legacy hardcoded build (for backward compatibility)
-        console.log("Building User Guide...");
-        await importAndExportDocs(join(__dirname, DOCS_ROOT, "User Guide"), "user-guide");
-
-        console.log("Building Developer Guide...");
-        await importAndExportDocs(
-            join(__dirname, DOCS_ROOT, "Developer Guide"),
-            "developer-guide"
-        );
-
-        // Copy favicon.
-        await fs.copyFile("../../apps/website/src/assets/favicon.ico",
-            join(OUTPUT_DIR, "favicon.ico"));
-        await fs.copyFile("../../apps/website/src/assets/favicon.ico",
-            join(OUTPUT_DIR, "user-guide", "favicon.ico"));
-        await fs.copyFile("../../apps/website/src/assets/favicon.ico",
-            join(OUTPUT_DIR, "developer-guide", "favicon.ico"));
-    }
+    // Copy favicon.
+    await fs.copyFile("../../apps/website/src/assets/favicon.ico", join(OUTPUT_DIR, "favicon.ico"));
+    await fs.copyFile("../../apps/website/src/assets/favicon.ico", join(OUTPUT_DIR, "user-guide", "favicon.ico"));
+    await fs.copyFile("../../apps/website/src/assets/favicon.ico", join(OUTPUT_DIR, "developer-guide", "favicon.ico"));
 
     console.log("Documentation built successfully!");
 }
 
 export async function importData(path: string) {
     const buffer = await createImportZip(path);
-    const { zipImportService, TaskContext, becca } = await import("@triliumnext/core");
+    const importService = (await import("../../server/src/services/import/zip.js")).default;
+    const TaskContext = (await import("../../server/src/services/task_context.js")).default;
     const context = new TaskContext("no-progress-reporting", "importNotes", null);
+    const becca = (await import("../../server/src/becca/becca.js")).default;
 
     const rootNote = becca.getRoot();
     if (!rootNote) {
         throw new Error("Missing root note for import.");
     }
-    return await zipImportService.importZip(context, buffer, rootNote, {
+    return await importService.importZip(context, buffer, rootNote, {
         preserveIds: true
     });
 }
@@ -217,13 +91,12 @@ async function createImportZip(path: string) {
         zlib: { level: 0 }
     });
 
-    console.log("Archive path is ", resolve(path));
+    console.log("Archive path is ", resolve(path))
     archive.directory(path, "/");
 
     const outputStream = fsExtra.createWriteStream(inputFile);
     archive.pipe(outputStream);
     archive.finalize();
-    const { waitForStreamToFinish } = await import("@triliumnext/server/src/services/utils.js");
     await waitForStreamToFinish(outputStream);
 
     try {
@@ -233,46 +106,26 @@ async function createImportZip(path: string) {
     }
 }
 
+function waitForStreamToFinish(stream: WriteStream) {
+    return new Promise<void>((res, rej) => {
+        stream.on("finish", () => res());
+        stream.on("error", (err) => rej(err));
+    });
+}
 
-export async function extractZip(
-    zipFilePath: string,
-    outputPath: string,
-    ignoredFiles?: Set<string>
-) {
-    const { getZipProvider } = await import("@triliumnext/core");
-    await getZipProvider().readZipFile(await fs.readFile(zipFilePath), async (entry, readContent) => {
+export async function extractZip(zipFilePath: string, outputPath: string, ignoredFiles?: Set<string>) {
+    const { readZipFile, readContent } = (await import("@triliumnext/server/src/services/import/zip.js"));
+    await readZipFile(await fs.readFile(zipFilePath), async (zip, entry) => {
         // We ignore directories since they can appear out of order anyway.
         if (!entry.fileName.endsWith("/") && !ignoredFiles?.has(entry.fileName)) {
             const destPath = join(outputPath, entry.fileName);
-            const fileContent = await readContent();
+            const fileContent = await readContent(zip, entry);
 
             await fsExtra.mkdirs(dirname(destPath));
             await fs.writeFile(destPath, fileContent);
         }
-    });
-}
 
-export async function buildDocsFromConfig(configPath?: string, gitRootDir?: string) {
-    const config = await loadConfig(configPath);
-
-    if (gitRootDir) {
-        // Build the share theme if we have a gitRootDir (for Trilium project)
-        execSync(`pnpm run --filter share-theme build`, {
-            stdio: "inherit",
-            cwd: gitRootDir
-        });
-    }
-
-    // Initialize the build environment before using cls
-    await initializeBuildEnvironment();
-
-    // Trigger the actual build.
-    await new Promise((res, rej) => {
-        getContext().init(() => {
-            buildDocsInner(config ?? undefined)
-                .catch(rej)
-                .then(res);
-        });
+        zip.readEntry();
     });
 }
 
@@ -283,12 +136,9 @@ export default async function buildDocs({ gitRootDir }: BuildContext) {
         cwd: gitRootDir
     });
 
-    // Initialize the build environment before using cls
-    await initializeBuildEnvironment();
-
     // Trigger the actual build.
     await new Promise((res, rej) => {
-        getContext().init(() => {
+        cls.init(() => {
             buildDocsInner()
                 .catch(rej)
                 .then(res);

apps/build-docs/src/cli.ts

@@ -1,89 +0,0 @@
-#!/usr/bin/env node
-
-import packageJson from "../package.json" with { type: "json" };
-import { buildDocsFromConfig } from "./build-docs.js";
-
-// Parse command-line arguments
-function parseArgs() {
-    const args = process.argv.slice(2);
-    let configPath: string | undefined;
-    let showHelp = false;
-    let showVersion = false;
-
-    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;
-        }
-    }
-
-    return { configPath, showHelp, showVersion };
-}
-
-function getVersion(): string {
-    return packageJson.version;
-}
-
-function printHelp() {
-    const version = getVersion();
-    console.log(`
-Usage: trilium-build-docs [options]
-
-Options:
-  -c, --config <path>  Path to the configuration file
-                       (default: edit-docs-config.yaml in current directory)
-  -h, --help           Display this help message
-  -v, --version        Display version information
-
-Description:
-  Builds documentation from Trilium note structure and exports to various formats.
-  Configuration file should be in YAML format with the following structure:
-
-  baseUrl: "https://example.com"
-  noteMappings:
-    - rootNoteId: "noteId123"
-      path: "docs"
-      format: "markdown"
-    - rootNoteId: "noteId456"
-      path: "public/docs"
-      format: "share"
-      exportOnly: true
-
-Version: ${version}
-`);
-}
-
-function printVersion() {
-    const version = getVersion();
-    console.log(version);
-}
-
-async function main() {
-    const { configPath, showHelp, showVersion } = parseArgs();
-
-    if (showHelp) {
-        printHelp();
-        process.exit(0);
-    } else if (showVersion) {
-        printVersion();
-        process.exit(0);
-    }
-
-    try {
-        await buildDocsFromConfig(configPath);
-        process.exit(0);
-    } catch (error) {
-        console.error("Error building documentation:", error);
-        process.exit(1);
-    }
-}
-
-main();

apps/build-docs/src/frontend_script_entrypoint.ts

@@ -13,19 +13,16 @@
  * Make sure to keep in line with frontend's `script_context.ts`.
  */
 
+export type { default as BasicWidget } from "../../client/src/widgets/basic_widget.js";
 export type { default as FAttachment } from "../../client/src/entities/fattachment.js";
 export type { default as FAttribute } from "../../client/src/entities/fattribute.js";
 export type { default as FBranch } from "../../client/src/entities/fbranch.js";
 export type { default as FNote } from "../../client/src/entities/fnote.js";
 export type { Api } from "../../client/src/services/frontend_script_api.js";
-export type { default as BasicWidget } from "../../client/src/widgets/basic_widget.js";
-export type {
-    default as NoteContextAwareWidget
-} from "../../client/src/widgets/note_context_aware_widget.js";
+export type { default as NoteContextAwareWidget } from "../../client/src/widgets/note_context_aware_widget.js";
 export type { default as RightPanelWidget } from "../../client/src/widgets/right_panel_widget.js";
 
 import FrontendScriptApi, { type Api } from "../../client/src/services/frontend_script_api.js";
 
-
-// @ts-expect-error - FrontendScriptApi is not directly exportable as Api without this simulation.
+//@ts-expect-error
 export const api: Api = new FrontendScriptApi();

apps/build-docs/src/main.ts

@@ -1,10 +1,9 @@
-import { cpSync, existsSync, mkdirSync, rmSync } from "fs";
 import { join } from "path";
-
-import buildDocs from "./build-docs";
 import BuildContext from "./context";
-import buildScriptApi from "./script-api";
 import buildSwagger from "./swagger";
+import { cpSync, existsSync, mkdirSync, rmSync } from "fs";
+import buildDocs from "./build-docs";
+import buildScriptApi from "./script-api";
 
 const context: BuildContext = {
     gitRootDir: join(__dirname, "../../../"),
@@ -28,13 +27,4 @@ async function main() {
     cpSync(join(context.baseDir, "user-guide/404.html"), join(context.baseDir, "404.html"));
 }
 
-// Note: forcing process.exit() because importing notes via the core triggers
-// fire-and-forget async work in `notes.ts#downloadImages` (a 5s setTimeout that
-// re-schedules itself via `asyncPostProcessContent`), which keeps the libuv
-// event loop alive forever even after main() completes.
-main()
-    .then(() => process.exit(0))
-    .catch((error) => {
-        console.error("Error building documentation:", error);
-        process.exit(1);
-    });
+main();

apps/build-docs/src/script-api.ts

@@ -1,7 +1,6 @@
 import { execSync } from "child_process";
-import { join } from "path";
-
 import BuildContext from "./context";
+import { join } from "path";
 
 export default function buildScriptApi({ baseDir, gitRootDir }: BuildContext) {
     // Generate types

apps/build-docs/src/swagger.ts

@@ -1,8 +1,7 @@
+import BuildContext from "./context";
+import { join } from "path";
 import { execSync } from "child_process";
 import { mkdirSync } from "fs";
-import { join } from "path";
-
-import BuildContext from "./context";
 
 interface BuildInfo {
     specPath: string;
@@ -28,9 +27,6 @@ export default function buildSwagger({ baseDir, gitRootDir }: BuildContext) {
         const absSpecPath = join(gitRootDir, specPath);
         const targetDir = join(baseDir, outDir);
         mkdirSync(targetDir, { recursive: true });
-        execSync(
-            `pnpm redocly build-docs ${absSpecPath} -o ${targetDir}/index.html`,
-            { stdio: "inherit" }
-        );
+        execSync(`pnpm redocly build-docs ${absSpecPath} -o ${targetDir}/index.html`, { stdio: "inherit" });
     }
 }

apps/build-docs/tsconfig.json

@@ -1,8 +1,6 @@
 {
   "extends": "../../tsconfig.base.json",
-  "include": [
-    "scripts/**/*.ts"
-  ],
+  "include": [],
   "references": [
     {
       "path": "../server"

apps/build-docs/typedoc.backend.json

@@ -4,7 +4,6 @@
   "entryPoints": [
     "src/backend_script_entrypoint.ts"
   ],
-  "tsconfig": "tsconfig.app.json",
   "plugin": [
     "typedoc-plugin-missing-exports"
   ]

apps/build-docs/typedoc.frontend.json

@@ -4,7 +4,6 @@
   "entryPoints": [
     "src/frontend_script_entrypoint.ts"
   ],
-  "tsconfig": "tsconfig.app.json",
   "plugin": [
     "typedoc-plugin-missing-exports"
   ]

apps/client-standalone/.env

@@ -1,4 +0,0 @@
-# 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

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

apps/client-standalone/package.json

@@ -1,92 +0,0 @@
-{
-  "name": "@triliumnext/client-standalone",
-  "version": "0.102.2",
-  "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 vite preview --port 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.1",
-    "@mind-elixir/node-menu": "5.0.1",
-    "@popperjs/core": "2.11.8",
-    "@preact/signals": "2.9.0",
-    "@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.7.0",
-    "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",
-    "fflate": "0.8.2",
-    "force-graph": "1.51.2",
-    "globals": "17.4.0",
-    "i18next": "26.0.3",
-    "i18next-http-backend": "3.0.4",
-    "aes-js": "3.1.2",
-    "jquery": "4.0.0",
-    "jquery.fancytree": "2.38.5",
-    "js-md5": "0.8.3",
-    "js-sha1": "0.7.0",
-    "js-sha256": "0.11.1",
-    "js-sha512": "0.9.0",
-    "scrypt-js": "3.0.1",
-    "jsplumb": "2.15.6",
-    "katex": "0.16.45",
-    "knockout": "3.5.1",
-    "leaflet": "1.9.4",
-    "leaflet-gpx": "2.2.0",
-    "mark.js": "8.11.1",
-    "marked": "18.0.0",
-    "mermaid": "11.14.0",
-    "mind-elixir": "5.10.0",
-    "normalize.css": "8.0.1",
-    "panzoom": "9.4.4",
-    "preact": "10.29.1",
-    "react-i18next": "17.0.2",
-    "react-window": "2.2.7",
-    "reveal.js": "6.0.0",
-    "svg-pan-zoom": "3.6.2",
-    "tabulator-tables": "6.4.0",
-    "vanilla-js-wheel-zoom": "9.0.4"
-  },
-  "devDependencies": {
-    "@types/aes-js": "3.1.4",
-    "@ckeditor/ckeditor5-inspector": "5.0.0",
-    "@preact/preset-vite": "2.10.2",
-    "@types/bootstrap": "5.2.10",
-    "@types/jquery": "4.0.0",
-    "@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": "14.0.0",
-    "cross-env": "7.0.3",
-    "happy-dom": "20.8.9",
-    "script-loader": "0.7.2",
-    "vite-plugin-static-copy": "4.0.1"
-  }
-}

apps/client-standalone/public/_headers

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

apps/client-standalone/public/manifest.webmanifest

@@ -1,20 +0,0 @@
-{
-    "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

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

apps/client-standalone/src/index.html

@@ -1,31 +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>
-    </head>
-
-    <body id="trilium-app">
-        <noscript>Trilium requires JavaScript to be enabled.</noscript>
-
-        <div id="context-menu-cover"></div>
-        <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/backup_provider.ts

@@ -1,156 +0,0 @@
-import type { DatabaseBackup } from "@triliumnext/commons";
-import { BackupOptionsService, BackupService, getSql } from "@triliumnext/core";
-
-const BACKUP_DIR_NAME = "backups";
-const BACKUP_FILE_PATTERN = /^backup-.*\.db$/;
-
-/**
- * Standalone backup service using OPFS (Origin Private File System).
- * Stores database backups as serialized byte arrays in OPFS.
- * Falls back to no-op behavior when OPFS is not available (e.g., in tests).
- */
-export default class StandaloneBackupService extends BackupService {
-    private backupDir: FileSystemDirectoryHandle | null = null;
-    private opfsAvailable: boolean | null = null;
-
-    constructor(options: BackupOptionsService) {
-        super(options);
-    }
-
-    private isOpfsAvailable(): boolean {
-        if (this.opfsAvailable === null) {
-            this.opfsAvailable = typeof navigator !== "undefined"
-                && navigator.storage
-                && typeof navigator.storage.getDirectory === "function";
-        }
-        return this.opfsAvailable;
-    }
-
-    private async ensureBackupDirectory(): Promise<FileSystemDirectoryHandle | null> {
-        if (!this.isOpfsAvailable()) {
-            return null;
-        }
-
-        if (!this.backupDir) {
-            const root = await navigator.storage.getDirectory();
-            this.backupDir = await root.getDirectoryHandle(BACKUP_DIR_NAME, { create: true });
-        }
-        return this.backupDir;
-    }
-
-    override async backupNow(name: string): Promise<string> {
-        const fileName = `backup-${name}.db`;
-
-        // Check if OPFS is available
-        if (!this.isOpfsAvailable()) {
-            console.warn(`[Backup] OPFS not available, skipping backup: ${fileName}`);
-            return `/${BACKUP_DIR_NAME}/${fileName}`;
-        }
-
-        try {
-            const dir = await this.ensureBackupDirectory();
-            if (!dir) {
-                console.warn(`[Backup] Backup directory not available, skipping: ${fileName}`);
-                return `/${BACKUP_DIR_NAME}/${fileName}`;
-            }
-
-            // Serialize the database
-            const data = getSql().serialize();
-
-            // Write to OPFS
-            const fileHandle = await dir.getFileHandle(fileName, { create: true });
-            const writable = await fileHandle.createWritable();
-            await writable.write(data);
-            await writable.close();
-
-            console.log(`[Backup] Created backup: ${fileName} (${data.byteLength} bytes)`);
-            return `/${BACKUP_DIR_NAME}/${fileName}`;
-        } catch (error) {
-            console.error(`[Backup] Failed to create backup ${fileName}:`, error);
-            // Don't throw - backup failure shouldn't block operations
-            return `/${BACKUP_DIR_NAME}/${fileName}`;
-        }
-    }
-
-    override async getExistingBackups(): Promise<DatabaseBackup[]> {
-        if (!this.isOpfsAvailable()) {
-            return [];
-        }
-
-        try {
-            const dir = await this.ensureBackupDirectory();
-            if (!dir) {
-                return [];
-            }
-
-            const backups: DatabaseBackup[] = [];
-
-            for await (const [name, handle] of dir.entries()) {
-                if (handle.kind !== "file" || !BACKUP_FILE_PATTERN.test(name)) {
-                    continue;
-                }
-
-                const file = await (handle as FileSystemFileHandle).getFile();
-                backups.push({
-                    fileName: name,
-                    filePath: `/${BACKUP_DIR_NAME}/${name}`,
-                    mtime: new Date(file.lastModified)
-                });
-            }
-
-            // Sort by modification time, newest first
-            backups.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-            return backups;
-        } catch (error) {
-            console.error("[Backup] Failed to list backups:", error);
-            return [];
-        }
-    }
-
-    /**
-     * Delete a backup by filename.
-     */
-    async deleteBackup(fileName: string): Promise<void> {
-        if (!this.isOpfsAvailable()) {
-            return;
-        }
-
-        try {
-            const dir = await this.ensureBackupDirectory();
-            if (!dir) {
-                return;
-            }
-            await dir.removeEntry(fileName);
-            console.log(`[Backup] Deleted backup: ${fileName}`);
-        } catch (error) {
-            console.error(`[Backup] Failed to delete backup ${fileName}:`, error);
-        }
-    }
-
-    override async getBackupContent(filePath: string): Promise<Uint8Array | null> {
-        if (!this.isOpfsAvailable()) {
-            return null;
-        }
-
-        try {
-            const dir = await this.ensureBackupDirectory();
-            if (!dir) {
-                return null;
-            }
-
-            // Extract fileName from filePath (e.g., "/backups/backup-now.db" -> "backup-now.db")
-            const fileName = filePath.split("/").pop();
-            if (!fileName || !BACKUP_FILE_PATTERN.test(fileName)) {
-                return null;
-            }
-
-            const fileHandle = await dir.getFileHandle(fileName);
-            const file = await fileHandle.getFile();
-            const data = await file.arrayBuffer();
-            return new Uint8Array(data);
-        } catch (error) {
-            console.error(`[Backup] Failed to get backup content ${filePath}:`, error);
-            return null;
-        }
-    }
-}

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

@@ -1,314 +0,0 @@
-/**
- * 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 UploadedFile {
-    originalname: string;
-    mimetype: string;
-    buffer: Uint8Array;
-}
-
-export interface BrowserRequest {
-    method: string;
-    url: string;
-    path: string;
-    params: Record<string, string>;
-    query: Record<string, string | undefined>;
-    headers?: Record<string, string>;
-    body?: unknown;
-    file?: UploadedFile;
-}
-
-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;
-}
-
-/**
- * Symbol used to mark a result as an already-formatted response,
- * so that formatResult passes it through without JSON-serializing.
- * Must match the symbol exported from browser_routes.ts.
- */
-const RAW_RESPONSE = Symbol.for('RAW_RESPONSE');
-
-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 body based on content-type
-        let parsedBody = body;
-        let uploadedFile: UploadedFile | undefined;
-        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);
-                    parsedBody = body;
-                }
-            } else if (contentType.includes('multipart/form-data')) {
-                try {
-                    // Reconstruct a Response so we can use the native FormData parser
-                    const response = new Response(body, { headers: { 'content-type': contentType } });
-                    const formData = await response.formData();
-                    const formFields: Record<string, string> = {};
-                    for (const [key, value] of formData.entries()) {
-                        if (typeof value === 'string') {
-                            formFields[key] = value;
-                        } else {
-                            // File field (Blob) — multer uses the field name "upload"
-                            const fileBuffer = new Uint8Array(await value.arrayBuffer());
-                            uploadedFile = {
-                                originalname: value.name,
-                                mimetype: value.type || 'application/octet-stream',
-                                buffer: fileBuffer
-                            };
-                        }
-                    }
-                    parsedBody = formFields;
-                } catch (e) {
-                    console.warn('[Router] Failed to parse multipart body:', e);
-                }
-            }
-        }
-        // 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,
-                headers: headers ?? {},
-                body: parsedBody,
-                file: uploadedFile
-            };
-
-            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 raw responses (e.g. from image routes that write directly to res)
-        if (result && typeof result === 'object' && RAW_RESPONSE in result) {
-            const raw = result as unknown as { status: number; headers: Record<string, string>; body: unknown };
-            let body: ArrayBuffer | null = null;
-
-            if (raw.body instanceof ArrayBuffer) {
-                body = raw.body;
-            } else if (raw.body instanceof Uint8Array) {
-                body = raw.body.buffer as ArrayBuffer;
-            } else if (typeof raw.body === 'string') {
-                body = encoder.encode(raw.body).buffer as ArrayBuffer;
-            }
-
-            return {
-                status: raw.status,
-                headers: raw.headers,
-                body
-            };
-        }
-
-        // 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

@@ -1,340 +0,0 @@
-/**
- * Browser route definitions.
- * This integrates with the shared route builder from @triliumnext/core.
- */
-
-import { BootstrapDefinition } from '@triliumnext/commons';
-import { entity_changes, getContext, getPlatform, getSharedBootstrapItems, getSql, routes, sql_init } from '@triliumnext/core';
-
-import packageJson from '../../package.json' with { type: 'json' };
-import { type BrowserRequest, BrowserRouter } from './browser_router';
-
-/** Minimal response object used by apiResultHandler to capture the processed result. */
-interface ResultHandlerResponse {
-    headers: Record<string, string>;
-    result: unknown;
-    setHeader(name: string, value: string): void;
-}
-
-/**
- * Symbol used to mark a result as an already-formatted BrowserResponse,
- * so that BrowserRouter.formatResult passes it through without JSON-serializing.
- * Uses Symbol.for() so the same symbol is shared across modules.
- */
-const RAW_RESPONSE = Symbol.for('RAW_RESPONSE');
-
-type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
-
-/**
- * Creates an Express-like request object from a BrowserRequest.
- */
-function toExpressLikeReq(req: BrowserRequest) {
-    return {
-        params: req.params,
-        query: req.query,
-        body: req.body,
-        headers: req.headers ?? {},
-        method: req.method,
-        file: req.file,
-        get originalUrl() { return req.url; }
-    };
-}
-
-/**
- * Extracts context headers from the request and sets them in the execution context,
- * mirroring what the server does in route_api.ts.
- */
-function setContextFromHeaders(req: BrowserRequest) {
-    const headers = req.headers ?? {};
-    const ctx = getContext();
-    ctx.set("componentId", headers["trilium-component-id"]);
-    ctx.set("localNowDateTime", headers["trilium-local-now-datetime"]);
-    ctx.set("hoistedNoteId", headers["trilium-hoisted-note-id"] || "root");
-}
-
-/**
- * Wraps a core route handler to work with the BrowserRouter.
- * Core handlers expect an Express-like request object with params, query, and body.
- * Each request is wrapped in an execution context (like cls.init() on the server)
- * to ensure entity change tracking works correctly.
- */
-function wrapHandler(handler: (req: any) => unknown, transactional: boolean) {
-    return (req: BrowserRequest) => {
-        return getContext().init(() => {
-            setContextFromHeaders(req);
-            const expressLikeReq = toExpressLikeReq(req);
-            if (transactional) {
-                return getSql().transactional(() => handler(expressLikeReq));
-            }
-            return handler(expressLikeReq);
-        });
-    };
-}
-
-/**
- * Creates an apiRoute function compatible with buildSharedApiRoutes.
- * This bridges the core's route registration to the BrowserRouter.
- */
-function createApiRoute(router: BrowserRouter, transactional: boolean) {
-    return (method: HttpMethod, path: string, handler: (req: any) => unknown) => {
-        router.register(method, path, wrapHandler(handler, transactional));
-    };
-}
-
-/**
- * Low-level route registration matching the server's `route()` signature:
- *   route(method, path, middleware[], handler, resultHandler)
- *
- * In standalone mode:
- * - Middleware (e.g. checkApiAuth) is skipped — there's no authentication.
- * - The resultHandler is applied to post-process the result (entity conversion, status codes).
- */
-function createRoute(router: BrowserRouter) {
-    return (method: HttpMethod, path: string, _middleware: any[], handler: (req: any, res: any) => unknown, resultHandler?: ((req: any, res: any, result: unknown) => unknown) | null) => {
-        router.register(method, path, (req: BrowserRequest) => {
-            return getContext().init(() => {
-                setContextFromHeaders(req);
-                const expressLikeReq = toExpressLikeReq(req);
-                const mockRes = createMockExpressResponse();
-                const result = getSql().transactional(() => handler(expressLikeReq, mockRes));
-
-                // If the handler used the mock response (e.g. image routes that call res.send()),
-                // return it as a raw response so BrowserRouter doesn't JSON-serialize it.
-                if (mockRes._used) {
-                    return {
-                        [RAW_RESPONSE]: true as const,
-                        status: mockRes._status,
-                        headers: mockRes._headers,
-                        body: mockRes._body
-                    };
-                }
-
-                if (resultHandler) {
-                    // Create a minimal response object that captures what apiResultHandler sets.
-                    const res = createResultHandlerResponse();
-                    resultHandler(expressLikeReq, res, result);
-                    return res.result;
-                }
-
-                return result;
-            });
-        });
-    };
-}
-
-/**
- * Async variant of createRoute for handlers that return Promises (e.g. import).
- * Uses transactionalAsync (manual BEGIN/COMMIT/ROLLBACK) instead of the synchronous
- * transactional() wrapper, which would commit an empty transaction immediately when
- * passed an async callback.
- */
-function createAsyncRoute(router: BrowserRouter) {
-    return (method: HttpMethod, path: string, _middleware: any[], handler: (req: any, res: any) => Promise<unknown>, resultHandler?: ((req: any, res: any, result: unknown) => unknown) | null) => {
-        router.register(method, path, (req: BrowserRequest) => {
-            return getContext().init(async () => {
-                setContextFromHeaders(req);
-                const expressLikeReq = toExpressLikeReq(req);
-                const mockRes = createMockExpressResponse();
-                const result = await getSql().transactionalAsync(() => handler(expressLikeReq, mockRes));
-
-                // If the handler used the mock response (e.g. image routes that call res.send()),
-                // return it as a raw response so BrowserRouter doesn't JSON-serialize it.
-                if (mockRes._used) {
-                    return {
-                        [RAW_RESPONSE]: true as const,
-                        status: mockRes._status,
-                        headers: mockRes._headers,
-                        body: mockRes._body
-                    };
-                }
-
-                if (resultHandler) {
-                    // Create a minimal response object that captures what apiResultHandler sets.
-                    const res = createResultHandlerResponse();
-                    resultHandler(expressLikeReq, res, result);
-                    return res.result;
-                }
-
-                return result;
-            });
-        });
-    };
-}
-
-/**
- * Creates a mock Express response object that captures calls to set(), send(), sendStatus(), etc.
- * Used for route handlers (like image routes) that write directly to the response.
- */
-function createMockExpressResponse() {
-    const chunks: string[] = [];
-    const res = {
-        _used: false,
-        _status: 200,
-        _headers: {} as Record<string, string>,
-        _body: null as unknown,
-        set(name: string, value: string) {
-            res._headers[name] = value;
-            return res;
-        },
-        setHeader(name: string, value: string) {
-            res._headers[name] = value;
-            return res;
-        },
-        removeHeader(name: string) {
-            delete res._headers[name];
-            return res;
-        },
-        status(code: number) {
-            res._status = code;
-            return res;
-        },
-        send(body: unknown) {
-            res._used = true;
-            res._body = body;
-            return res;
-        },
-        sendStatus(code: number) {
-            res._used = true;
-            res._status = code;
-            return res;
-        },
-        write(chunk: string) {
-            chunks.push(chunk);
-            return true;
-        },
-        end() {
-            res._used = true;
-            res._body = chunks.join("");
-            return res;
-        }
-    };
-    return res;
-}
-
-/**
- * Standalone apiResultHandler matching the server's behavior:
- * - Converts Becca entities to POJOs
- * - Handles [statusCode, response] tuple format
- * - Sets trilium-max-entity-change-id (captured in response headers)
- */
-function apiResultHandler(_req: any, res: ResultHandlerResponse, result: unknown) {
-    res.headers["trilium-max-entity-change-id"] = String(entity_changes.getMaxEntityChangeId());
-    result = routes.convertEntitiesToPojo(result);
-
-    if (Array.isArray(result) && result.length > 0 && Number.isInteger(result[0])) {
-        const [_statusCode, response] = result;
-        res.result = response;
-    } else if (result === undefined) {
-        res.result = "";
-    } else {
-        res.result = result;
-    }
-}
-
-/**
- * No-op middleware stubs for standalone mode.
- *
- * In a browser context there is no network authentication, rate limiting,
- * or multi-user access, so all auth/rate-limit middleware is a no-op.
- *
- * `checkAppNotInitialized` still guards setup routes: if the database is
- * already initialised the middleware throws so the route handler is never
- * reached (mirrors the server behaviour).
- */
-function noopMiddleware() {
-    // No-op.
-}
-
-function checkAppNotInitialized() {
-    if (sql_init.isDbInitialized()) {
-        throw new Error("App already initialized.");
-    }
-}
-
-/**
- * Creates a minimal response-like object for the apiResultHandler.
- */
-function createResultHandlerResponse(): ResultHandlerResponse {
-    return {
-        headers: {},
-        result: undefined,
-        setHeader(name: string, value: string) {
-            this.headers[name] = value;
-        }
-    };
-}
-
-/**
- * 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, true);
-    routes.buildSharedApiRoutes({
-        route: createRoute(router),
-        asyncRoute: createAsyncRoute(router),
-        apiRoute,
-        asyncApiRoute: createApiRoute(router, false),
-        apiResultHandler,
-        checkApiAuth: noopMiddleware,
-        checkApiAuthOrElectron: noopMiddleware,
-        checkAppNotInitialized,
-        checkCredentials: noopMiddleware,
-        loginRateLimiter: noopMiddleware,
-        uploadMiddlewareWithErrorHandling: noopMiddleware,
-        csrfMiddleware: noopMiddleware
-    });
-    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 }));
-}
-
-function bootstrapRoute(): BootstrapDefinition {
-    const assetPath = ".";
-
-    const isDbInitialized = sql_init.isDbInitialized();
-    const commonItems = {
-        ...getSharedBootstrapItems(assetPath, isDbInitialized),
-        isDev: import.meta.env.DEV,
-        isStandalone: true,
-        isMainWindow: true,
-        isElectron: false,
-        hasNativeTitleBar: false,
-        hasBackgroundEffects: false,
-        triliumVersion: packageJson.version,
-        device: false as const, // Let the client detect device type.
-        appPath: assetPath,
-        instanceName: "standalone",
-        TRILIUM_SAFE_MODE: !!getPlatform().getEnv("TRILIUM_SAFE_MODE")
-    };
-
-    if (!isDbInitialized) {
-        return {
-            ...commonItems,
-            baseApiUrl: "../api/",
-            isProtectedSessionAvailable: false,
-        };
-    }
-
-    return {
-        ...commonItems,
-        csrfToken: "dummy-csrf-token",
-        baseApiUrl: "../api/",
-        headingStyle: "plain",
-        layoutOrientation: "vertical",
-        platform: "web",
-    };
-}
-
-/**
- * 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

@@ -1,77 +0,0 @@
-import { ExecutionContext } from "@triliumnext/core";
-
-/**
- * Browser execution context implementation.
- * 
- * Handles per-request context isolation with support for fire-and-forget async operations
- * using a context stack and grace-period cleanup to allow unawaited promises to complete.
- */
-export default class BrowserExecutionContext implements ExecutionContext {
-    private contextStack: Map<string, any>[] = [];
-    private cleanupTimers = new WeakMap<Map<string, any>, ReturnType<typeof setTimeout>>();
-    private readonly CLEANUP_GRACE_PERIOD = 1000; // 1 second for fire-and-forget operations
-
-    private getCurrentContext(): Map<string, any> {
-        if (this.contextStack.length === 0) {
-            throw new Error("ExecutionContext not initialized");
-        }
-        return this.contextStack[this.contextStack.length - 1];
-    }
-
-    get<T = any>(key: string): T {
-        return this.getCurrentContext().get(key);
-    }
-
-    set(key: string, value: any): void {
-        this.getCurrentContext().set(key, value);
-    }
-
-    reset(): void {
-        this.contextStack = [];
-    }
-
-    init<T>(callback: () => T): T {
-        const context = new Map<string, any>();
-        this.contextStack.push(context);
-
-        // Cancel any pending cleanup timer for this context
-        const existingTimer = this.cleanupTimers.get(context);
-        if (existingTimer) {
-            clearTimeout(existingTimer);
-            this.cleanupTimers.delete(context);
-        }
-
-        try {
-            const result = callback();
-
-            // If the result is a Promise
-            if (result && typeof result === 'object' && 'then' in result && 'catch' in result) {
-                const promise = result as unknown as Promise<any>;
-                return promise.finally(() => {
-                    this.scheduleContextCleanup(context);
-                }) as T;
-            } else {
-                // For synchronous results, schedule delayed cleanup to allow fire-and-forget operations
-                this.scheduleContextCleanup(context);
-                return result;
-            }
-        } catch (error) {
-            // Always clean up on error with grace period
-            this.scheduleContextCleanup(context);
-            throw error;
-        }
-    }
-
-    private scheduleContextCleanup(context: Map<string, any>): void {
-        const timer = setTimeout(() => {
-            // Remove from stack if still present
-            const index = this.contextStack.indexOf(context);
-            if (index !== -1) {
-                this.contextStack.splice(index, 1);
-            }
-            this.cleanupTimers.delete(context);
-        }, this.CLEANUP_GRACE_PERIOD);
-
-        this.cleanupTimers.set(context, timer);
-    }
-}

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

@@ -1,175 +0,0 @@
-import type { Cipher, CryptoProvider, ScryptOptions } from "@triliumnext/core";
-import { binary_utils } from "@triliumnext/core";
-import { sha1 } from "js-sha1";
-import { sha256 } from "js-sha256";
-import { sha512 } from "js-sha512";
-import { md5 } from "js-md5";
-import { scrypt } from "scrypt-js";
-import aesjs from "aes-js";
-
-const CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-/**
- * Crypto provider for browser environments using pure JavaScript crypto libraries.
- * Uses aes-js for synchronous AES encryption (matching Node.js behavior).
- */
-export default class BrowserCryptoProvider implements CryptoProvider {
-
-    createHash(algorithm: "md5" | "sha1" | "sha512", content: string | Uint8Array): Uint8Array {
-        const data = binary_utils.unwrapStringOrBuffer(content);
-
-        let hexHash: string;
-        if (algorithm === "md5") {
-            hexHash = md5(data);
-        } else if (algorithm === "sha1") {
-            hexHash = sha1(data);
-        } else {
-            hexHash = 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 {
-        return new AesJsCipher(algorithm, key, iv, "encrypt");
-    }
-
-    createDecipheriv(algorithm: "aes-128-cbc", key: Uint8Array, iv: Uint8Array): Cipher {
-        return new AesJsCipher(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;
-    }
-
-    hmac(secret: string | Uint8Array, value: string | Uint8Array): string {
-        const secretStr = binary_utils.unwrapStringOrBuffer(secret);
-        const valueStr = binary_utils.unwrapStringOrBuffer(value);
-        // sha256.hmac returns hex, convert to base64 to match Node's behavior
-        const hexHash = sha256.hmac(secretStr, valueStr);
-        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 btoa(String.fromCharCode(...bytes));
-    }
-
-    async scrypt(
-        password: Uint8Array | string,
-        salt: Uint8Array | string,
-        keyLength: number,
-        options: ScryptOptions = {}
-    ): Promise<Uint8Array> {
-        const { N = 16384, r = 8, p = 1 } = options;
-        const passwordBytes = binary_utils.wrapStringOrBuffer(password);
-        const saltBytes = binary_utils.wrapStringOrBuffer(salt);
-
-        return scrypt(passwordBytes, saltBytes, N, r, p, keyLength);
-    }
-
-    constantTimeCompare(a: Uint8Array, b: Uint8Array): boolean {
-        if (a.length !== b.length) {
-            return false;
-        }
-
-        let result = 0;
-        for (let i = 0; i < a.length; i++) {
-            result |= a[i] ^ b[i];
-        }
-        return result === 0;
-    }
-}
-
-/**
- * A synchronous cipher implementation using aes-js.
- * Matches Node.js crypto behavior with update() and final() methods.
- */
-class AesJsCipher implements Cipher {
-    private chunks: Uint8Array[] = [];
-    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.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 - we process everything in final() to match streaming behavior
-        this.chunks.push(data);
-        // Return empty array since aes-js CBC doesn't support true streaming
-        return new Uint8Array(0);
-    }
-
-    final(): 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;
-        }
-
-        if (this.mode === "encrypt") {
-            // PKCS7 padding for encryption
-            const blockSize = 16;
-            const paddingLength = blockSize - (data.length % blockSize);
-            const paddedData = new Uint8Array(data.length + paddingLength);
-            paddedData.set(data);
-            paddedData.fill(paddingLength, data.length);
-
-            const aesCbc = new aesjs.ModeOfOperation.cbc(
-                Array.from(this.key),
-                Array.from(this.iv)
-            );
-            return new Uint8Array(aesCbc.encrypt(paddedData));
-        } else {
-            // Decryption
-            const aesCbc = new aesjs.ModeOfOperation.cbc(
-                Array.from(this.key),
-                Array.from(this.iv)
-            );
-            const decrypted = new Uint8Array(aesCbc.decrypt(data));
-
-            // Remove PKCS7 padding
-            const paddingLength = decrypted[decrypted.length - 1];
-            if (paddingLength > 0 && paddingLength <= 16) {
-                return decrypted.slice(0, decrypted.length - paddingLength);
-            }
-            return decrypted;
-        }
-    }
-}

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

@@ -1,168 +0,0 @@
-import { FileBasedLogService, type LogFileInfo } from "@triliumnext/core";
-
-const LOG_DIR_NAME = "logs";
-const LOG_FILE_PATTERN = /^trilium-\d{4}-\d{2}-\d{2}\.log$/;
-const DEFAULT_RETENTION_DAYS = 7;
-
-/**
- * Standalone log service using OPFS (Origin Private File System).
- * Uses synchronous access handles available in service worker context.
- */
-export default class StandaloneLogService extends FileBasedLogService {
-    private logDir: FileSystemDirectoryHandle | null = null;
-    private currentFile: FileSystemSyncAccessHandle | null = null;
-    private currentFileName: string = "";
-    private textEncoder = new TextEncoder();
-    private textDecoder = new TextDecoder();
-
-    constructor() {
-        super();
-    }
-
-    // ==================== Abstract Method Implementations ====================
-
-    protected override get eol(): string {
-        return "\n";
-    }
-
-    protected override async ensureLogDirectory(): Promise<void> {
-        const root = await navigator.storage.getDirectory();
-        this.logDir = await root.getDirectoryHandle(LOG_DIR_NAME, { create: true });
-    }
-
-    protected override async openLogFile(fileName: string): Promise<void> {
-        if (!this.logDir) {
-            await this.ensureLogDirectory();
-        }
-
-        // Close existing file if open
-        if (this.currentFile) {
-            this.currentFile.close();
-            this.currentFile = null;
-        }
-
-        const fileHandle = await this.logDir!.getFileHandle(fileName, { create: true });
-
-        // Try to create sync access handle with retry logic for worker restarts
-        // Previous worker may have left handle open before being terminated
-        const maxRetries = 3;
-        const retryDelay = 100;
-
-        for (let attempt = 0; attempt < maxRetries; attempt++) {
-            try {
-                this.currentFile = await fileHandle.createSyncAccessHandle();
-                break;
-            } catch (error) {
-                if (attempt === maxRetries - 1) {
-                    // Last attempt failed - fall back to console-only logging
-                    console.warn("[LogService] Could not open log file, using console-only logging:", error);
-                    this.currentFile = null;
-                    this.currentFileName = "";
-                    return;
-                }
-                // Wait before retrying - previous handle may be released
-                await new Promise(resolve => setTimeout(resolve, retryDelay * (attempt + 1)));
-            }
-        }
-
-        this.currentFileName = fileName;
-
-        // Seek to end for appending
-        if (this.currentFile) {
-            const size = this.currentFile.getSize();
-            this.currentFile.truncate(size); // No-op, but ensures we're at the right position
-        }
-    }
-
-    protected override closeLogFile(): void {
-        if (this.currentFile) {
-            this.currentFile.close();
-            this.currentFile = null;
-            this.currentFileName = "";
-        }
-    }
-
-    protected override writeEntry(entry: string): void {
-        if (!this.currentFile) {
-            console.log(entry); // Fallback to console if file not ready
-            return;
-        }
-
-        const data = this.textEncoder.encode(entry);
-        const currentSize = this.currentFile.getSize();
-        this.currentFile.write(data, { at: currentSize });
-        this.currentFile.flush();
-    }
-
-    protected override readLogFile(fileName: string): string | null {
-        if (!this.logDir) {
-            return null;
-        }
-
-        try {
-            // For the current file, we need to read from the sync handle
-            if (fileName === this.currentFileName && this.currentFile) {
-                const size = this.currentFile.getSize();
-                const buffer = new ArrayBuffer(size);
-                const view = new DataView(buffer);
-                this.currentFile.read(view, { at: 0 });
-                return this.textDecoder.decode(buffer);
-            }
-
-            // For other files, we'd need async access - return null for now
-            // The current file is what's most commonly needed
-            return null;
-        } catch {
-            return null;
-        }
-    }
-
-    protected override async listLogFiles(): Promise<LogFileInfo[]> {
-        if (!this.logDir) {
-            return [];
-        }
-
-        const logFiles: LogFileInfo[] = [];
-
-        for await (const [name, handle] of this.logDir.entries()) {
-            if (handle.kind !== "file" || !LOG_FILE_PATTERN.test(name)) {
-                continue;
-            }
-
-            // OPFS doesn't provide mtime directly, so we parse from filename
-            const match = name.match(/trilium-(\d{4})-(\d{2})-(\d{2})\.log/);
-            if (match) {
-                const mtime = new Date(
-                    parseInt(match[1]),
-                    parseInt(match[2]) - 1,
-                    parseInt(match[3])
-                );
-                logFiles.push({ name, mtime });
-            }
-        }
-
-        return logFiles;
-    }
-
-    protected override async deleteLogFile(fileName: string): Promise<void> {
-        if (!this.logDir) {
-            return;
-        }
-
-        // Don't delete the current file
-        if (fileName === this.currentFileName) {
-            return;
-        }
-
-        try {
-            await this.logDir.removeEntry(fileName);
-        } catch {
-            // File might not exist or be locked
-        }
-    }
-
-    protected override getRetentionDays(): number {
-        // Standalone doesn't have config system, use default
-        return DEFAULT_RETENTION_DAYS;
-    }
-}

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

@@ -1,120 +0,0 @@
-import type { WebSocketMessage } from "@triliumnext/commons";
-import type { ClientMessageHandler, MessageHandler,MessagingProvider } 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 clientMessageHandler?: ClientMessageHandler;
-    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 the client message handler (used by ws.ts for log-error, log-info, ping)
-            if (this.clientMessageHandler) {
-                try {
-                    this.clientMessageHandler("main-thread", message);
-                } catch (e) {
-                    console.error("[WorkerMessagingProvider] Error in client message handler:", e);
-                }
-            }
-
-            // 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);
-        }
-    }
-
-    /**
-     * Send a message to a specific client.
-     * In worker context, there's only one client (the main thread), so clientId is ignored.
-     */
-    sendMessageToClient(_clientId: string, message: WebSocketMessage): boolean {
-        if (this.isDisposed) {
-            return false;
-        }
-
-        this.sendMessageToAllClients(message);
-        return true;
-    }
-
-    /**
-     * Register a handler for incoming client messages.
-     */
-    setClientMessageHandler(handler: ClientMessageHandler): void {
-        this.clientMessageHandler = handler;
-    }
-
-    /**
-     * 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/platform_provider.ts

@@ -1,36 +0,0 @@
-import type { PlatformProvider } from "@triliumnext/core";
-
-/** Maps URL query parameter names to TRILIUM_ environment variable names. */
-const QUERY_TO_ENV: Record<string, string> = {
-    "safeMode": "TRILIUM_SAFE_MODE",
-    "startNoteId": "TRILIUM_START_NOTE_ID",
-};
-
-export default class StandalonePlatformProvider implements PlatformProvider {
-    readonly isElectron = false;
-    readonly isMac = false;
-    readonly isWindows = false;
-
-    private envMap: Record<string, string> = {};
-
-    constructor(queryString: string) {
-        const params = new URLSearchParams(queryString);
-        for (const [queryKey, envKey] of Object.entries(QUERY_TO_ENV)) {
-            if (params.has(queryKey)) {
-                this.envMap[envKey] = params.get(queryKey) || "true";
-            }
-        }
-    }
-
-    crash(message: string): void {
-        console.error("[Standalone] FATAL:", message);
-        self.postMessage({
-            type: "FATAL_ERROR",
-            message
-        });
-    }
-
-    getEnv(key: string): string | undefined {
-        return this.envMap[key];
-    }
-}

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

@@ -1,93 +0,0 @@
-import type { ExecOpts, RequestProvider } from "@triliumnext/core";
-
-/**
- * Fetch-based implementation of RequestProvider for browser environments.
- *
- * Uses the Fetch API instead of Node's http/https modules.
- * Proxy support is not available in browsers, so the proxy option is ignored.
- */
-export default class FetchRequestProvider implements RequestProvider {
-
-    async exec<T>(opts: ExecOpts): Promise<T> {
-        const paging = opts.paging || {
-            pageCount: 1,
-            pageIndex: 0,
-            requestId: "n/a"
-        };
-
-        const headers: Record<string, string> = {
-            "Content-Type": paging.pageCount === 1 ? "application/json" : "text/plain",
-            "pageCount": String(paging.pageCount),
-            "pageIndex": String(paging.pageIndex),
-            "requestId": paging.requestId
-        };
-
-        // Note: the Cookie header is a forbidden header in fetch —
-        // the browser manages cookies automatically via credentials: 'include'.
-
-        if (opts.auth?.password) {
-            headers["trilium-cred"] = btoa(`dummy:${opts.auth.password}`);
-        }
-
-        let body: string | undefined;
-        if (opts.body) {
-            body = typeof opts.body === "object" ? JSON.stringify(opts.body) : opts.body;
-        }
-
-        const controller = new AbortController();
-        const timeoutId = opts.timeout
-            ? setTimeout(() => controller.abort(), opts.timeout)
-            : undefined;
-
-        try {
-            const response = await fetch(opts.url, {
-                method: opts.method,
-                headers,
-                body,
-                signal: controller.signal,
-                credentials: "include"
-            });
-
-            if ([200, 201, 204].includes(response.status)) {
-                const text = await response.text();
-                return text.trim() ? JSON.parse(text) : null;
-            }
-            const text = await response.text();
-            let errorMessage: string;
-            try {
-                const json = JSON.parse(text);
-                errorMessage = json?.message || "";
-            } catch {
-                errorMessage = text.substring(0, 100);
-            }
-            throw new Error(`${response.status} ${opts.method} ${opts.url}: ${errorMessage}`);
-
-        } catch (e: any) {
-            if (e.name === "AbortError") {
-                throw new Error(`${opts.method} ${opts.url} failed, error: timeout after ${opts.timeout}ms`);
-            }
-            if (e instanceof TypeError && e.message === "Failed to fetch") {
-                const isCrossOrigin = !opts.url.startsWith(location.origin);
-                if (isCrossOrigin) {
-                    throw new Error(`Request to ${opts.url} was blocked. The server may not allow requests from this origin (CORS), or it may be unreachable.`);
-                }
-                throw new Error(`Request to ${opts.url} failed. The server may be unreachable.`);
-            }
-            throw e;
-        } finally {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-        }
-    }
-
-    async getImage(imageUrl: string): Promise<ArrayBuffer> {
-        const response = await fetch(imageUrl);
-
-        if (!response.ok) {
-            throw new Error(`${response.status} GET ${imageUrl} failed`);
-        }
-
-        return await response.arrayBuffer();
-    }
-}

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

@@ -1,628 +0,0 @@
-import { type BindableValue, default as sqlite3InitModule } from "@sqlite.org/sqlite-wasm";
-import type { DatabaseProvider, RunResult, Statement, Transaction } from "@triliumnext/core";
-
-// 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,
-        private sql: string
-    ) {}
-
-    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;
-    }
-
-    /**
-     * Detect the prefix used for a parameter name in the SQL query.
-     * SQLite supports @name, :name, and $name parameter styles.
-     * Returns the prefix character, or ':' as default if not found.
-     */
-    private detectParamPrefix(paramName: string): string {
-        // Search for the parameter with each possible prefix
-        for (const prefix of [':', '@', '$']) {
-            // Use word boundary to avoid partial matches
-            const pattern = new RegExp(`\\${prefix}${paramName}(?![a-zA-Z0-9_])`);
-            if (pattern.test(this.sql)) {
-                return prefix;
-            }
-        }
-        // Default to ':' if not found (most common in Trilium)
-        return ':';
-    }
-
-    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 $)
-            // We detect the prefix used in the SQL for each parameter
-            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 {
-                    // Detect the prefix used in the SQL and apply it
-                    const prefix = this.detectParamPrefix(key);
-                    bindings[`${prefix}${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");
-
-        const loadTime = performance.now() - startTime;
-        console.log(`[BrowserSqlProvider] In-memory database created in ${loadTime.toFixed(2)}ms`);
-    }
-
-    loadFromBuffer(buffer: Uint8Array): void {
-        this.ensureSqlite3();
-        // SQLite WASM's allocFromTypedArray rejects Node's Buffer (and other
-        // non-Uint8Array typed arrays) with "expecting 8/16/32/64". Normalize
-        // to a plain Uint8Array view over the same memory so callers can pass
-        // anything readFileSync returns.
-        const view = buffer instanceof Uint8Array && buffer.constructor === Uint8Array
-            ? buffer
-            : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        const p = this.sqlite3!.wasm.allocFromTypedArray(view);
-        try {
-            // Cached statements reference the previous DB and become invalid
-            // once we swap connections. Drop them so callers re-prepare.
-            this.clearStatementCache();
-            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,
-                view.byteLength,
-                view.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!, query);
-        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 (either tracked via JS flag or via actual SQLite
-            // autocommit state), use SAVEPOINTs for nesting — this handles the case where a manual
-            // BEGIN was issued directly (e.g. transactionalAsync) without going through transaction().
-            const sqliteInTransaction = self.db?.pointer !== undefined
-                && (self.sqlite3!.capi as any).sqlite3_get_autocommit(self.db!.pointer) === 0;
-            if (self._inTransaction || sqliteInTransaction) {
-                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);
-    }
-
-    private clearStatementCache(): void {
-        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();
-    }
-
-    close(): void {
-        this.clearStatementCache();
-
-        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

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

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

@@ -1,18 +0,0 @@
-import { type ExportFormat, type ZipExportProviderData, ZipExportProvider } from "@triliumnext/core";
-
-import contentCss from "@triliumnext/ckeditor5/src/theme/ck-content.css?raw";
-
-export async function standaloneZipExportProviderFactory(format: ExportFormat, data: ZipExportProviderData): Promise<ZipExportProvider> {
-    switch (format) {
-        case "html": {
-            const { default: HtmlExportProvider } = await import("@triliumnext/core/src/services/export/zip/html.js");
-            return new HtmlExportProvider(data, { contentCss });
-        }
-        case "markdown": {
-            const { default: MarkdownExportProvider } = await import("@triliumnext/core/src/services/export/zip/markdown.js");
-            return new MarkdownExportProvider(data);
-        }
-        default:
-            throw new Error(`Unsupported export format: '${format}'`);
-    }
-}

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

@@ -1,101 +0,0 @@
-import type { FileStream, ZipArchive, ZipEntry, ZipProvider } from "@triliumnext/core/src/services/zip_provider.js";
-import { strToU8, unzip, zipSync } from "fflate";
-
-type ZipOutput = {
-    send?: (body: unknown) => unknown;
-    write?: (chunk: Uint8Array | string) => unknown;
-    end?: (chunk?: Uint8Array | string) => unknown;
-};
-
-class BrowserZipArchive implements ZipArchive {
-    readonly #entries: Record<string, Uint8Array> = {};
-    #destination: ZipOutput | null = null;
-
-    append(content: string | Uint8Array, options: { name: string }) {
-        this.#entries[options.name] = typeof content === "string" ? strToU8(content) : content;
-    }
-
-    pipe(destination: unknown) {
-        this.#destination = destination as ZipOutput;
-    }
-
-    async finalize(): Promise<void> {
-        if (!this.#destination) {
-            throw new Error("ZIP output destination not set.");
-        }
-
-        const content = zipSync(this.#entries, { level: 9 });
-
-        if (typeof this.#destination.send === "function") {
-            this.#destination.send(content);
-            return;
-        }
-
-        if (typeof this.#destination.end === "function") {
-            if (typeof this.#destination.write === "function") {
-                this.#destination.write(content);
-                this.#destination.end();
-            } else {
-                this.#destination.end(content);
-            }
-            return;
-        }
-
-        throw new Error("Unsupported ZIP output destination.");
-    }
-}
-
-export default class BrowserZipProvider implements ZipProvider {
-    createZipArchive(): ZipArchive {
-        return new BrowserZipArchive();
-    }
-
-    createFileStream(_filePath: string): FileStream {
-        throw new Error("File stream creation is not supported in the browser.");
-    }
-
-    readZipFile(
-        buffer: Uint8Array,
-        processEntry: (entry: ZipEntry, readContent: () => Promise<Uint8Array>) => Promise<void>
-    ): Promise<void> {
-        return new Promise<void>((res, rej) => {
-            unzip(buffer, async (err, files) => {
-                if (err) { rej(err); return; }
-
-                try {
-                    for (const [fileName, data] of Object.entries(files)) {
-                        await processEntry(
-                            { fileName: decodeZipFileName(fileName) },
-                            () => Promise.resolve(data)
-                        );
-                    }
-                    res();
-                } catch (e) {
-                    rej(e);
-                }
-            });
-        });
-    }
-}
-
-const utf8Decoder = new TextDecoder("utf-8", { fatal: true });
-
-/**
- * fflate decodes ZIP entry filenames as CP437/Latin-1 unless the language
- * encoding flag (general purpose bit 11) is set, but many real-world archives
- * (e.g. those produced by macOS / Linux unzip / Python's zipfile) write UTF-8
- * filenames without setting that flag. Recover the original UTF-8 bytes from
- * fflate's per-byte string and re-decode them; if the result isn't valid
- * UTF-8 we fall back to the as-decoded name.
- */
-function decodeZipFileName(name: string): string {
-    const bytes = new Uint8Array(name.length);
-    for (let i = 0; i < name.length; i++) {
-        bytes[i] = name.charCodeAt(i) & 0xff;
-    }
-    try {
-        return utf8Decoder.decode(bytes);
-    } catch {
-        return name;
-    }
-}

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

@@ -1,110 +0,0 @@
-import LocalServerWorker from "./local-server-worker?worker";
-let localWorker: Worker | null = null;
-const pending = new Map();
-
-function showFatalErrorDialog(message: string) {
-    alert(message);
-}
-
-export function startLocalServerWorker() {
-    if (localWorker) return localWorker;
-    localWorker = new LocalServerWorker();
-    localWorker.postMessage({ type: "INIT", queryString: location.search });
-
-    // 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 fatal platform crashes (shown as a dialog to the user)
-        if (msg?.type === "FATAL_ERROR") {
-            console.error("[LocalBridge] Fatal error:", msg.message);
-            showFatalErrorDialog(msg.message);
-            return;
-        }
-
-        // 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;
-        }
-
-        // Handle WebSocket-like messages from the worker (for frontend updates)
-        if (msg?.type === "WS_MESSAGE" && msg.message) {
-            // Dispatch a custom event that ws.ts listens to in standalone mode
-            window.dispatchEvent(new CustomEvent("trilium:ws-message", {
-                detail: msg.message
-            }));
-            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<{ body?: ArrayBuffer }>((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: unknown) {
-            const errorMessage = e instanceof Error ? e.message : String(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(errorMessage).buffer
-                }
-            });
-        }
-    });
-}

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

@@ -1,303 +0,0 @@
-// =============================================================================
-// ERROR HANDLERS FIRST - No static imports above this!
-// ES modules hoist static imports, so they execute BEFORE any code runs.
-// We use dynamic imports below to ensure error handlers are registered first.
-// =============================================================================
-
-self.onerror = (message, source, lineno, colno, error) => {
-    const errorMsg = `[Worker] Uncaught error: ${message}\n  at ${source}:${lineno}:${colno}`;
-    console.error(errorMsg, error);
-    try {
-        self.postMessage({
-            type: "WORKER_ERROR",
-            error: {
-                message: String(message),
-                source,
-                lineno,
-                colno,
-                stack: error?.stack || new Error().stack
-            }
-        });
-    } catch (e) {
-        console.error("[Worker] Failed to report error:", e);
-    }
-    return false;
-};
-
-self.onunhandledrejection = (event) => {
-    const reason = event.reason;
-    const errorMsg = `[Worker] Unhandled rejection: ${reason?.message || reason}`;
-    console.error(errorMsg, reason);
-    try {
-        self.postMessage({
-            type: "WORKER_ERROR",
-            error: {
-                message: String(reason?.message || reason),
-                stack: reason?.stack || new Error().stack
-            }
-        });
-    } catch (e) {
-        console.error("[Worker] Failed to report rejection:", e);
-    }
-};
-
-console.log("[Worker] Error handlers installed, loading modules...");
-
-// =============================================================================
-// TYPE-ONLY IMPORTS (erased at runtime, safe as static imports)
-// =============================================================================
-import type { BrowserRouter } from './lightweight/browser_router';
-
-// =============================================================================
-// MODULE STATE (populated by dynamic imports)
-// =============================================================================
-let BrowserSqlProvider: typeof import('./lightweight/sql_provider').default;
-let WorkerMessagingProvider: typeof import('./lightweight/messaging_provider').default;
-let BrowserExecutionContext: typeof import('./lightweight/cls_provider').default;
-let BrowserCryptoProvider: typeof import('./lightweight/crypto_provider').default;
-let BrowserZipProvider: typeof import('./lightweight/zip_provider').default;
-let FetchRequestProvider: typeof import('./lightweight/request_provider').default;
-let StandalonePlatformProvider: typeof import('./lightweight/platform_provider').default;
-let StandaloneLogService: typeof import('./lightweight/log_provider').default;
-let StandaloneBackupService: typeof import('./lightweight/backup_provider').default;
-let translationProvider: typeof import('./lightweight/translation_provider').default;
-let createConfiguredRouter: typeof import('./lightweight/browser_routes').createConfiguredRouter;
-
-// Instance state
-let sqlProvider: InstanceType<typeof BrowserSqlProvider> | null = null;
-let messagingProvider: InstanceType<typeof WorkerMessagingProvider> | null = null;
-
-// 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;
-let queryString = "";
-
-/**
- * Load all required modules using dynamic imports.
- * This allows errors to be caught by our error handlers.
- */
-async function loadModules(): Promise<void> {
-    console.log("[Worker] Loading lightweight modules...");
-    const [
-        sqlModule,
-        messagingModule,
-        clsModule,
-        cryptoModule,
-        zipModule,
-        requestModule,
-        platformModule,
-        logModule,
-        backupModule,
-        translationModule,
-        routesModule
-    ] = await Promise.all([
-        import('./lightweight/sql_provider.js'),
-        import('./lightweight/messaging_provider.js'),
-        import('./lightweight/cls_provider.js'),
-        import('./lightweight/crypto_provider.js'),
-        import('./lightweight/zip_provider.js'),
-        import('./lightweight/request_provider.js'),
-        import('./lightweight/platform_provider.js'),
-        import('./lightweight/log_provider.js'),
-        import('./lightweight/backup_provider.js'),
-        import('./lightweight/translation_provider.js'),
-        import('./lightweight/browser_routes.js')
-    ]);
-
-    BrowserSqlProvider = sqlModule.default;
-    WorkerMessagingProvider = messagingModule.default;
-    BrowserExecutionContext = clsModule.default;
-    BrowserCryptoProvider = cryptoModule.default;
-    BrowserZipProvider = zipModule.default;
-    FetchRequestProvider = requestModule.default;
-    StandalonePlatformProvider = platformModule.default;
-    StandaloneLogService = logModule.default;
-    StandaloneBackupService = backupModule.default;
-    translationProvider = translationModule.default;
-    createConfiguredRouter = routesModule.createConfiguredRouter;
-
-    // Create instances
-    sqlProvider = new BrowserSqlProvider();
-    messagingProvider = new WorkerMessagingProvider();
-
-    console.log("[Worker] Lightweight modules loaded successfully");
-}
-
-/**
- * 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 {
-            // First, load all modules dynamically
-            await loadModules();
-
-            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");
-            } 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...");
-            const schemaModule = await import("@triliumnext/core/src/assets/schema.sql?raw");
-            coreModule = await import("@triliumnext/core");
-
-            // Initialize log service with OPFS persistence
-            const logService = new StandaloneLogService();
-            await logService.initialize();
-            console.log("[Worker] Log service initialized with OPFS");
-
-            await coreModule.initializeCore({
-                executionContext: new BrowserExecutionContext(),
-                crypto: new BrowserCryptoProvider(),
-                zip: new BrowserZipProvider(),
-                zipExportProviderFactory: (await import("./lightweight/zip_export_provider_factory.js")).standaloneZipExportProviderFactory,
-                messaging: messagingProvider!,
-                request: new FetchRequestProvider(),
-                platform: new StandalonePlatformProvider(queryString),
-                log: logService,
-                backup: new StandaloneBackupService(coreModule!.options),
-                translations: translationProvider,
-                schema: schemaModule.default,
-                getDemoArchive: async () => {
-                    const response = await fetch("/server-assets/db/demo.zip");
-                    if (!response.ok) return null;
-                    return new Uint8Array(await response.arrayBuffer());
-                },
-                image: (await import("./services/image_provider.js")).standaloneImageProvider,
-                dbConfig: {
-                    provider: sqlProvider!,
-                    isReadOnly: false,
-                    onTransactionCommit: () => {
-                        coreModule?.ws.sendTransactionEntityChangesToAllClients();
-                    },
-                    onTransactionRollback: () => {
-                        // No-op for now
-                    }
-                }
-            });
-            coreModule.ws.init();
-
-            console.log("[Worker] Supported routes", Object.keys(coreModule.routes));
-
-            // Create and configure the router
-            router = createConfiguredRouter();
-            console.log("[Worker] Router configured");
-
-            // initializeDb runs initDbConnection inside an execution context,
-            // which resolves dbReady — required before beccaLoaded can settle.
-            coreModule.sql_init.initializeDb();
-
-            if (coreModule.sql_init.isDbInitialized()) {
-                console.log("[Worker] Database already initialized, loading becca...");
-                await coreModule.becca_loader.beccaLoaded;
-            } else {
-                console.log("[Worker] Database not initialized, skipping becca load (will be loaded during DB initialization)");
-            }
-
-            coreModule.scheduler.startScheduler();
-
-            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) {
-    // 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) return;
-
-    if (msg.type === "INIT") {
-        queryString = msg.queryString || "";
-        return;
-    }
-
-    if (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

@@ -1,84 +0,0 @@
-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/services/data_encryption.spec.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { data_encryption } from "@triliumnext/core";
-
-// Note: BrowserCryptoProvider is already initialized via test_setup.ts
-
-describe("data_encryption with BrowserCryptoProvider", () => {
-    it("should encrypt and decrypt ASCII text correctly", () => {
-        const key = new Uint8Array(16).fill(42);
-        const plainText = "Hello, World!";
-
-        const encrypted = data_encryption.encrypt(key, plainText);
-        expect(typeof encrypted).toBe("string");
-        expect(encrypted.length).toBeGreaterThan(0);
-
-        const decrypted = data_encryption.decryptString(key, encrypted);
-        expect(decrypted).toBe(plainText);
-    });
-
-    it("should encrypt and decrypt UTF-8 text correctly", () => {
-        const key = new Uint8Array(16).fill(42);
-        const plainText = "Привет мир! 你好世界! 🎉";
-
-        const encrypted = data_encryption.encrypt(key, plainText);
-        const decrypted = data_encryption.decryptString(key, encrypted);
-        expect(decrypted).toBe(plainText);
-    });
-
-    it("should encrypt and decrypt empty string", () => {
-        const key = new Uint8Array(16).fill(42);
-        const plainText = "";
-
-        const encrypted = data_encryption.encrypt(key, plainText);
-        const decrypted = data_encryption.decryptString(key, encrypted);
-        expect(decrypted).toBe(plainText);
-    });
-
-    it("should encrypt and decrypt binary data", () => {
-        const key = new Uint8Array(16).fill(42);
-        const plainData = new Uint8Array([0, 1, 2, 255, 128, 64]);
-
-        const encrypted = data_encryption.encrypt(key, plainData);
-        const decrypted = data_encryption.decrypt(key, encrypted);
-        expect(decrypted).toBeInstanceOf(Uint8Array);
-        expect(Array.from(decrypted as Uint8Array)).toEqual(Array.from(plainData));
-    });
-
-    it("should fail decryption with wrong key", () => {
-        const key1 = new Uint8Array(16).fill(42);
-        const key2 = new Uint8Array(16).fill(43);
-        const plainText = "Secret message";
-
-        const encrypted = data_encryption.encrypt(key1, plainText);
-
-        // decrypt returns false when digest doesn't match
-        const result = data_encryption.decrypt(key2, encrypted);
-        expect(result).toBe(false);
-    });
-
-    it("should handle large content", () => {
-        const key = new Uint8Array(16).fill(42);
-        const plainText = "x".repeat(100000);
-
-        const encrypted = data_encryption.encrypt(key, plainText);
-        const decrypted = data_encryption.decryptString(key, encrypted);
-        expect(decrypted).toBe(plainText);
-    });
-});

apps/client-standalone/src/services/image_provider.ts

@@ -1,96 +0,0 @@
-/**
- * Standalone image provider implementation.
- * Uses pure JavaScript for format detection without compression.
- * Images are saved as-is without resizing.
- */
-
-import type { ImageProvider, ImageFormat, ProcessedImage } from "@triliumnext/core";
-
-/**
- * Detect image type from buffer using magic bytes.
- */
-function getImageTypeFromBuffer(buffer: Uint8Array): ImageFormat | null {
-    if (buffer.length < 12) {
-        return null;
-    }
-
-    // Check for SVG (text-based)
-    if (isSvg(buffer)) {
-        return { ext: "svg", mime: "image/svg+xml" };
-    }
-
-    // JPEG: FF D8 FF
-    if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
-        return { ext: "jpg", mime: "image/jpeg" };
-    }
-
-    // PNG: 89 50 4E 47 0D 0A 1A 0A
-    if (
-        buffer[0] === 0x89 &&
-        buffer[1] === 0x50 &&
-        buffer[2] === 0x4e &&
-        buffer[3] === 0x47 &&
-        buffer[4] === 0x0d &&
-        buffer[5] === 0x0a &&
-        buffer[6] === 0x1a &&
-        buffer[7] === 0x0a
-    ) {
-        return { ext: "png", mime: "image/png" };
-    }
-
-    // GIF: "GIF"
-    if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {
-        return { ext: "gif", mime: "image/gif" };
-    }
-
-    // WebP: RIFF....WEBP
-    if (
-        buffer[0] === 0x52 &&
-        buffer[1] === 0x49 &&
-        buffer[2] === 0x46 &&
-        buffer[3] === 0x46 &&
-        buffer[8] === 0x57 &&
-        buffer[9] === 0x45 &&
-        buffer[10] === 0x42 &&
-        buffer[11] === 0x50
-    ) {
-        return { ext: "webp", mime: "image/webp" };
-    }
-
-    // BMP: "BM"
-    if (buffer[0] === 0x42 && buffer[1] === 0x4d) {
-        return { ext: "bmp", mime: "image/bmp" };
-    }
-
-    return null;
-}
-
-/**
- * Check if buffer contains SVG content.
- */
-function isSvg(buffer: Uint8Array): boolean {
-    const maxBytes = Math.min(buffer.length, 1000);
-    let str = "";
-    for (let i = 0; i < maxBytes; i++) {
-        str += String.fromCharCode(buffer[i]);
-    }
-
-    const trimmed = str.trim().toLowerCase();
-    return trimmed.startsWith("<svg") || (trimmed.startsWith("<?xml") && trimmed.includes("<svg"));
-}
-
-export const standaloneImageProvider: ImageProvider = {
-    getImageType(buffer: Uint8Array): ImageFormat | null {
-        return getImageTypeFromBuffer(buffer);
-    },
-
-    async processImage(buffer: Uint8Array, _originalName: string, _shrink: boolean): Promise<ProcessedImage> {
-        // Standalone doesn't do compression - just detect format and return original
-        const format = getImageTypeFromBuffer(buffer) || { ext: "dat", mime: "application/octet-stream" };
-
-        return {
-            buffer,
-            format
-        };
-    }
-};

apps/client-standalone/src/sw.ts

@@ -1,196 +0,0 @@
-// 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 the main app window to handle the request
-    // We must route to the main app (which has the local bridge), not iframes like PDF.js viewer
-    // @ts-expect-error - self.clients is valid in service worker context
-    const all = await self.clients.matchAll({ type: "window", includeUncontrolled: true });
-
-    // Find the main app window - it's the one NOT serving pdfjs or other embedded content
-    // The main app has the local bridge handler for LOCAL_FETCH messages
-    let client = all.find((c: { url: string }) => {
-        const url = new URL(c.url);
-        // Main app is at root or index.html, not in /pdfjs/ or other iframe paths
-        return !url.pathname.startsWith("/pdfjs/");
-    }) || null;
-
-    // If no main app window found, fall back to any available client
-    if (!client) {
-        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;
-
-    // API-ish: local-first via bridge (must be checked before navigate handling,
-    // because export triggers a navigation to an /api/ URL)
-    if (isLocalFirst(url)) {
-        event.respondWith(forwardToClientLocalServer(event.request, event.clientId));
-        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") {
-        event.respondWith(cacheFirst(event.request));
-        return;
-    }
-
-    // Default
-    event.respondWith(fetch(event.request));
-});

apps/client-standalone/src/test_setup.ts

@@ -1,142 +0,0 @@
-import { createRequire } from "node:module";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-import { initializeCore, options } from "@triliumnext/core";
-import schemaSql from "@triliumnext/core/src/assets/schema.sql?raw";
-import HappyDomHtmlParser from "happy-dom/lib/html-parser/HTMLParser.js";
-import serverEnTranslations from "../../server/src/assets/translations/en/server.json";
-import { beforeAll } from "vitest";
-
-import StandaloneBackupService from "./lightweight/backup_provider.js";
-import BrowserExecutionContext from "./lightweight/cls_provider.js";
-import BrowserCryptoProvider from "./lightweight/crypto_provider.js";
-import StandalonePlatformProvider from "./lightweight/platform_provider.js";
-import BrowserSqlProvider from "./lightweight/sql_provider.js";
-import BrowserZipProvider from "./lightweight/zip_provider.js";
-
-// =============================================================================
-// SQLite WASM compatibility shims
-// =============================================================================
-// The @sqlite.org/sqlite-wasm package loads its .wasm via fetch, and its
-// bundled `instantiateWasm` hook overrides any user-supplied alternative.
-// Two things go wrong under vitest + happy-dom:
-//   1. happy-dom's `fetch()` refuses `file://` URLs.
-//   2. happy-dom installs its own Response global, which Node's
-//      `WebAssembly.instantiateStreaming` rejects ("Received an instance of
-//      Response" — it wants undici's Response).
-// We intercept fetch for file:// URLs ourselves and force instantiateStreaming
-// to fall back to the ArrayBuffer path.
-const fileFetchCache = new Map<string, ArrayBuffer>();
-
-function readFileAsArrayBuffer(url: string): ArrayBuffer {
-    let cached = fileFetchCache.get(url);
-    if (!cached) {
-        const bytes = readFileSync(fileURLToPath(url));
-        cached = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;
-        fileFetchCache.set(url, cached);
-    }
-    return cached;
-}
-
-const originalFetch = globalThis.fetch;
-globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
-    const url = typeof input === "string"
-        ? input
-        : input instanceof URL
-            ? input.href
-            : input.url;
-
-    if (url.startsWith("file://")) {
-        const body = readFileAsArrayBuffer(url);
-        return new Response(body, {
-            status: 200,
-            headers: { "Content-Type": "application/wasm" }
-        });
-    }
-
-    return originalFetch(input as RequestInfo, init);
-}) as typeof fetch;
-
-WebAssembly.instantiateStreaming = (async (source, importObject) => {
-    const response = await source;
-    const bytes = await response.arrayBuffer();
-    return WebAssembly.instantiate(bytes, importObject);
-}) as typeof WebAssembly.instantiateStreaming;
-
-// =============================================================================
-// happy-dom HTMLParser spec compliance patch
-// =============================================================================
-// Per HTML5 parsing spec, a single U+000A LINE FEED immediately after a <pre>,
-// <listing>, or <textarea> start tag must be ignored ("newlines at the start
-// of pre blocks are ignored as an authoring convenience"). Real browsers and
-// domino (which the server runtime uses via turnish) both implement this;
-// happy-dom (as of 20.8.9) does not — it keeps the LF as a text node.
-//
-// That difference makes turnish's markdown export produce different output
-// under happy-dom vs. production, breaking markdown.spec.ts > "exports jQuery
-// code in table properly". Patch HTMLParser.parse to pre-process the string.
-const LEADING_LF_IN_PRE_RE = /(<(?:pre|listing|textarea)\b[^>]*>)(\r\n|\r|\n)/gi;
-const originalHtmlParserParse = (HappyDomHtmlParser as unknown as {
-    prototype: { parse(html: string, rootNode?: unknown): unknown };
-}).prototype.parse;
-(HappyDomHtmlParser as unknown as {
-    prototype: { parse(html: string, rootNode?: unknown): unknown };
-}).prototype.parse = function (html: string, rootNode?: unknown) {
-    const patched = typeof html === "string"
-        ? html.replace(LEADING_LF_IN_PRE_RE, "$1")
-        : html;
-    return originalHtmlParserParse.call(this, patched, rootNode);
-};
-
-// =============================================================================
-// Core initialization for standalone-flavored tests
-// =============================================================================
-// Mirror what apps/server/spec/setup.ts does: load the pre-seeded integration
-// fixture DB into an in-memory sqlite-wasm instance, then initialize core
-// against it with the standalone (browser) providers. Each vitest worker gets
-// a fresh copy because tests run in forks (per the default pool).
-
-const require = createRequire(import.meta.url);
-const fixtureDb = readFileSync(
-    require.resolve("@triliumnext/core/src/test/fixtures/document.db")
-);
-
-beforeAll(async () => {
-    const sqlProvider = new BrowserSqlProvider();
-    await sqlProvider.initWasm();
-    sqlProvider.loadFromBuffer(fixtureDb);
-
-    await initializeCore({
-        executionContext: new BrowserExecutionContext(),
-        crypto: new BrowserCryptoProvider(),
-        zip: new BrowserZipProvider(),
-        zipExportProviderFactory: (
-            await import("./lightweight/zip_export_provider_factory.js")
-        ).standaloneZipExportProviderFactory,
-        // i18next must be wired up — keyboard_actions.ts and other modules
-        // call `t()` and throw if translations are missing. Inline the
-        // en/server.json resources via vite's JSON import so we don't need a
-        // backend in tests.
-        translations: async (i18nextInstance, locale) => {
-            await i18nextInstance.init({
-                lng: locale,
-                fallbackLng: "en",
-                ns: "server",
-                defaultNS: "server",
-                resources: {
-                    en: { server: serverEnTranslations }
-                }
-            });
-        },
-        platform: new StandalonePlatformProvider(""),
-        backup: new StandaloneBackupService(options),
-        schema: schemaSql,
-        dbConfig: {
-            provider: sqlProvider,
-            isReadOnly: false,
-            onTransactionCommit: () => {},
-            onTransactionRollback: () => {}
-        }
-    });
-});

apps/client-standalone/tsconfig.app.json

@@ -1,26 +0,0 @@
-{
-  "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

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

apps/client-standalone/tsconfig.spec.json

@@ -1,18 +0,0 @@
-{
-  "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

@@ -1,277 +0,0 @@
-import fs from "fs";
-import { join } from "path";
-
-import prefresh from "@prefresh/vite";
-import { defineConfig, type Plugin } 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"
-                    });
-                }
-            });
-        }
-    }
-});
-
-// Serve PDF.js files directly in dev mode to bypass SPA fallback
-const pdfjsServePlugin = (): Plugin => ({
-    name: "pdfjs-serve",
-    configureServer(server) {
-        const pdfjsRoot = join(__dirname, "../../packages/pdfjs-viewer/dist");
-
-        server.middlewares.use((req, res, next) => {
-            if (!req.url?.startsWith("/pdfjs/")) {
-                return next();
-            }
-
-            // Map /pdfjs/web/... to dist/web/...
-            // Map /pdfjs/build/... to dist/build/...
-            // Strip query string (e.g., ?v=0.102.2) before resolving path
-            const urlWithoutQuery = req.url.split("?")[0];
-            const relativePath = urlWithoutQuery.replace(/^\/pdfjs\//, "");
-            const filePath = join(pdfjsRoot, relativePath);
-
-            // Security: ensure we're still within pdfjsRoot
-            if (!filePath.startsWith(pdfjsRoot)) {
-                return next();
-            }
-
-            if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
-                const ext = filePath.split(".").pop() || "";
-                const mimeTypes: Record<string, string> = {
-                    html: "text/html",
-                    css: "text/css",
-                    js: "application/javascript",
-                    mjs: "application/javascript",
-                    wasm: "application/wasm",
-                    png: "image/png",
-                    svg: "image/svg+xml",
-                    json: "application/json"
-                };
-                res.setHeader("Content-Type", mimeTypes[ext] || "application/octet-stream");
-                // Match isolation headers from main page for iframe compatibility
-                res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
-                res.setHeader("Cross-Origin-Embedder-Policy", "require-corp");
-                fs.createReadStream(filePath).pipe(res);
-            } else {
-                next();
-            }
-        });
-    }
-});
-
-// 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",
-            rename: { stripBase: true }
-        },
-        {
-            src: "../../../node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3-opfs-async-proxy.js",
-            dest: "assets",
-            rename: { stripBase: true }
-        }
-    ]
-});
-
-let plugins: any = [
-    sqliteWasmPlugin,  // Always include SQLite WASM files
-    viteStaticCopy({
-        targets: clientAssets.map((asset) => ({
-            src: `../../client/src/${asset}/**/*`,
-            dest: asset,
-            rename: { stripBase: 3 }
-        })),
-        // Enable watching in development
-        ...(isDev && {
-            watch: {
-                reloadPageOnChange: true
-            }
-        })
-    }),
-    viteStaticCopy({
-        targets: [
-            {
-                src: "../../server/src/assets/**/*",
-                dest: "server-assets",
-                rename: { stripBase: 3 }
-            }
-        ]
-    }),
-    // PDF.js viewer for PDF preview support
-    // stripBase: 4 removes packages/pdfjs-viewer/dist/web (or /build)
-    viteStaticCopy({
-        targets: [
-            {
-                src: "../../../packages/pdfjs-viewer/dist/web/**/*",
-                dest: "pdfjs/web",
-                rename: { stripBase: 4 }
-            },
-            {
-                src: "../../../packages/pdfjs-viewer/dist/build/**/*",
-                dest: "pdfjs/build",
-                rename: { stripBase: 4 }
-            }
-        ]
-    }),
-    // Watch client files for changes in development
-    ...(isDev ? [
-        prefresh(),
-        clientWatchPlugin(),
-        pdfjsServePlugin()
-    ] : [])
-];
-
-if (!isDev) {
-    plugins = [
-        ...plugins,
-        viteStaticCopy({
-            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'),
-            },
-            output: {
-                entryFileNames: (chunkInfo) => {
-                    // Service worker and other workers should be at root level
-                    if (chunkInfo.name === 'sw') {
-                        return '[name].js';
-                    }
-                    return 'src/[name].js';
-                },
-                chunkFileNames: "src/[name].js",
-                assetFileNames: "src/[name].[ext]"
-            }
-        }
-    },
-    test: {
-        environment: "happy-dom",
-        setupFiles: [join(__dirname, "src/test_setup.ts")],
-        dir: join(__dirname),
-        include: [
-            "src/**/*.{test,spec}.{ts,tsx}",
-            "../../packages/trilium-core/src/**/*.{test,spec}.{ts,tsx}"
-        ],
-        server: {
-            deps: {
-                inline: ["@sqlite.org/sqlite-wasm"]
-            }
-        },
-        alias: {
-            // The package's `node.mjs` entry references a non-existent
-            // `sqlite3-node.mjs`. Force the browser-style entry which works
-            // under Node + happy-dom too.
-            "@sqlite.org/sqlite-wasm": join(
-                __dirname,
-                "../../node_modules/@sqlite.org/sqlite-wasm/index.mjs"
-            )
-        }
-    },
-    define: {
-        "process.env.IS_PREACT": JSON.stringify("true"),
-    }
-}));

apps/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triliumnext/client",
-  "version": "0.102.2",
+  "version": "0.101.3",
   "description": "JQuery-based client for TriliumNext, used for both web and desktop (via Electron)",
   "private": true,
   "license": "AGPL-3.0-only",
@@ -22,71 +22,65 @@
     "@fullcalendar/interaction": "6.1.20",
     "@fullcalendar/list": "6.1.20",
     "@fullcalendar/multimonth": "6.1.20",
-    "@fullcalendar/rrule": "6.1.20",
     "@fullcalendar/timegrid": "6.1.20",
     "@maplibre/maplibre-gl-leaflet": "0.1.3",
-    "@mermaid-js/layout-elk": "0.2.1",
+    "@mermaid-js/layout-elk": "0.2.0",
     "@mind-elixir/node-menu": "5.0.1",
-    "@preact/signals": "2.9.0",
+    "@popperjs/core": "2.11.8",
+    "@preact/signals": "2.6.2",
     "@triliumnext/ckeditor5": "workspace:*",
     "@triliumnext/codemirror": "workspace:*",
     "@triliumnext/commons": "workspace:*",
     "@triliumnext/highlightjs": "workspace:*",
     "@triliumnext/share-theme": "workspace:*",
     "@triliumnext/split.js": "workspace:*",
-    "@univerjs/preset-sheets-conditional-formatting": "0.20.0",
-    "@univerjs/preset-sheets-core": "0.20.0",
-    "@univerjs/preset-sheets-data-validation": "0.20.0",
-    "@univerjs/preset-sheets-filter": "0.20.0",
-    "@univerjs/preset-sheets-find-replace": "0.20.0",
-    "@univerjs/preset-sheets-note": "0.20.0",
-    "@univerjs/preset-sheets-sort": "0.20.0",
-    "@univerjs/presets": "0.20.0",
-    "@zumer/snapdom": "2.7.0",
+    "@zumer/snapdom": "2.0.2",
     "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",
-    "dompurify": "3.3.3",
     "draggabilly": "3.0.0",
-    "force-graph": "1.51.2",
-    "i18next": "26.0.3",
-    "i18next-http-backend": "3.0.4",
+    "force-graph": "1.51.0",
+    "globals": "17.2.0",
+    "i18next": "25.8.0",
+    "i18next-http-backend": "3.0.2",
     "jquery": "4.0.0",
     "jquery.fancytree": "2.38.5",
     "jsplumb": "2.15.6",
-    "katex": "0.16.45",
+    "katex": "0.16.28",
+    "knockout": "3.5.1",
     "leaflet": "1.9.4",
     "leaflet-gpx": "2.2.0",
     "mark.js": "8.11.1",
-    "marked": "18.0.0",
-    "mermaid": "11.14.0",
-    "mind-elixir": "5.10.0",
-    "panzoom": "9.4.4",
-    "preact": "10.29.1",
-    "react-i18next": "17.0.2",
-    "react-window": "2.2.7",
-    "reveal.js": "6.0.0",
-    "rrule": "2.8.1",
+    "marked": "17.0.1",
+    "mermaid": "11.12.2",
+    "mind-elixir": "5.6.1",
+    "normalize.css": "8.0.1",
+    "panzoom": "9.4.3",
+    "preact": "10.28.2",
+    "react-i18next": "16.5.4",
+    "react-window": "2.2.5",
+    "reveal.js": "5.2.1",
     "svg-pan-zoom": "3.6.2",
-    "tabulator-tables": "6.4.0",
+    "tabulator-tables": "6.3.1",
     "vanilla-js-wheel-zoom": "9.0.4"
   },
   "devDependencies": {
     "@ckeditor/ckeditor5-inspector": "5.0.0",
-    "@prefresh/vite": "3.0.0",
+    "@prefresh/vite": "2.4.11",
     "@types/bootstrap": "5.2.10",
-    "@types/jquery": "4.0.0",
+    "@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": "14.0.0",
-    "happy-dom": "20.8.9",
-    "lightningcss": "1.32.0",
+    "copy-webpack-plugin": "13.0.1",
+    "happy-dom": "20.4.0",
+    "lightningcss": "1.31.1",
     "script-loader": "0.7.2",
-    "vite-plugin-static-copy": "4.0.1"
+    "vite-plugin-static-copy": "3.2.0"
   }
 }

apps/client/src/assets/icon-color.svg

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg enable-background="new 0 0 256 256" version="1.1" viewBox="0 0 256 256" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
-	<title>Trilium Notes</title>
-	<style type="text/css">
-		.st0{fill:#95C980;}
-		.st1{fill:#72B755;}
-		.st2{fill:#4FA52B;}
-		.st3{fill:#EE8C89;}
-		.st4{fill:#E96562;}
-		.st5{fill:#E33F3B;}
-		.st6{fill:#EFB075;}
-		.st7{fill:#E99547;}
-		.st8{fill:#E47B19;}
-	</style>
-	<g>
-		<path class="st0" d="m202.9 112.7c-22.5 16.1-54.5 12.8-74.9 6.3l14.8-11.8 14.1-11.3 49.1-39.3-51.2 35.9-14.3 10-14.9 10.5c0.7-21.2 7-49.9 28.6-65.4 1.8-1.3 3.9-2.6 6.1-3.8 2.7-1.5 5.7-2.9 8.8-4.1 27.1-11.1 68.5-15.3 85.2-9.5 0.1 16.2-15.9 45.4-33.9 65.9-2.4 2.8-4.9 5.4-7.4 7.8-3.4 3.5-6.8 6.4-10.1 8.8z"/>
-		<path class="st1" d="m213.1 104c-22.2 12.6-51.4 9.3-70.3 3.2l14.1-11.3 49.1-39.3-51.2 35.9-14.3 10c0.5-18.1 4.9-42.1 19.7-58.6 2.7-1.5 5.7-2.9 8.8-4.1 27.1-11.1 68.5-15.3 85.2-9.5 0.1 16.2-15.9 45.4-33.9 65.9-2.3 2.8-4.8 5.4-7.2 7.8z"/>
-		<path class="st2" d="m220.5 96.2c-21.1 8.6-46.6 5.3-63.7-0.2l49.2-39.4-51.2 35.9c0.3-15.8 3.5-36.6 14.3-52.8 27.1-11.1 68.5-15.3 85.2-9.5 0.1 16.2-15.9 45.4-33.8 66z"/>
-	
-		<path class="st3" d="m106.7 179c-5.8-21 5.2-43.8 15.5-57.2l4.8 14.2 4.5 13.4 15.9 47-12.8-47.6-3.6-13.2-3.7-13.9c15.5 6.2 35.1 18.6 40.7 38.8 0.5 1.7 0.9 3.6 1.2 5.5 0.4 2.4 0.6 5 0.7 7.7 0.9 23.1-7.1 54.9-15.9 65.7-12-4.3-29.3-24-39.7-42.8-1.4-2.6-2.7-5.1-3.8-7.6-1.6-3.5-2.9-6.8-3.8-10z"/>
-		<path class="st4" d="m110.4 188.9c-3.4-19.8 6.9-40.5 16.6-52.9l4.5 13.4 15.9 47-12.8-47.6-3.6-13.2c13.3 5.2 29.9 15 38.1 30.4 0.4 2.4 0.6 5 0.7 7.7 0.9 23.1-7.1 54.9-15.9 65.7-12-4.3-29.3-24-39.7-42.8-1.4-2.6-2.7-5.2-3.8-7.7z"/>
-		<path class="st5" d="m114.2 196.5c-0.7-18 8.6-35.9 17.3-47.1l15.9 47-12.8-47.6c11.6 4.4 26.1 12.4 35.2 24.8 0.9 23.1-7.1 54.9-15.9 65.7-12-4.3-29.3-24-39.7-42.8z"/>
-
-		<path class="st6" d="m86.3 59.1c21.7 10.9 32.4 36.6 35.8 54.9l-15.2-6.6-14.5-6.3-50.6-22 48.8 24.9 13.6 6.9 14.3 7.3c-16.6 7.9-41.3 14.5-62.1 4.1-1.8-0.9-3.6-1.9-5.4-3.2-2.3-1.5-4.5-3.2-6.8-5.1-19.9-16.4-40.3-46.4-42.7-61.5 12.4-6.5 41.5-5.8 64.8-0.3 3.2 0.8 6.2 1.6 9.1 2.5 4 1.3 7.6 2.8 10.9 4.4z"/>
-		<path class="st7" d="m75.4 54.8c18.9 12 28.4 35.6 31.6 52.6l-14.5-6.3-50.6-22 48.7 24.9 13.6 6.9c-14.1 6.8-34.5 13-53.3 8.2-2.3-1.5-4.5-3.2-6.8-5.1-19.8-16.4-40.2-46.4-42.6-61.5 12.4-6.5 41.5-5.8 64.8-0.3 3.1 0.8 6.2 1.6 9.1 2.6z"/>
-		<path class="st8" d="m66.3 52.2c15.3 12.8 23.3 33.6 26.1 48.9l-50.6-22 48.8 24.9c-12.2 6-29.6 11.8-46.5 10-19.8-16.4-40.2-46.4-42.6-61.5 12.4-6.5 41.5-5.8 64.8-0.3z"/>
-	</g>
-</svg>

apps/client/src/components/app_context.ts

@@ -1,11 +1,10 @@
 import type { CKTextEditor } from "@triliumnext/ckeditor5";
 import type CodeMirror from "@triliumnext/codemirror";
-import { type LOCALE_IDS, SqlExecuteResponse } from "@triliumnext/commons";
+import { SqlExecuteResponse } from "@triliumnext/commons";
 import type { NativeImage, TouchBar } from "electron";
 import { ColumnComponent } from "tabulator-tables";
 
 import type { Attribute } from "../services/attribute_parser.js";
-import bundleService from "../services/bundle.js";
 import froca from "../services/froca.js";
 import { initLocale, t } from "../services/i18n.js";
 import keyboardActionsService from "../services/keyboard_actions.js";
@@ -102,6 +101,8 @@ export type CommandMappings = {
     showRevisions: CommandData & {
         noteId?: string | null;
     };
+    showLlmChat: CommandData;
+    createAiChat: CommandData;
     showOptions: CommandData & {
         section: string;
     };
@@ -303,7 +304,6 @@ export type CommandMappings = {
     ninthTab: CommandData;
     lastTab: CommandData;
     showNoteSource: CommandData;
-    showNoteOCRText: CommandData;
     showSQLConsole: CommandData;
     showBackendLog: CommandData;
     showCheatsheet: CommandData;
@@ -510,7 +510,7 @@ type EventMappings = {
     contentSafeMarginChanged: {
         top: number;
         noteContext: NoteContext;
-    };
+    }
 };
 
 export type EventListener<T extends EventNames> = {
@@ -564,7 +564,7 @@ export class AppContext extends Component {
      */
     async earlyInit() {
         await options.initializedPromise;
-        await initLocale((options.get("locale") || "en") as LOCALE_IDS);
+        await initLocale();
     }
 
     setLayout(layout: Layout) {
@@ -579,6 +579,7 @@ export class AppContext extends Component {
 
         this.tabManager.loadTabs();
 
+        const bundleService = (await import("../services/bundle.js")).default;
         setTimeout(() => bundleService.executeStartupBundles(), 2000);
     }
 

apps/client/src/components/note_context.ts

@@ -381,10 +381,6 @@ class NoteContext extends Component implements EventListener<"entitiesReloaded">
 
         // Collections must always display a note list, even if no children.
         if (note.type === "book") {
-            if (note.isProtected && !protectedSessionHolder.isProtectedSessionAvailable()) {
-                return false;
-            }
-
             const viewType = note.getLabelValue("viewType") ?? "grid";
             if (!["list", "grid"].includes(viewType)) {
                 return true;

apps/client/src/components/root_command_executor.ts

@@ -1,8 +1,10 @@
 import dateNoteService from "../services/date_notes.js";
 import froca from "../services/froca.js";
+import noteCreateService from "../services/note_create.js";
 import openService from "../services/open.js";
 import options from "../services/options.js";
 import protectedSessionService from "../services/protected_session.js";
+import toastService from "../services/toast.js";
 import treeService from "../services/tree.js";
 import utils, { openInReusableSplit } from "../services/utils.js";
 import appContext, { type CommandListenerData } from "./app_context.js";
@@ -148,19 +150,6 @@ export default class RootCommandExecutor extends Component {
         }
     }
 
-    async showNoteOCRTextCommand() {
-        const notePath = appContext.tabManager.getActiveContextNotePath();
-
-        if (notePath) {
-            await appContext.tabManager.openTabWithNoteWithHoisting(notePath, {
-                activate: true,
-                viewScope: {
-                    viewMode: "ocr"
-                }
-            });
-        }
-    }
-
     async showAttachmentsCommand() {
         const notePath = appContext.tabManager.getActiveContextNotePath();
 
@@ -259,4 +248,34 @@ export default class RootCommandExecutor extends Component {
         }
     }
 
+    async createAiChatCommand() {
+        try {
+            // Create a new AI Chat note at the root level
+            const rootNoteId = "root";
+
+            const result = await noteCreateService.createNote(rootNoteId, {
+                title: "New AI Chat",
+                type: "aiChat",
+                content: JSON.stringify({
+                    messages: [],
+                    title: "New AI Chat"
+                })
+            });
+
+            if (!result.note) {
+                toastService.showError("Failed to create AI Chat note");
+                return;
+            }
+
+            await appContext.tabManager.openTabWithNoteWithHoisting(result.note.noteId, {
+                activate: true
+            });
+
+            toastService.showMessage("Created new AI Chat note");
+        }
+        catch (e) {
+            console.error("Error creating AI Chat note:", e);
+            toastService.showError(`Failed to create AI Chat note: ${(e as Error).message}`);
+        }
+    }
 }

apps/client/src/desktop.ts

@@ -46,6 +46,10 @@ if (utils.isElectron()) {
     electronContextMenu.setupContextMenu();
 }
 
+if (utils.isPWA()) {
+    initPWATopbarColor();
+}
+
 function initOnElectron() {
     const electron: typeof Electron = utils.dynamicRequire("electron");
     electron.ipcRenderer.on("globalShortcut", async (event, actionName) => appContext.triggerCommand(actionName));
@@ -54,7 +58,7 @@ function initOnElectron() {
     const currentWindow = electronRemote.getCurrentWindow();
     const style = window.getComputedStyle(document.body);
 
-    initDarkOrLightMode();
+    initDarkOrLightMode(style);
     initTransparencyEffects(style, currentWindow);
     initFullScreenDetection(currentWindow);
 
@@ -119,14 +123,31 @@ function initTransparencyEffects(style: CSSStyleDeclaration, currentWindow: Elec
  *
  * @param style the root CSS element to read variables from.
  */
-function initDarkOrLightMode() {
+function initDarkOrLightMode(style: CSSStyleDeclaration) {
     let themeSource: typeof nativeTheme.themeSource = "system";
 
-    const themeStyle = window.glob.getThemeStyle();
-    if (themeStyle !== "auto") {
+    const themeStyle = style.getPropertyValue("--theme-style");
+    if (style.getPropertyValue("--theme-style-auto") !== "true" && (themeStyle === "light" || themeStyle === "dark")) {
         themeSource = themeStyle;
     }
 
     const { nativeTheme } = utils.dynamicRequire("@electron/remote") as typeof ElectronRemote;
     nativeTheme.themeSource = themeSource;
 }
+
+function initPWATopbarColor() {
+    const tracker = $("#background-color-tracker");
+
+    if (tracker.length) {
+        const applyThemeColor = () => {
+            let meta = $("meta[name='theme-color']");
+            if (!meta.length) {
+                meta = $(`<meta name="theme-color">`).appendTo($("head"));
+            }
+            meta.attr("content", tracker.css("color"));
+        };
+
+        tracker.on("transitionend", applyThemeColor);
+        applyThemeColor();
+    }
+}

apps/client/src/entities/fnote.ts

@@ -1,6 +1,5 @@
 import { getNoteIcon } from "@triliumnext/commons";
 
-import bundleService from "../services/bundle.js";
 import cssClassManager from "../services/css_class_manager.js";
 import type { Froca } from "../services/froca-interface.js";
 import noteAttributeCache from "../services/note_attribute_cache.js";
@@ -19,7 +18,7 @@ const RELATION = "relation";
  * end user. Those types should be used only for checking against, they are
  * not for direct use.
  */
-export type NoteType = "file" | "image" | "search" | "noteMap" | "launcher" | "doc" | "contentWidget" | "text" | "relationMap" | "render" | "canvas" | "mermaid" | "book" | "webView" | "code" | "mindMap" | "spreadsheet" | "llmChat";
+export type NoteType = "file" | "image" | "search" | "noteMap" | "launcher" | "doc" | "contentWidget" | "text" | "relationMap" | "render" | "canvas" | "mermaid" | "book" | "webView" | "code" | "mindMap" | "aiChat";
 
 export interface NotePathRecord {
     isArchived: boolean;
@@ -236,16 +235,6 @@ export default class FNote {
         return this.hasAttribute("label", "archived");
     }
 
-    /**
-     * Returns true if the note's metadata (title, icon) should not be editable.
-     * This applies to system notes like options, help, and launch bar configuration.
-     */
-    get isMetadataReadOnly() {
-        return utils.isLaunchBarConfig(this.noteId)
-            || this.noteId.startsWith("_help_")
-            || this.noteId.startsWith("_options");
-    }
-
     getChildNoteIds() {
         return this.children;
     }
@@ -711,15 +700,6 @@ export default class FNote {
         return this.hasAttribute(LABEL, name);
     }
 
-    /**
-     * Returns `true` if the note has a label with the given name (same as {@link hasOwnedLabel}), or it has a label with the `disabled:` prefix (for example due to a safe import).
-     * @param name the name of the label to look for.
-     * @returns `true` if the label exists, or its version with the `disabled:` prefix.
-     */
-    hasLabelOrDisabled(name: string) {
-        return this.hasLabel(name) || this.hasLabel(`disabled:${name}`);
-    }
-
     /**
      * @param name - label name
      * @returns true if label exists (including inherited) and does not have "false" value.
@@ -1025,6 +1005,7 @@ export default class FNote {
         const env = this.getScriptEnv();
 
         if (env === "frontend") {
+            const bundleService = (await import("../services/bundle.js")).default;
             return await bundleService.getAndExecuteBundle(this.noteId);
         } else if (env === "backend") {
             await server.post(`script/run/${this.noteId}`);

apps/client/src/index.ts

@@ -1,5 +1,3 @@
-import { getThemeStyle } from "./services/theme";
-
 async function bootstrap() {
     showSplash();
     await setupGlob();
@@ -38,36 +36,8 @@ async function setupGlob() {
     window.global = globalThis; /* fixes https://github.com/webpack/webpack/issues/10035 */
     window.glob = {
         ...json,
-        activeDialog: null,
-        device: json.device || getDevice()
+        activeDialog: null
     };
-    window.glob.getThemeStyle = getThemeStyle;
-}
-
-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() {
@@ -79,65 +49,31 @@ async function loadBootstrapCss() {
     }
 }
 
-type StylesheetRef = {
-    href: string;
-    media?: string;
-};
-
-function getConfiguredThemeStylesheets(stylesheetsPath: string, theme: string, customThemeCssUrl?: string) {
-    if (theme === "auto") {
-        return [{ href: `${stylesheetsPath}/theme-dark.css`, media: "(prefers-color-scheme: dark)" }];
-    }
-
-    if (theme === "dark") {
-        return [{ href: `${stylesheetsPath}/theme-dark.css` }];
-    }
-
-    if (theme === "next") {
-        return [
-            { href: `${stylesheetsPath}/theme-next-light.css` },
-            { href: `${stylesheetsPath}/theme-next-dark.css`, media: "(prefers-color-scheme: dark)" }
-        ];
-    }
-
-    if (theme === "next-light") {
-        return [{ href: `${stylesheetsPath}/theme-next-light.css` }];
-    }
-
-    if (theme === "next-dark") {
-        return [{ href: `${stylesheetsPath}/theme-next-dark.css` }];
-    }
-
-    if (theme !== "light" && customThemeCssUrl) {
-        return [{ href: customThemeCssUrl }];
-    }
-
-    return [];
-}
-
 function loadStylesheets() {
-    const { device, assetPath, theme, themeBase, customThemeCssUrl } = window.glob;
-    const stylesheetsPath = `${assetPath}/stylesheets`;
+    const { device, assetPath, themeCssUrl, themeUseNextAsBase } = window.glob;
 
-    const cssToLoad: StylesheetRef[] = [];
+    const cssToLoad: string[] = [];
     if (device !== "print") {
-        cssToLoad.push({ href: `${stylesheetsPath}/ckeditor-theme.css` });
-        cssToLoad.push({ href: `api/fonts` });
-        cssToLoad.push({ href: `${stylesheetsPath}/theme-light.css` });
-        cssToLoad.push(...getConfiguredThemeStylesheets(stylesheetsPath, theme, customThemeCssUrl));
-        if (themeBase) {
-            cssToLoad.push(...getConfiguredThemeStylesheets(stylesheetsPath, themeBase));
+        cssToLoad.push(`${assetPath}/stylesheets/ckeditor-theme.css`);
+        cssToLoad.push(`api/fonts`);
+        cssToLoad.push(`${assetPath}/stylesheets/theme-light.css`);
+        if (themeCssUrl) {
+            cssToLoad.push(themeCssUrl);
         }
-        cssToLoad.push({ href: `${stylesheetsPath}/style.css` });
+        if (themeUseNextAsBase === "next") {
+            cssToLoad.push(`${assetPath}/stylesheets/theme-next.css`);
+        } else if (themeUseNextAsBase === "next-dark") {
+            cssToLoad.push(`${assetPath}/stylesheets/theme-next-dark.css`);
+        } else if (themeUseNextAsBase === "next-light") {
+            cssToLoad.push(`${assetPath}/stylesheets/theme-next-light.css`);
+        }
+        cssToLoad.push(`${assetPath}/stylesheets/style.css`);
     }
 
-    for (const { href, media } of cssToLoad) {
+    for (const href of cssToLoad) {
         const linkEl = document.createElement("link");
         linkEl.href = href;
         linkEl.rel = "stylesheet";
-        if (media) {
-            linkEl.media = media;
-        }
         document.head.appendChild(linkEl);
     }
 }
@@ -149,8 +85,6 @@ function loadIcons() {
 }
 
 function setBodyAttributes() {
-    if (!glob.dbInitialized) return;
-
     const { device, headingStyle, layoutOrientation, platform, isElectron, hasNativeTitleBar, hasBackgroundEffects, currentLocale } = window.glob;
     const classesToSet = [
         device,
@@ -171,11 +105,6 @@ function setBodyAttributes() {
 }
 
 async function loadScripts() {
-    if (!glob.dbInitialized) {
-        await import("./setup.js");
-        return;
-    }
-
     switch (glob.device) {
         case "mobile":
             await import("./mobile.js");

apps/client/src/layouts/desktop_layout.tsx

@@ -30,7 +30,6 @@ import SpacerWidget from "../widgets/launch_bar/SpacerWidget.jsx";
 import InlineTitle from "../widgets/layout/InlineTitle.jsx";
 import NoteBadges from "../widgets/layout/NoteBadges.jsx";
 import NoteTitleActions from "../widgets/layout/NoteTitleActions.jsx";
-import StandaloneWarningBar from "../widgets/layout/StandaloneWarningBar.jsx";
 import StatusBar from "../widgets/layout/StatusBar.jsx";
 import NoteIconWidget from "../widgets/note_icon.jsx";
 import NoteTitleWidget from "../widgets/note_title.jsx";
@@ -187,7 +186,6 @@ export default class DesktopLayout {
                     )
             )
             .optChild(launcherPaneIsHorizontal && isNewLayout, <StatusBar />)
-            .optChild(glob.isStandalone, <StandaloneWarningBar />)
             .child(<CloseZenModeButton />)
 
             // Desktop-specific dialogs.

apps/client/src/layouts/mobile_layout.css

@@ -1,76 +0,0 @@
-#background-color-tracker {
-    color: var(--main-background-color) !important;
-}
-
-span.keyboard-shortcut,
-kbd {
-    display: none;
-}
-
-.dropdown-menu {
-    font-size: larger;
-}
-
-.action-button {
-    background: none;
-    border: none;
-    cursor: pointer;
-    font-size: 1.25em;
-    padding-inline-start: 0.5em;
-    padding-inline-end: 0.5em;
-    color: var(--main-text-color);
-}
-.quick-search {
-    margin: 0;
-}
-.quick-search .dropdown-menu {
-    max-width: 350px;
-}
-
-/* #region Tree */
-.tree-wrapper {
-    max-height: 100%;
-    margin-top: 0px;
-    overflow-y: auto;
-    contain: content;
-    padding-inline-start: 10px;
-}
-
-.fancytree-title {
-    margin-inline-start: 0.6em !important;
-}
-
-.fancytree-node {
-    padding: 5px;
-}
-
-span.fancytree-expander {
-    width: 24px !important;
-    margin-inline-end: 5px;
-}
-
-.fancytree-loading span.fancytree-expander {
-    width: 24px;
-    height: 32px;
-}
-
-.fancytree-loading  span.fancytree-expander:after {
-    width: 20px;
-    height: 20px;
-    margin-top: 4px;
-    border-width: 2px;
-    border-style: solid;
-}
-
-.tree-wrapper .collapse-tree-button,
-.tree-wrapper .scroll-to-active-note-button,
-.tree-wrapper .tree-settings-button {
-    position: fixed;
-    margin-inline-end: 16px;
-    display: none;
-}
-
-.tree-wrapper .unhoist-button {
-    font-size: 200%;
-}
-/* #endregion */

apps/client/src/layouts/mobile_layout.tsx

@@ -1,39 +1,128 @@
-import "./mobile_layout.css";
-
 import type AppContext from "../components/app_context.js";
 import GlobalMenuWidget from "../widgets/buttons/global_menu.js";
 import CloseZenModeButton from "../widgets/close_zen_button.js";
 import NoteList from "../widgets/collections/NoteList.jsx";
+import ContentHeader from "../widgets/containers/content_header.js";
 import FlexContainer from "../widgets/containers/flex_container.js";
 import RootContainer from "../widgets/containers/root_container.js";
 import ScrollingContainer from "../widgets/containers/scrolling_container.js";
 import SplitNoteContainer from "../widgets/containers/split_note_container.js";
-import FindWidget from "../widgets/find.js";
+import FloatingButtons from "../widgets/FloatingButtons.jsx";
+import { MOBILE_FLOATING_BUTTONS } from "../widgets/FloatingButtonsDefinitions.jsx";
 import LauncherContainer from "../widgets/launch_bar/LauncherContainer.jsx";
-import InlineTitle from "../widgets/layout/InlineTitle.jsx";
-import NoteBadges from "../widgets/layout/NoteBadges.jsx";
-import NoteTitleActions from "../widgets/layout/NoteTitleActions.jsx";
-import StandaloneWarningBar from "../widgets/layout/StandaloneWarningBar";
 import MobileDetailMenu from "../widgets/mobile_widgets/mobile_detail_menu.js";
 import ScreenContainer from "../widgets/mobile_widgets/screen_container.js";
 import SidebarContainer from "../widgets/mobile_widgets/sidebar_container.js";
 import ToggleSidebarButton from "../widgets/mobile_widgets/toggle_sidebar_button.jsx";
-import NoteIconWidget from "../widgets/note_icon.jsx";
 import NoteTitleWidget from "../widgets/note_title.js";
 import NoteTreeWidget from "../widgets/note_tree.js";
 import NoteWrapperWidget from "../widgets/note_wrapper.js";
 import NoteDetail from "../widgets/NoteDetail.jsx";
+import PromotedAttributes from "../widgets/PromotedAttributes.jsx";
 import QuickSearchWidget from "../widgets/quick_search.js";
-import ScrollPadding from "../widgets/scroll_padding";
+import { useNoteContext } from "../widgets/react/hooks.jsx";
+import ReadOnlyNoteInfoBar from "../widgets/ReadOnlyNoteInfoBar.jsx";
+import StandaloneRibbonAdapter from "../widgets/ribbon/components/StandaloneRibbonAdapter.jsx";
+import FilePropertiesTab from "../widgets/ribbon/FilePropertiesTab.jsx";
+import SearchDefinitionTab from "../widgets/ribbon/SearchDefinitionTab.jsx";
 import SearchResult from "../widgets/search_result.jsx";
+import SharedInfoWidget from "../widgets/shared_info.js";
+import TabRowWidget from "../widgets/tab_row.js";
 import MobileEditorToolbar from "../widgets/type_widgets/text/mobile_editor_toolbar.jsx";
 import { applyModals } from "./layout_commons.js";
 
+const MOBILE_CSS = `
+<style>
+span.keyboard-shortcut,
+kbd {
+    display: none;
+}
+
+.dropdown-menu {
+    font-size: larger;
+}
+
+.action-button {
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-size: 1.25em;
+    padding-inline-start: 0.5em;
+    padding-inline-end: 0.5em;
+    color: var(--main-text-color);
+}
+.quick-search {
+    margin: 0;
+}
+.quick-search .dropdown-menu {
+    max-width: 350px;
+}
+</style>`;
+
+const FANCYTREE_CSS = `
+<style>
+.tree-wrapper {
+    max-height: 100%;
+    margin-top: 0px;
+    overflow-y: auto;
+    contain: content;
+    padding-inline-start: 10px;
+}
+
+.fancytree-custom-icon {
+    font-size: 2em;
+}
+
+.fancytree-title {
+    font-size: 1.5em;
+    margin-inline-start: 0.6em !important;
+}
+
+.fancytree-node {
+    padding: 5px;
+}
+
+.fancytree-node .fancytree-expander:before {
+    font-size: 2em !important;
+}
+
+span.fancytree-expander {
+    width: 24px !important;
+    margin-inline-end: 5px;
+}
+
+.fancytree-loading span.fancytree-expander {
+    width: 24px;
+    height: 32px;
+}
+
+.fancytree-loading  span.fancytree-expander:after {
+    width: 20px;
+    height: 20px;
+    margin-top: 4px;
+    border-width: 2px;
+    border-style: solid;
+}
+
+.tree-wrapper .collapse-tree-button,
+.tree-wrapper .scroll-to-active-note-button,
+.tree-wrapper .tree-settings-button {
+    position: fixed;
+    margin-inline-end: 16px;
+    display: none;
+}
+
+.tree-wrapper .unhoist-button {
+    font-size: 200%;
+}
+</style>`;
+
 export default class MobileLayout {
     getRootWidget(appContext: typeof AppContext) {
         const rootContainer = new RootContainer(true)
             .setParent(appContext)
             .class("horizontal-layout")
+            .cssBlock(MOBILE_CSS)
             .child(new FlexContainer("column").id("mobile-sidebar-container"))
             .child(
                 new FlexContainer("row")
@@ -47,7 +136,7 @@ export default class MobileLayout {
                             .css("padding-inline-start", "0")
                             .css("padding-inline-end", "0")
                             .css("contain", "content")
-                            .child(new FlexContainer("column").filling().id("mobile-sidebar-wrapper").child(new QuickSearchWidget()).child(new NoteTreeWidget()))
+                            .child(new FlexContainer("column").filling().id("mobile-sidebar-wrapper").child(new QuickSearchWidget()).child(new NoteTreeWidget().cssBlock(FANCYTREE_CSS)))
                     )
                     .child(
                         new ScreenContainer("detail", "row")
@@ -56,31 +145,32 @@ export default class MobileLayout {
                             .child(
                                 new SplitNoteContainer(() =>
                                     new NoteWrapperWidget()
-                                        .optChild(glob.isStandalone, <StandaloneWarningBar />)
                                         .child(
                                             new FlexContainer("row")
-                                                .class("title-row note-split-title")
                                                 .contentSized()
+                                                .css("font-size", "larger")
                                                 .css("align-items", "center")
                                                 .child(<ToggleSidebarButton />)
-                                                .child(<NoteIconWidget />)
                                                 .child(<NoteTitleWidget />)
-                                                .child(<NoteBadges />)
                                                 .child(<MobileDetailMenu />)
                                         )
+                                        .child(<FloatingButtons items={MOBILE_FLOATING_BUTTONS} />)
+                                        .child(<PromotedAttributes />)
                                         .child(
                                             new ScrollingContainer()
                                                 .filling()
                                                 .contentSized()
-                                                .child(<InlineTitle />)
-                                                .child(<NoteTitleActions />)
+                                                .child(new ContentHeader()
+                                                    .child(<ReadOnlyNoteInfoBar />)
+                                                    .child(<SharedInfoWidget />)
+                                                )
                                                 .child(<NoteDetail />)
                                                 .child(<NoteList media="screen" />)
+                                                .child(<StandaloneRibbonAdapter component={SearchDefinitionTab} />)
                                                 .child(<SearchResult />)
-                                                .child(<ScrollPadding />)
+                                                .child(<FilePropertiesWrapper />)
                                         )
                                         .child(<MobileEditorToolbar />)
-                                        .child(new FindWidget())
                                 )
                             )
                     )
@@ -101,3 +191,13 @@ export default class MobileLayout {
         return rootContainer;
     }
 }
+
+function FilePropertiesWrapper() {
+    const { note, ntxId } = useNoteContext();
+
+    return (
+        <div>
+            {note?.type === "file" && <FilePropertiesTab note={note} ntxId={ntxId} />}
+        </div>
+    );
+}

apps/client/src/menus/context_menu.ts

@@ -248,7 +248,7 @@ class ContextMenu {
         if ("uiIcon" in item || "checked" in item) {
             const icon = (item.checked ? "bx bx-check" : item.uiIcon);
             if (icon) {
-                $icon.addClass([icon, "tn-icon"]);
+                $icon.addClass(icon);
             } else {
                 $icon.append(" ");
             }

apps/client/src/menus/electron_context_menu.ts

@@ -1,14 +1,10 @@
-import type { BrowserWindow } from "electron";
-
-import type { CommandNames } from "../components/app_context.js";
-import appContext from "../components/app_context.js";
-import zoomService from "../components/zoom.js";
-import * as clipboardExt from "../services/clipboard_ext.js";
-import { t } from "../services/i18n.js";
-import options from "../services/options.js";
-import server from "../services/server.js";
 import utils from "../services/utils.js";
+import options from "../services/options.js";
+import zoomService from "../components/zoom.js";
 import contextMenu, { type MenuItem } from "./context_menu.js";
+import { t } from "../services/i18n.js";
+import type { BrowserWindow } from "electron";
+import type { CommandNames, AppContext } from "../components/app_context.js";
 
 function setupContextMenu() {
     const electron = utils.dynamicRequire("electron");
@@ -17,6 +13,8 @@ function setupContextMenu() {
     // FIXME: Remove typecast once Electron is properly integrated.
     const { webContents } = remote.getCurrentWindow() as BrowserWindow;
 
+    let appContext: AppContext;
+
     webContents.on("context-menu", (event, params) => {
         const { editFlags } = params;
         const hasText = params.selectionText.trim().length > 0;
@@ -38,7 +36,7 @@ function setupContextMenu() {
             items.push({
                 title: t("electron_context_menu.add-term-to-dictionary", { term: params.misspelledWord }),
                 uiIcon: "bx bx-plus",
-                handler: () => electron.ipcRenderer.send("add-word-to-dictionary", params.misspelledWord)
+                handler: () => webContents.session.addWordToSpellCheckerDictionary(params.misspelledWord)
             });
 
             items.push({ kind: "separator" });
@@ -62,33 +60,6 @@ function setupContextMenu() {
                 uiIcon: "bx bx-copy",
                 handler: () => webContents.copy()
             });
-
-            items.push({
-                enabled: hasText,
-                title: t("electron_context_menu.copy-as-markdown"),
-                uiIcon: "bx bx-copy-alt",
-                handler: async () => {
-                    const selection = window.getSelection();
-                    if (!selection || !selection.rangeCount) return '';
-
-                    const range = selection.getRangeAt(0);
-                    const div = document.createElement('div');
-                    div.appendChild(range.cloneContents());
-
-                    const htmlContent = div.innerHTML;
-                    if (htmlContent) {
-                        try {
-                            const { markdownContent } = await server.post<{ markdownContent: string }>(
-                                "other/to-markdown",
-                                { htmlContent }
-                            );
-                            await clipboardExt.copyTextWithToast(markdownContent);
-                        } catch (error) {
-                            console.error("Failed to copy as markdown:", error);
-                        }
-                    }
-                }
-            });
         }
 
         if (!["", "javascript:", "about:blank#blocked"].includes(params.linkURL) && params.mediaType === "none") {
@@ -141,7 +112,7 @@ function setupContextMenu() {
             }
 
             // Replace the placeholder with the real search keyword.
-            const searchUrl = searchEngineUrl.replace("{keyword}", encodeURIComponent(params.selectionText));
+            let searchUrl = searchEngineUrl.replace("{keyword}", encodeURIComponent(params.selectionText));
 
             items.push({ kind: "separator" });
 
@@ -155,6 +126,10 @@ function setupContextMenu() {
                 title: t("electron_context_menu.search_in_trilium", { term: shortenedSelection }),
                 uiIcon: "bx bx-search",
                 handler: async () => {
+                    if (!appContext) {
+                        appContext = (await import("../components/app_context.js")).default;
+                    }
+
                     await appContext.triggerCommand("searchNotes", {
                         searchString: params.selectionText
                     });

apps/client/src/menus/launcher_context_menu.ts

@@ -1,12 +1,12 @@
-import type { ContextMenuCommandData,FilteredCommandNames } from "../components/app_context.js";
-import type { SelectMenuItemEventListener } from "../components/events.js";
-import dialogService from "../services/dialog.js";
-import froca from "../services/froca.js";
-import { t } from "../services/i18n.js";
-import server from "../services/server.js";
 import treeService from "../services/tree.js";
-import type NoteTreeWidget from "../widgets/note_tree.js";
+import froca from "../services/froca.js";
 import contextMenu, { type MenuCommandItem, type MenuItem } from "./context_menu.js";
+import dialogService from "../services/dialog.js";
+import server from "../services/server.js";
+import { t } from "../services/i18n.js";
+import type { SelectMenuItemEventListener } from "../components/events.js";
+import type NoteTreeWidget from "../widgets/note_tree.js";
+import type { FilteredCommandNames, ContextMenuCommandData } from "../components/app_context.js";
 
 type LauncherCommandNames = FilteredCommandNames<ContextMenuCommandData>;
 
@@ -32,8 +32,8 @@ export default class LauncherContextMenu implements SelectMenuItemEventListener<
         const note = this.node.data.noteId ? await froca.getNote(this.node.data.noteId) : null;
         const parentNoteId = this.node.getParent().data.noteId;
 
-        const isVisibleRoot = note?.noteId === "_lbVisibleLaunchers" || note?.noteId === "_lbMobileVisibleLaunchers";
-        const isAvailableRoot = note?.noteId === "_lbAvailableLaunchers" || note?.noteId === "_lbMobileAvailableLaunchers";
+        const isVisibleRoot = note?.noteId === "_lbVisibleLaunchers";
+        const isAvailableRoot = note?.noteId === "_lbAvailableLaunchers";
         const isVisibleItem = parentNoteId === "_lbVisibleLaunchers" || parentNoteId === "_lbMobileVisibleLaunchers";
         const isAvailableItem = parentNoteId === "_lbAvailableLaunchers" || parentNoteId === "_lbMobileAvailableLaunchers";
         const isItem = isVisibleItem || isAvailableItem;

apps/client/src/print.tsx

@@ -4,7 +4,6 @@ import { useCallback, useLayoutEffect, useRef } from "preact/hooks";
 import FNote from "./entities/fnote";
 import content_renderer from "./services/content_renderer";
 import { applyInlineMermaid } from "./services/content_renderer_text";
-import froca from "./services/froca";
 import { dynamicRequire, isElectron } from "./services/utils";
 import { CustomNoteList, useNoteViewType } from "./widgets/collections/NoteList";
 
@@ -19,10 +18,6 @@ export type PrintReport = {
 } | {
     type: "collection";
     ignoredNoteIds: string[];
-} | {
-    type: "error";
-    message: string;
-    stack?: string;
 };
 
 async function main() {
@@ -31,6 +26,7 @@ async function main() {
     if (!noteId) return;
 
     await import("./print.css");
+    const froca = (await import("./services/froca")).default;
     const note = await froca.getNote(noteId);
 
     const bodyWrapper = document.createElement("div");

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

@@ -6,8 +6,10 @@ import froca from "./froca";
 import server from "./server.js";
 
 // Spy on server methods to track calls
-server.put = vi.fn(async () => ({})) as typeof server.put;
-server.remove = vi.fn(async () => ({})) as typeof server.remove;
+// @ts-expect-error the generic typing is causing issues here
+server.put = vi.fn(async <T> (url: string, data?: T) => ({} as T));
+// @ts-expect-error the generic typing is causing issues here
+server.remove = vi.fn(async <T> (url: string) => ({} as T));
 
 describe("Set boolean with inheritance", () => {
     beforeEach(() => {

apps/client/src/services/attributes.ts

@@ -168,49 +168,6 @@ function isAffecting(attrRow: AttributeRow, affectedNote: FNote | null | undefin
     return false;
 }
 
-/**
- * Toggles whether a dangerous attribute is enabled or not. When an attribute is disabled, its name is prefixed with `disabled:`.
- *
- * Note that this work for non-dangerous attributes as well.
- *
- * If there are multiple attributes with the same name, all of them will be toggled at the same time.
- *
- * @param note the note whose attribute to change.
- * @param type the type of dangerous attribute (label or relation).
- * @param name the name of the dangerous attribute.
- * @param willEnable whether to enable or disable the attribute.
- * @returns a promise that will resolve when the request to the server completes.
- */
-async function toggleDangerousAttribute(note: FNote, type: "label" | "relation", name: string, willEnable: boolean) {
-    const attrs = [
-        ...note.getOwnedAttributes(type, name),
-        ...note.getOwnedAttributes(type, `disabled:${name}`)
-    ];
-
-    for (const attr of attrs) {
-        const baseName = getNameWithoutDangerousPrefix(attr.name);
-        const newName = willEnable ? baseName : `disabled:${baseName}`;
-        if (newName === attr.name) continue;
-
-        // We are adding and removing afterwards to avoid a flicker (because for a moment there would be no active content attribute anymore) because the operations are done in sequence and not atomically.
-        if (attr.type === "label") {
-            await setLabel(note.noteId, newName, attr.value);
-        } else {
-            await setRelation(note.noteId, newName, attr.value);
-        }
-        await removeAttributeById(note.noteId, attr.attributeId);
-    }
-}
-
-/**
- * Returns the name of an attribute without the `disabled:` prefix, or the same name if it's not disabled.
- * @param name the name of an attribute.
- * @returns the name without the `disabled:` prefix.
- */
-function getNameWithoutDangerousPrefix(name: string) {
-    return name.startsWith("disabled:") ? name.substring(9) : name;
-}
-
 export default {
     addLabel,
     setLabel,
@@ -220,7 +177,5 @@ export default {
     removeAttributeById,
     removeOwnedLabelByName,
     removeOwnedRelationByName,
-    isAffecting,
-    toggleDangerousAttribute,
-    getNameWithoutDangerousPrefix
+    isAffecting
 };

apps/client/src/services/branches.ts

@@ -120,7 +120,7 @@ async function deleteNotes(branchIdsToDelete: string[], forceDeleteAllClones = f
 
     if (moveToParent) {
         try {
-            await activateParentNotePath(branchIdsToDelete);
+            await activateParentNotePath();
         } catch (e) {
             console.error(e);
         }
@@ -152,28 +152,13 @@ async function deleteNotes(branchIdsToDelete: string[], forceDeleteAllClones = f
     return true;
 }
 
-async function activateParentNotePath(branchIdsToDelete: string[]) {
+async function activateParentNotePath() {
+    // this is not perfect, maybe we should find the next/previous sibling, but that's more complex
     const activeContext = appContext.tabManager.getActiveContext();
-    const activeNotePath = activeContext?.notePathArray ?? [];
+    const parentNotePathArr = activeContext?.notePathArray.slice(0, -1);
 
-    // Find the deleted branch that appears earliest in the active note's path
-    let earliestIndex = activeNotePath.length;
-    for (const branchId of branchIdsToDelete) {
-        const branch = froca.getBranch(branchId);
-        if (branch) {
-            const index = activeNotePath.indexOf(branch.noteId);
-            if (index !== -1 && index < earliestIndex) {
-                earliestIndex = index;
-            }
-        }
-    }
-
-    // Navigate to the parent of the highest deleted ancestor
-    if (earliestIndex < activeNotePath.length) {
-        const parentPath = activeNotePath.slice(0, earliestIndex);
-        if (parentPath.length > 0) {
-            await activeContext?.setNote(parentPath.join("/"));
-        }
+    if (parentNotePathArr && parentNotePathArr.length > 0) {
+        activeContext?.setNote(parentNotePathArr.join("/"));
     }
 }
 

apps/client/src/services/bundle.ts

@@ -1,9 +1,8 @@
-import { ScriptParams } from "@triliumnext/commons";
 import { h, VNode } from "preact";
 
-import FNote from "../entities/fnote.js";
 import BasicWidget, { ReactWrappedWidget } from "../widgets/basic_widget.js";
 import RightPanelWidget from "../widgets/right_panel_widget.js";
+import froca from "./froca.js";
 import type { Entity } from "./frontend_script_api.js";
 import { WidgetDefinitionWithType } from "./frontend_script_api_preact.js";
 import { t } from "./i18n.js";
@@ -28,7 +27,7 @@ type WithNoteId<T> = T & {
 };
 export type Widget = WithNoteId<(LegacyWidget | WidgetDefinitionWithType)>;
 
-async function getAndExecuteBundle(noteId: string, originEntity: FNote | null = null, script: string | null = null, params: ScriptParams | null = null) {
+async function getAndExecuteBundle(noteId: string, originEntity = null, script = null, params = null) {
     const bundle = await server.post<Bundle>(`script/bundle/${noteId}`, {
         script,
         params
@@ -39,18 +38,15 @@ async function getAndExecuteBundle(noteId: string, originEntity: FNote | null =
 
 export type ParentName = "left-pane" | "center-pane" | "note-detail-pane" | "right-pane";
 
-export async function executeBundleWithoutErrorHandling(bundle: Bundle, originEntity?: Entity | null, $container?: JQuery<HTMLElement>) {
-    const apiContext = await ScriptContext(bundle.noteId, bundle.allNoteIds, originEntity, $container);
-    return await function () {
-        return eval(`const apiContext = this; (async function() { ${bundle.script}\r\n})()`);
-    }.call(apiContext);
-}
-
 export async function executeBundle(bundle: Bundle, originEntity?: Entity | null, $container?: JQuery<HTMLElement>) {
+    const apiContext = await ScriptContext(bundle.noteId, bundle.allNoteIds, originEntity, $container);
+
     try {
-        return await executeBundleWithoutErrorHandling(bundle, originEntity, $container);
-    } catch (e: unknown) {
-        showErrorForScriptNote(bundle.noteId, t("toast.bundle-error.message", { message: getErrorMessage(e) }));
+        return await function () {
+            return eval(`const apiContext = this; (async function() { ${bundle.script}\r\n})()`);
+        }.call(apiContext);
+    } catch (e: any) {
+        showErrorForScriptNote(bundle.noteId, t("toast.bundle-error.message", { message: e.message }));
         logError("Widget initialization failed: ", e);
     }
 }

apps/client/src/services/clipboard_ext.ts

@@ -1,6 +1,3 @@
-import { t } from "./i18n.js";
-import toast from "./toast.js";
-
 export function copyText(text: string) {
     if (!text) {
         return;
@@ -9,26 +6,29 @@ export function copyText(text: string) {
         if (navigator.clipboard) {
             navigator.clipboard.writeText(text);
             return true;
-        } 
-        // Fallback method: https://stackoverflow.com/a/72239825
-        const textArea = document.createElement("textarea");
-        textArea.value = text;
-        try {
-            document.body.appendChild(textArea);
-            textArea.focus();
-            textArea.select();
-            return document.execCommand('copy');
-        } finally {
-            document.body.removeChild(textArea);
+        } else {
+            // Fallback method: https://stackoverflow.com/a/72239825
+            const textArea = document.createElement("textarea");
+            textArea.value = text;
+            try {
+                document.body.appendChild(textArea);
+                textArea.focus();
+                textArea.select();
+                return document.execCommand('copy');
+            } finally {
+                document.body.removeChild(textArea);
+            }
         }
-        
     } catch (e) {
         console.warn(e);
         return false;
     }
 }
 
-export function copyTextWithToast(text: string) {
+export async function copyTextWithToast(text: string) {
+    const t = (await import("./i18n.js")).t;
+    const toast = (await import("./toast.js")).default;
+
     if (copyText(text)) {
         toast.showMessage(t("clipboard.copy_success"));
     } else {

apps/client/src/services/content_renderer.css

@@ -1,9 +0,0 @@
-.rendered-content.no-preview > div {
-    display: flex;
-    flex-direction: column;
-    justify-content: space-around;
-    align-items: center;
-    height: 100%;
-    font-size: 500%;
-    flex-grow: 1;
-}

apps/client/src/services/content_renderer.ts

@@ -1,7 +1,4 @@
-import "./content_renderer.css";
-
-import { normalizeMimeTypeForCKEditor, type TextRepresentationResponse } from "@triliumnext/commons";
-import { h, render } from "preact";
+import { normalizeMimeTypeForCKEditor } from "@triliumnext/commons";
 import WheelZoom from 'vanilla-js-wheel-zoom';
 
 import FAttachment from "../entities/fattachment.js";
@@ -15,9 +12,8 @@ import openService from "./open.js";
 import protectedSessionService from "./protected_session.js";
 import protectedSessionHolder from "./protected_session_holder.js";
 import renderService from "./render.js";
-import server from "./server.js";
 import { applySingleBlockSyntaxHighlight } from "./syntax_highlight.js";
-import utils, { getErrorMessage } from "./utils.js";
+import utils from "./utils.js";
 
 let idCounter = 1;
 
@@ -33,7 +29,6 @@ export interface RenderOptions {
     includeArchivedNotes?: boolean;
     /** Set of note IDs that have already been seen during rendering to prevent infinite recursion. */
     seenNoteIds?: Set<string>;
-    showTextRepresentation?: boolean;
 }
 
 const CODE_MIME_TYPES = new Set(["application/json"]);
@@ -56,19 +51,16 @@ export async function getRenderedContent(this: {} | { ctx: string }, entity: FNo
         await renderText(entity, $renderedContent, options);
     } else if (type === "code") {
         await renderCode(entity, $renderedContent);
-    } else if (["image", "canvas", "mindMap", "spreadsheet"].includes(type)) {
-        await renderImage(entity, $renderedContent, options);
+    } else if (["image", "canvas", "mindMap"].includes(type)) {
+        renderImage(entity, $renderedContent, options);
     } else if (!options.tooltip && ["file", "pdf", "audio", "video"].includes(type)) {
-        await renderFile(entity, type, $renderedContent, options);
+        renderFile(entity, type, $renderedContent);
     } else if (type === "mermaid") {
         await renderMermaid(entity, $renderedContent);
     } else if (type === "render" && entity instanceof FNote) {
         const $content = $("<div>");
 
-        await renderService.render(entity, $content, (e) => {
-            const $error = $("<div>").addClass("admonition caution").text(typeof e === "string" ? e : getErrorMessage(e));
-            $content.empty().append($error);
-        });
+        await renderService.render(entity, $content);
 
         $renderedContent.append($content);
     } else if (type === "doc" && "noteId" in entity) {
@@ -79,9 +71,18 @@ export async function getRenderedContent(this: {} | { ctx: string }, entity: FNo
 
         $renderedContent.append($("<div>").append("<div>This note is protected and to access it you need to enter password.</div>").append("<br/>").append($button));
     } else if (entity instanceof FNote) {
-        $renderedContent.addClass("no-preview");
+        $renderedContent
+            .css("display", "flex")
+            .css("flex-direction", "column");
         $renderedContent.append(
-            $("<div>").append($("<span>").addClass(entity.getIcon()))
+            $("<div>")
+                .css("display", "flex")
+                .css("justify-content", "space-around")
+                .css("align-items", "center")
+                .css("height", "100%")
+                .css("font-size", "500%")
+                .css("flex-grow", "1")
+                .append($("<span>").addClass(entity.getIcon()))
         );
 
         if (entity.type === "webView" && entity.hasLabel("webViewSrc")) {
@@ -140,7 +141,7 @@ async function renderCode(note: FNote | FAttachment, $renderedContent: JQuery<HT
     await applySingleBlockSyntaxHighlight($codeBlock, normalizeMimeTypeForCKEditor(note.mime));
 }
 
-async function renderImage(entity: FNote | FAttachment, $renderedContent: JQuery<HTMLElement>, options: RenderOptions = {}) {
+function renderImage(entity: FNote | FAttachment, $renderedContent: JQuery<HTMLElement>, options: RenderOptions = {}) {
     const encodedTitle = encodeURIComponent(entity.title);
 
     let url;
@@ -148,14 +149,13 @@ async function renderImage(entity: FNote | FAttachment, $renderedContent: JQuery
     if (entity instanceof FNote) {
         url = `api/images/${entity.noteId}/${encodedTitle}?${Math.random()}`;
     } else if (entity instanceof FAttachment) {
-        url = `api/attachments/${entity.attachmentId}/image/${encodedTitle}?${entity.utcDateModified}`;
+        url = `api/attachments/${entity.attachmentId}/image/${encodedTitle}?${entity.utcDateModified}">`;
     }
 
     $renderedContent // styles needed for the zoom to work well
         .css("display", "flex")
         .css("align-items", "center")
-        .css("justify-content", "center")
-        .css("flex-direction", "column");   // OCR text is displayed below the image.
+        .css("justify-content", "center");
 
     const $img = $("<img>")
         .attr("src", url || "")
@@ -181,35 +181,9 @@ async function renderImage(entity: FNote | FAttachment, $renderedContent: JQuery
     }
 
     imageContextMenuService.setupContextMenu($img);
-
-    if (entity instanceof FNote && options.showTextRepresentation) {
-        await addOCRTextIfAvailable(entity, $renderedContent);
-    }
 }
 
-async function addOCRTextIfAvailable(note: FNote, $content: JQuery<HTMLElement>) {
-    try {
-        const data = await server.get<TextRepresentationResponse>(`ocr/notes/${note.noteId}/text`);
-        if (data.success && data.hasOcr && data.text) {
-            const $ocrSection = $(`
-                <div class="ocr-text-section">
-                    <div class="ocr-header">
-                        <span class="bx bx-text"></span> ${t("ocr.extracted_text")}
-                    </div>
-                    <div class="ocr-content"></div>
-                </div>
-            `);
-
-            $ocrSection.find('.ocr-content').text(data.text);
-            $content.append($ocrSection);
-        }
-    } catch (error) {
-        // Silently fail if OCR API is not available
-        console.debug('Failed to fetch OCR text:', error);
-    }
-}
-
-async function renderFile(entity: FNote | FAttachment, type: string, $renderedContent: JQuery<HTMLElement>, options: RenderOptions = {}) {
+function renderFile(entity: FNote | FAttachment, type: string, $renderedContent: JQuery<HTMLElement>) {
     let entityType, entityId;
 
     if (entity instanceof FNote) {
@@ -222,17 +196,13 @@ async function renderFile(entity: FNote | FAttachment, type: string, $renderedCo
         throw new Error(`Can't recognize entity type of '${entity}'`);
     }
 
-    const $content = $('<div style="display: flex; flex-direction: column; height: 100%; justify-content: end;">');
+    const $content = $('<div style="display: flex; flex-direction: column; height: 100%;">');
 
     if (type === "pdf") {
-        const url = `../../api/${entityType}/${entityId}/open`;
-        const $viewer = $(`<div style="height: 100%">`);
-        const PdfViewer = (await import("../widgets/type_widgets/file/PdfViewer")).default;
-        render(h(PdfViewer, {pdfUrl: url, editable: false}), $viewer.get(0)!);
-
-        $content.append($viewer);
-
+        const $pdfPreview = $('<iframe class="pdf-preview" style="width: 100%; flex-grow: 100;"></iframe>');
+        $pdfPreview.attr("src", openService.getUrlForDownload(`pdfjs/web/viewer.html?file=../../api/${entityType}/${entityId}/open`));
 
+        $content.append($pdfPreview);
     } else if (type === "audio") {
         const $audioPreview = $("<audio controls></audio>")
             .attr("src", openService.getUrlForDownload(`api/${entityType}/${entityId}/open-partial`))
@@ -249,10 +219,6 @@ async function renderFile(entity: FNote | FAttachment, type: string, $renderedCo
         $content.append($videoPreview);
     }
 
-    if (entity instanceof FNote && options.showTextRepresentation) {
-        await addOCRTextIfAvailable(entity, $content);
-    }
-
     if (entityType === "notes" && "noteId" in entity) {
         // TODO: we should make this available also for attachments, but there's a problem with "Open externally" support
         //       in attachment list
@@ -326,11 +292,10 @@ function getRenderingType(entity: FNote | FAttachment) {
     }
 
     const mime = "mime" in entity && entity.mime;
-    const isIconPack = entity instanceof FNote && entity.hasLabel("iconPack");
 
     if (type === "file" && mime === "application/pdf") {
         type = "pdf";
-    } else if ((type === "file" || type === "viewConfig") && mime && CODE_MIME_TYPES.has(mime) && !isIconPack) {
+    } else if ((type === "file" || type === "viewConfig") && mime && CODE_MIME_TYPES.has(mime)) {
         type = "code";
     } else if (type === "file" && mime && mime.startsWith("audio/")) {
         type = "audio";

apps/client/src/services/content_renderer_text.ts

@@ -120,6 +120,7 @@ async function renderChildrenList($renderedContent: JQuery<HTMLElement>, note: F
         return;
     }
 
+    $renderedContent.css("padding", "10px");
     $renderedContent.addClass("text-with-ellipsis");
 
     // just load the first 10 child notes

apps/client/src/services/date_notes.ts

@@ -1,5 +1,4 @@
 import { dayjs } from "@triliumnext/commons";
-
 import type { FNoteRow } from "../entities/fnote.js";
 import froca from "./froca.js";
 import server from "./server.js";
@@ -15,13 +14,8 @@ async function getTodayNote() {
     return await getDayNote(dayjs().format("YYYY-MM-DD"));
 }
 
-async function getDayNote(date: string, calendarRootId?: string) {
-    let url = `special-notes/days/${date}`;
-    if (calendarRootId) {
-        url += `?calendarRootId=${calendarRootId}`;
-    }
-
-    const note = await server.get<FNoteRow>(url, "date-note");
+async function getDayNote(date: string) {
+    const note = await server.get<FNoteRow>(`special-notes/days/${date}`, "date-note");
 
     await ws.waitForMaxKnownEntityChangeId();
 
@@ -84,55 +78,6 @@ async function createSearchNote(opts = {}) {
     return await froca.getNote(note.noteId);
 }
 
-async function createLlmChat() {
-    const note = await server.post<FNoteRow>("special-notes/llm-chat");
-
-    await ws.waitForMaxKnownEntityChangeId();
-
-    return await froca.getNote(note.noteId);
-}
-
-/**
- * Gets the most recently modified LLM chat.
- * Returns null if no chat exists.
- */
-async function getMostRecentLlmChat() {
-    const note = await server.get<FNoteRow | null>("special-notes/most-recent-llm-chat");
-
-    if (!note) {
-        return null;
-    }
-
-    await ws.waitForMaxKnownEntityChangeId();
-
-    return await froca.getNote(note.noteId);
-}
-
-/**
- * Gets the most recent LLM chat, or creates a new one if none exists.
- * Used by sidebar chat for persistent conversations across page refreshes.
- */
-async function getOrCreateLlmChat() {
-    const note = await server.get<FNoteRow>("special-notes/get-or-create-llm-chat");
-
-    await ws.waitForMaxKnownEntityChangeId();
-
-    return await froca.getNote(note.noteId);
-}
-
-export interface RecentLlmChat {
-    noteId: string;
-    title: string;
-    dateModified: string;
-}
-
-/**
- * Gets a list of recent LLM chats for the history popup.
- */
-async function getRecentLlmChats(limit: number = 10): Promise<RecentLlmChat[]> {
-    return await server.get<RecentLlmChat[]>(`special-notes/recent-llm-chats?limit=${limit}`);
-}
-
 export default {
     getInboxNote,
     getTodayNote,
@@ -143,9 +88,5 @@ export default {
     getMonthNote,
     getYearNote,
     createSqlConsole,
-    createSearchNote,
-    createLlmChat,
-    getMostRecentLlmChat,
-    getOrCreateLlmChat,
-    getRecentLlmChats
+    createSearchNote
 };

apps/client/src/services/dialog.ts

@@ -1,11 +1,9 @@
 import { Modal } from "bootstrap";
-
 import appContext from "../components/app_context.js";
 import type { ConfirmDialogOptions, ConfirmDialogResult, ConfirmWithMessageOptions, MessageType } from "../widgets/dialogs/confirm.js";
-import { InfoExtraProps } from "../widgets/dialogs/info.jsx";
 import type { PromptDialogOptions } from "../widgets/dialogs/prompt.js";
 import { focusSavedElement, saveFocusedElement } from "./focus.js";
-import keyboardActionsService from "./keyboard_actions.js";
+import { InfoExtraProps } from "../widgets/dialogs/info.jsx";
 
 export async function openDialog($dialog: JQuery<HTMLElement>, closeActDialog = true, config?: Partial<Modal.Options>) {
     if (closeActDialog) {
@@ -27,6 +25,7 @@ export async function openDialog($dialog: JQuery<HTMLElement>, closeActDialog =
         }
     });
 
+    const keyboardActionsService = (await import("./keyboard_actions.js")).default;
     keyboardActionsService.updateDisplayedShortcuts($dialog);
 
     return $dialog;

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

@@ -1,30 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { isValidDocName } from "./doc_renderer.js";
-
-describe("isValidDocName", () => {
-    it("accepts valid docNames", () => {
-        expect(isValidDocName("launchbar_intro")).toBe(true);
-        expect(isValidDocName("User Guide/Quick Start")).toBe(true);
-        expect(isValidDocName("User Guide/User Guide/Quick Start")).toBe(true);
-        expect(isValidDocName("Quick Start Guide")).toBe(true);
-        expect(isValidDocName("quick_start_guide")).toBe(true);
-        expect(isValidDocName("quick-start-guide")).toBe(true);
-    });
-
-    it("rejects path traversal attacks", () => {
-        expect(isValidDocName("..")).toBe(false);
-        expect(isValidDocName("../etc/passwd")).toBe(false);
-        expect(isValidDocName("foo/../bar")).toBe(false);
-        expect(isValidDocName("../../../../api/notes/_malicious/open")).toBe(false);
-        expect(isValidDocName("..\\etc\\passwd")).toBe(false);
-        expect(isValidDocName("foo\\bar")).toBe(false);
-    });
-
-    it("rejects URL manipulation attacks", () => {
-        expect(isValidDocName("../../../../api/notes/_malicious/open?x=")).toBe(false);
-        expect(isValidDocName("foo#bar")).toBe(false);
-        expect(isValidDocName("%2e%2e")).toBe(false);
-        expect(isValidDocName("%2e%2e%2f%2e%2e%2fapi")).toBe(false);
-    });
-});

apps/client/src/services/doc_renderer.ts

@@ -3,39 +3,22 @@ import { applyReferenceLinks } from "../widgets/type_widgets/text/read_only_help
 import { getCurrentLanguage } from "./i18n.js";
 import { formatCodeBlocks } from "./syntax_highlight.js";
 
-/**
- * Validates a docName to prevent path traversal attacks.
- * Allows forward slashes for subdirectories (e.g., "User Guide/Quick Start")
- * but blocks traversal sequences and URL manipulation characters.
- */
-export function isValidDocName(docName: string): boolean {
-    // Allow alphanumeric characters, spaces, underscores, hyphens, and forward slashes.
-    const validDocNameRegex = /^[a-zA-Z0-9_/\- ]+$/;
-    return validDocNameRegex.test(docName);
-}
-
 export default function renderDoc(note: FNote) {
     return new Promise<JQuery<HTMLElement>>((resolve) => {
-        const docName = note.getLabelValue("docName");
+        let docName = note.getLabelValue("docName");
         const $content = $("<div>");
 
-        // find doc based on language
-        const url = getUrl(docName, getCurrentLanguage());
-
-        if (url) {
+        if (docName) {
+            // find doc based on language
+            const url = getUrl(docName, getCurrentLanguage());
             $content.load(url, async (response, status) => {
                 // fallback to english doc if no translation available
                 if (status === "error") {
                     const fallbackUrl = getUrl(docName, "en");
-
-                    if (fallbackUrl) {
-                        $content.load(fallbackUrl, async () => {
-                            await processContent(fallbackUrl, $content);
-                            resolve($content);
-                        });
-                    } else {
+                    $content.load(fallbackUrl, async () => {
+                        await processContent(fallbackUrl, $content)
                         resolve($content);
-                    }
+                    });
                     return;
                 }
 
@@ -45,6 +28,8 @@ export default function renderDoc(note: FNote) {
         } else {
             resolve($content);
         }
+
+        return $content;
     });
 }
 
@@ -52,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);
@@ -63,27 +48,10 @@ async function processContent(url: string, $content: JQuery<HTMLElement>) {
     await applyReferenceLinks($content[0]);
 }
 
-function getUrl(docNameValue: string | null, language: string) {
-    if (!docNameValue) return;
-
-    if (!isValidDocName(docNameValue)) {
-        console.error(`Invalid docName: ${docNameValue}`);
-        return null;
-    }
-
+function getUrl(docNameValue: string, language: string) {
     // Cannot have spaces in the URL due to how JQuery.load works.
     docNameValue = docNameValue.replaceAll(" ", "%20");
-    // 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;
+    const basePath = window.glob.isDev ? window.glob.assetPath + "/.." : window.glob.assetPath;
+    return `${basePath}/doc_notes/${language}/${docNameValue}.html`;
 }

apps/client/src/services/experimental_features.ts

@@ -1,6 +1,5 @@
 import { t } from "./i18n";
 import options from "./options";
-import { isMobile, isStandalone } from "./utils";
 
 export interface ExperimentalFeature {
     id: string;
@@ -13,46 +12,26 @@ export const experimentalFeatures = [
         id: "new-layout",
         name: t("experimental_features.new_layout_name"),
         description: t("experimental_features.new_layout_description"),
-    },
-    {
-        id: "llm",
-        name: t("experimental_features.llm_name"),
-        description: t("experimental_features.llm_description"),
     }
 ] as const satisfies ExperimentalFeature[];
 
 export type ExperimentalFeatureId = typeof experimentalFeatures[number]["id"];
 
-/** Returns experimental features available for the current platform (excludes LLM in standalone mode). */
-export function getAvailableExperimentalFeatures() {
-    return experimentalFeatures.filter(f => !(f.id === "llm" && isStandalone));
-}
-
 let enabledFeatures: Set<ExperimentalFeatureId> | null = null;
 
 export function isExperimentalFeatureEnabled(featureId: ExperimentalFeatureId): boolean {
     if (featureId === "new-layout") {
-        return (isMobile() || options.is("newLayout"));
-    }
-
-    // LLM features require server-side API calls that don't work in standalone mode
-    // due to CORS restrictions from LLM providers (OpenAI, Google don't allow browser requests)
-    if (featureId === "llm" && isStandalone) {
-        return false;
+        return options.is("newLayout");
     }
 
     return getEnabledFeatures().has(featureId);
 }
 
 export function getEnabledExperimentalFeatureIds() {
-    let values = [ ...getEnabledFeatures().values() ];
-    if (isMobile() || options.is("newLayout")) {
+    const values = [ ...getEnabledFeatures().values() ];
+    if (options.is("newLayout")) {
         values.push("new-layout");
     }
-    // LLM is not available in standalone mode
-    if (isStandalone) {
-        values = values.filter(v => v !== "llm");
-    }
     return values;
 }
 

apps/client/src/services/froca.ts

@@ -1,11 +1,11 @@
-import appContext from "../components/app_context.js";
-import FAttachment, { type FAttachmentRow } from "../entities/fattachment.js";
-import FAttribute, { type FAttributeRow } from "../entities/fattribute.js";
-import FBlob, { type FBlobRow } from "../entities/fblob.js";
 import FBranch, { type FBranchRow } from "../entities/fbranch.js";
 import FNote, { type FNoteRow } from "../entities/fnote.js";
-import type { Froca } from "./froca-interface.js";
+import FAttribute, { type FAttributeRow } from "../entities/fattribute.js";
 import server from "./server.js";
+import appContext from "../components/app_context.js";
+import FBlob, { type FBlobRow } from "../entities/fblob.js";
+import FAttachment, { type FAttachmentRow } from "../entities/fattachment.js";
+import type { Froca } from "./froca-interface.js";
 
 interface SubtreeResponse {
     notes: FNoteRow[];
@@ -44,9 +44,8 @@ class FrocaImpl implements Froca {
     }
 
     async loadInitialTree() {
-        if (!glob.dbInitialized) return;
-
         const resp = await server.get<SubtreeResponse>("tree");
+
         // clear the cache only directly before adding new content which is important for e.g., switching to protected session
         this.#clear();
         this.addResp(resp);
@@ -78,7 +77,7 @@ class FrocaImpl implements Froca {
         for (const noteRow of noteRows) {
             const { noteId } = noteRow;
 
-            const note = this.notes[noteId];
+            let note = this.notes[noteId];
 
             if (note) {
                 note.update(noteRow);
@@ -241,8 +240,9 @@ class FrocaImpl implements Froca {
                     console.trace(`Can't find note '${noteId}'`);
 
                     return null;
+                } else {
+                    return this.notes[noteId];
                 }
-                return this.notes[noteId];
             })
             .filter((note) => !!note) as FNote[];
     }
@@ -263,8 +263,9 @@ class FrocaImpl implements Froca {
                     console.trace(`Can't find note '${noteId}'`);
 
                     return null;
+                } else {
+                    return this.notes[noteId];
                 }
-                return this.notes[noteId];
             })
             .filter((note) => !!note) as FNote[];
     }
@@ -337,10 +338,11 @@ class FrocaImpl implements Froca {
             attachmentRows = await server.getWithSilentNotFound<FAttachmentRow[]>(`attachments/${attachmentId}/all`);
         } catch (e: any) {
             if (silentNotFoundError) {
-                logInfo(`Attachment '${attachmentId}' not found, but silentNotFoundError is enabled: ${e.message}`);
+                logInfo(`Attachment '${attachmentId}' not found, but silentNotFoundError is enabled: ` + e.message);
                 return null;
+            } else {
+                throw e;
             }
-            throw e;
         }
 
         const attachments = this.processAttachmentRows(attachmentRows);

apps/client/src/services/froca_updater.ts

@@ -1,16 +1,14 @@
-import type { OptionNames } from "@triliumnext/commons";
-
-import appContext from "../components/app_context.js";
-import FAttachment, { type FAttachmentRow } from "../entities/fattachment.js";
-import FAttribute, { type FAttributeRow } from "../entities/fattribute.js";
+import LoadResults from "./load_results.js";
+import froca from "./froca.js";
+import utils from "./utils.js";
+import options from "./options.js";
+import noteAttributeCache from "./note_attribute_cache.js";
 import FBranch, { type FBranchRow } from "../entities/fbranch.js";
+import FAttribute, { type FAttributeRow } from "../entities/fattribute.js";
+import FAttachment, { type FAttachmentRow } from "../entities/fattachment.js";
 import type { default as FNote, FNoteRow } from "../entities/fnote.js";
 import type { EntityChange } from "../server_types.js";
-import froca from "./froca.js";
-import LoadResults from "./load_results.js";
-import noteAttributeCache from "./note_attribute_cache.js";
-import options from "./options.js";
-import utils from "./utils.js";
+import type { OptionNames } from "@triliumnext/commons";
 
 async function processEntityChanges(entityChanges: EntityChange[]) {
     const loadResults = new LoadResults(entityChanges);
@@ -65,7 +63,7 @@ async function processEntityChanges(entityChanges: EntityChange[]) {
         if (entityName === "branches" && !((entity as FBranchRow).parentNoteId in froca.notes)) {
             missingNoteIds.push((entity as FBranchRow).parentNoteId);
         } else if (entityName === "attributes") {
-            const attributeEntity = entity as FAttributeRow;
+            let attributeEntity = entity as FAttributeRow;
             if (attributeEntity.type === "relation" && (attributeEntity.name === "template" || attributeEntity.name === "inherit") && !(attributeEntity.value in froca.notes)) {
                 missingNoteIds.push(attributeEntity.value);
             }
@@ -81,6 +79,7 @@ async function processEntityChanges(entityChanges: EntityChange[]) {
             noteAttributeCache.invalidate();
         }
 
+        const appContext = (await import("../components/app_context.js")).default;
         await appContext.triggerEvent("entitiesReloaded", { loadResults });
     }
 }
@@ -111,12 +110,7 @@ function processNoteChange(loadResults: LoadResults, ec: EntityChange) {
                 }
             }
 
-            // Only register as a content change if the protection status didn't change.
-            // When isProtected changes, the blobId change is a side effect of re-encryption,
-            // not a content edit. Registering it as content would cause the tree's content-only
-            // filter to incorrectly skip the note update (since both changes share the same
-            // componentId).
-            if (ec.componentId && note.isProtected === (ec.entity as FNoteRow).isProtected) {
+            if (ec.componentId) {
                 loadResults.addNoteContent(note.noteId, ec.componentId);
             }
         }

apps/client/src/services/frontend_script_api.ts

@@ -206,7 +206,7 @@ export interface Api {
      * Instance name identifies particular Trilium instance. It can be useful for scripts
      * if some action needs to happen on only one specific instance.
      */
-    getInstanceName(): string | null;
+    getInstanceName(): string;
 
     /**
      * @returns date in YYYY-MM-DD format

apps/client/src/services/frontend_script_api_preact.ts

@@ -1,4 +1,4 @@
-import { createContext, Fragment, h, VNode } from "preact";
+import { Fragment, h, VNode } from "preact";
 import * as hooks from "preact/hooks";
 
 import ActionButton from "../widgets/react/ActionButton";
@@ -47,7 +47,6 @@ export const preactAPI = Object.freeze({
     // Core
     h,
     Fragment,
-    createContext,
 
     /**
      * Method that must be run for widget scripts that run on Preact, using JSX. The method just returns the same definition, reserved for future typechecking and perhaps validation purposes.

apps/client/src/services/i18n.ts

@@ -1,14 +1,21 @@
-import { LOCALE_IDS, LOCALES, setDayjsLocale } from "@triliumnext/commons";
+import options from "./options.js";
 import i18next from "i18next";
 import i18nextHttpBackend from "i18next-http-backend";
+import server from "./server.js";
+import { LOCALE_IDS, setDayjsLocale, type Locale } from "@triliumnext/commons";
 import { initReactI18next } from "react-i18next";
 
+let locales: Locale[] | null;
+
 /**
  * A deferred promise that resolves when translations are initialized.
  */
-export const translationsInitializedPromise = $.Deferred();
+export let translationsInitializedPromise = $.Deferred();
 
-export async function initLocale(locale: LOCALE_IDS = "en") {
+export async function initLocale() {
+    const locale = ((options.get("locale") as string) || "en") as LOCALE_IDS;
+
+    locales = await server.get<Locale[]>("options/locales");
 
     i18next.use(initReactI18next);
     await i18next.use(i18nextHttpBackend).init({
@@ -25,7 +32,11 @@ export async function initLocale(locale: LOCALE_IDS = "en") {
 }
 
 export function getAvailableLocales() {
-    return LOCALES;
+    if (!locales) {
+        throw new Error("Tried to load list of locales, but localization is not yet initialized.")
+    }
+
+    return locales;
 }
 
 /**
@@ -36,7 +47,7 @@ export function getAvailableLocales() {
  */
 export function getLocaleById(localeId: string | null | undefined) {
     if (!localeId) return null;
-    return LOCALES.find((l) => l.id === localeId) ?? null;
+    return locales?.find((l) => l.id === localeId) ?? null;
 }
 
 export const t = i18next.t;

apps/client/src/services/in_app_help.ts

@@ -1,5 +1,4 @@
 import { NoteType } from "@triliumnext/commons";
-
 import FNote from "../entities/fnote";
 import { ViewTypeOptions } from "../widgets/collections/interface";
 
@@ -19,8 +18,7 @@ export const byNoteType: Record<Exclude<NoteType, "book">, string | null> = {
     search: null,
     text: null,
     webView: null,
-    spreadsheet: null,
-    llmChat: null
+    aiChat: null
 };
 
 export const byBookType: Record<ViewTypeOptions, string | null> = {
@@ -41,6 +39,6 @@ export function getHelpUrlForNote(note: FNote | null | undefined) {
     } else if (note?.hasLabel("textSnippet")) {
         return "pwc194wlRzcH";
     } else if (note && note.type === "book") {
-        return byBookType[note.getAttributeValue("label", "viewType") as ViewTypeOptions ?? ""];
+        return byBookType[note.getAttributeValue("label", "viewType") as ViewTypeOptions ?? ""]
     }
 }