Bulk create HTML snapshots (#1132 )

* Add option to create HTML snapshot for bulk edit * Add the prerequisite for displaying the "Create HTML Snapshot" bulk action option * Add test case This test case covers the scenario where the bulk actions panel displays the corresponding options when the HTML snapshot feature is enabled. * Use the existing `tasks.create_html_snapshots()` instead of the for loop * Fix the exposure of `settings.LD_ENABLE_SNAPSHOTS` within `BookmarkListContext` * add service tests * cleanup context --------- Co-authored-by: Sascha Ißbrücker <sascha.issbruecker@gmail.com>
Run formatter
2025-08-14 14:09:26 +02:00 · 2025-08-12 23:06:23 +02:00 · 2025-08-11 08:05:50 +02:00 · 2025-08-10 22:45:28 +02:00 · 2025-08-10 15:05:10 +02:00 · 2025-08-10 12:59:55 +02:00
222 changed files with 11373 additions and 4596 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -3,7 +3,6 @@

 # Include files required for build or at runtime
 !/bookmarks
-!/siteroot

 !/bootstrap.sh
 !/LICENSE.txt
@@ -19,4 +18,4 @@
 !/version.txt

 # Remove dev settings
-/siteroot/settings/dev.py
+/bookmarks/settings/dev.py
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -0,0 +1,89 @@
+name: build
+
+on: workflow_dispatch
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Read version from file
+        id: get_version
+        run: echo "VERSION=$(cat version.txt)" >> $GITHUB_ENV
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ vars.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ github.token }}
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build latest
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./docker/default.Dockerfile
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          tags: |
+            sissbruecker/linkding:latest
+            sissbruecker/linkding:${{ env.VERSION }}
+            ghcr.io/sissbruecker/linkding:latest
+            ghcr.io/sissbruecker/linkding:${{ env.VERSION }}
+          target: linkding
+          push: true
+
+      - name: Build latest-alpine
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./docker/alpine.Dockerfile
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          tags: |
+            sissbruecker/linkding:latest-alpine
+            sissbruecker/linkding:${{ env.VERSION }}-alpine
+            ghcr.io/sissbruecker/linkding:latest-alpine
+            ghcr.io/sissbruecker/linkding:${{ env.VERSION }}-alpine
+          target: linkding
+          push: true
+
+      - name: Build latest-plus
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./docker/default.Dockerfile
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          tags: |
+            sissbruecker/linkding:latest-plus
+            sissbruecker/linkding:${{ env.VERSION }}-plus
+            ghcr.io/sissbruecker/linkding:latest-plus
+            ghcr.io/sissbruecker/linkding:${{ env.VERSION }}-plus
+          target: linkding-plus
+          push: true
+
+      - name: Build latest-plus-alpine
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./docker/alpine.Dockerfile
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          tags: |
+            sissbruecker/linkding:latest-plus-alpine
+            sissbruecker/linkding:${{ env.VERSION }}-plus-alpine
+            ghcr.io/sissbruecker/linkding:latest-plus-alpine
+            ghcr.io/sissbruecker/linkding:${{ env.VERSION }}-plus-alpine
+          target: linkding-plus
+          push: true
--- a/.github/workflows/main.yaml
+++ b/.github/workflows/main.yaml
@@ -55,4 +55,4 @@ jobs:
          npm run build
          python manage.py collectstatic
      - name: Run tests
-        run: python manage.py test bookmarks.e2e --pattern="e2e_test_*.py"
+        run: python manage.py test bookmarks.tests_e2e --pattern="e2e_test_*.py"
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,183 @@
 # Changelog

-##  (23/09/2024)
+## v1.41.0 (19/06/2025)
+
+### What's Changed
+* Add bundles for organizing bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1097
+* Add REST API for bookmark bundles by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1100
+* Add date filters for REST API by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1080
+* Fix side panel not being hidden on smaller viewports by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1089
+* Fix assets not using correct icon by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1098
+* Add LinkBuddy to community section by @peterto in https://github.com/sissbruecker/linkding/pull/1088
+* Bump tar-fs in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1084
+* Bump django from 5.1.9 to 5.1.10 by @dependabot in https://github.com/sissbruecker/linkding/pull/1086
+* Bump requests from 2.32.3 to 2.32.4 by @dependabot in https://github.com/sissbruecker/linkding/pull/1090
+* Bump urllib3 from 2.2.3 to 2.5.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/1096
+
+### New Contributors
+* @peterto made their first contribution in https://github.com/sissbruecker/linkding/pull/1088
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.40.0...v1.41.0
+
+---
+
+## v1.40.0 (17/05/2025)
+
+### What's Changed
+* Add bulk and single bookmark metadata refresh by @Teknicallity in https://github.com/sissbruecker/linkding/pull/999
+* Prefer local snapshot over web archive link in bookmark list links by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1021
+* Push Docker images to GHCR in addition to Docker Hub by @caycehouse in https://github.com/sissbruecker/linkding/pull/1024
+* Allow auto tagging rules to match URL fragments by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1045
+* Linkify plain URLs in notes by @sonicdoe in https://github.com/sissbruecker/linkding/pull/1051
+* Add opensearch declaration by @jzorn in https://github.com/sissbruecker/linkding/pull/1058
+* Allow pre-filling tags in new bookmark form by @dasrecht in https://github.com/sissbruecker/linkding/pull/1060
+* Handle lowercase "true" in environment variables by @jose-elias-alvarez in https://github.com/sissbruecker/linkding/pull/1020
+* Accessibility improvements in page structure by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1014
+* Improve announcements after navigation by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1015
+* Fix OIDC login link by @cite in https://github.com/sissbruecker/linkding/pull/1019
+* Fix bookmark asset download endpoint by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1033
+* Add docs for auto tagging by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1009
+* Fix typo in index.mdx tagline by @cenviity in https://github.com/sissbruecker/linkding/pull/1052
+* Add how-to for using linkding PWA in native Android share sheet by @kzshantonu in https://github.com/sissbruecker/linkding/pull/1055
+* Adding linktiles to community projects by @haondt in https://github.com/sissbruecker/linkding/pull/1025
+* Bump django from 5.1.5 to 5.1.7 by @dependabot in https://github.com/sissbruecker/linkding/pull/1007
+* Bump django from 5.1.7 to 5.1.8 by @dependabot in https://github.com/sissbruecker/linkding/pull/1030
+* Bump tar-fs in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1028
+* Bump prismjs from 1.29.0 to 1.30.0 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1034
+* Bump @babel/helpers from 7.26.7 to 7.27.0 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1035
+* Bump vite from 5.4.14 to 5.4.17 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1036
+* Bump esbuild, @astrojs/starlight and astro in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1037
+* Bump django from 5.1.8 to 5.1.9 by @dependabot in https://github.com/sissbruecker/linkding/pull/1059
+
+### New Contributors
+* @cite made their first contribution in https://github.com/sissbruecker/linkding/pull/1019
+* @jose-elias-alvarez made their first contribution in https://github.com/sissbruecker/linkding/pull/1020
+* @Teknicallity made their first contribution in https://github.com/sissbruecker/linkding/pull/999
+* @haondt made their first contribution in https://github.com/sissbruecker/linkding/pull/1025
+* @caycehouse made their first contribution in https://github.com/sissbruecker/linkding/pull/1024
+* @cenviity made their first contribution in https://github.com/sissbruecker/linkding/pull/1052
+* @sonicdoe made their first contribution in https://github.com/sissbruecker/linkding/pull/1051
+* @jzorn made their first contribution in https://github.com/sissbruecker/linkding/pull/1058
+* @dasrecht made their first contribution in https://github.com/sissbruecker/linkding/pull/1060
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.39.1...v1.40.0
+
+---
+
+## v1.39.1 (06/03/2025)
+
+> [!WARNING]
+> Due to changes in the release process the `1.39.0` Docker image accidentally runs the application in debug mode. Please upgrade to `1.39.1` instead.
+
+---
+
+## v1.39.0 (06/03/2025)
+
+### What's Changed
+* Add REST endpoint for uploading snapshots from the Singlefile extension by @sissbruecker in https://github.com/sissbruecker/linkding/pull/996
+* Add bookmark assets API by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1003
+* Allow providing REST API authentication token with Bearer keyword by @sissbruecker in https://github.com/sissbruecker/linkding/pull/995
+* Add Telegram bot to community section by @marb08 in https://github.com/sissbruecker/linkding/pull/1001
+* Adding linklater to community projects by @nsartor in https://github.com/sissbruecker/linkding/pull/1002
+
+### New Contributors
+* @marb08 made their first contribution in https://github.com/sissbruecker/linkding/pull/1001
+* @nsartor made their first contribution in https://github.com/sissbruecker/linkding/pull/1002
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.38.1...v1.39.0
+
+---
+
+## v1.38.1 (22/02/2025)
+
+### What's Changed
+* Remove preview image when bookmark is deleted by @sissbruecker in https://github.com/sissbruecker/linkding/pull/989
+* Try limit uwsgi memory usage by configuring file descriptor limit by @sissbruecker in https://github.com/sissbruecker/linkding/pull/990
+* Add note about OIDC and LD_SUPERUSER_NAME combination by @tebriel in https://github.com/sissbruecker/linkding/pull/992
+* Return web archive fallback URL from REST API by @sissbruecker in https://github.com/sissbruecker/linkding/pull/993
+* Fix auth proxy logout by @sissbruecker in https://github.com/sissbruecker/linkding/pull/994
+
+### New Contributors
+* @tebriel made their first contribution in https://github.com/sissbruecker/linkding/pull/992
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.38.0...v1.38.1
+
+---
+
+## v1.38.0 (09/02/2025)
+
+### What's Changed
+* Fix nav menu closing on mousedown in Safari by @sissbruecker in https://github.com/sissbruecker/linkding/pull/965
+* Allow customizing username when creating user through OIDC by @kyuuk in https://github.com/sissbruecker/linkding/pull/971
+* Improve accessibility of modal dialogs by @sissbruecker in https://github.com/sissbruecker/linkding/pull/974
+* Add option to collapse side panel by @sissbruecker in https://github.com/sissbruecker/linkding/pull/975
+* Convert tag modal into drawer by @sissbruecker in https://github.com/sissbruecker/linkding/pull/977
+* Add RSS link to shared bookmarks page by @sissbruecker in https://github.com/sissbruecker/linkding/pull/984
+* Add Additional iOS Shortcut to community section by @joshdick in https://github.com/sissbruecker/linkding/pull/968
+
+### New Contributors
+* @kyuuk made their first contribution in https://github.com/sissbruecker/linkding/pull/971
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.37.0...v1.38.0
+
+---
+
+## v1.37.0 (26/01/2025)
+
+### What's Changed
+* Add option to disable request logs by @dmarcoux in https://github.com/sissbruecker/linkding/pull/887
+* Add default robots.txt to block crawlers by @sissbruecker in https://github.com/sissbruecker/linkding/pull/959
+* Fix menu dropdown focus traps by @sissbruecker in https://github.com/sissbruecker/linkding/pull/944
+* Provide accessible name to radio groups by @sissbruecker in https://github.com/sissbruecker/linkding/pull/945
+* Add serchding to community projects, sort the list by alphabetical order by @ldwgchen in https://github.com/sissbruecker/linkding/pull/880
+* Add cosmicding To Community Resources by @vkhitrin in https://github.com/sissbruecker/linkding/pull/892
+* Add 3 new community projects by @sebw in https://github.com/sissbruecker/linkding/pull/949
+* Add a rust client library to community.md by @zbrox in https://github.com/sissbruecker/linkding/pull/914
+* Update community.md by @justusthane in https://github.com/sissbruecker/linkding/pull/897
+* Bump astro from 4.15.8 to 4.16.3 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/884
+* Bump vite from 5.4.9 to 5.4.14 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/953
+* Bump django from 5.1.1 to 5.1.5 by @dependabot in https://github.com/sissbruecker/linkding/pull/947
+* Bump nanoid from 3.3.7 to 3.3.8 by @dependabot in https://github.com/sissbruecker/linkding/pull/928
+* Bump astro from 4.16.3 to 4.16.18 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/929
+* Bump nanoid from 3.3.7 to 3.3.8 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/962
+
+### New Contributors
+* @ldwgchen made their first contribution in https://github.com/sissbruecker/linkding/pull/880
+* @dmarcoux made their first contribution in https://github.com/sissbruecker/linkding/pull/887
+* @vkhitrin made their first contribution in https://github.com/sissbruecker/linkding/pull/892
+* @sebw made their first contribution in https://github.com/sissbruecker/linkding/pull/949
+* @justusthane made their first contribution in https://github.com/sissbruecker/linkding/pull/897
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.36.0...v1.37.0
+
+---
+
+## v1.36.0 (02/10/2024)
+
+### What's Changed
+* Replace uBlock Origin with uBlock Origin Lite by @sissbruecker in https://github.com/sissbruecker/linkding/pull/866
+* Add LAST_MODIFIED attribute when exporting by @ixzhao in https://github.com/sissbruecker/linkding/pull/860
+* Return client error status code for invalid form submissions by @sissbruecker in https://github.com/sissbruecker/linkding/pull/849
+* Fix header.svg text by @vladh in https://github.com/sissbruecker/linkding/pull/850
+* Do not clear fields in POST requests (API behavior change) by @sissbruecker in https://github.com/sissbruecker/linkding/pull/852
+* Prevent duplicates when editing by @sissbruecker in https://github.com/sissbruecker/linkding/pull/853
+* Fix jumping details modal on back navigation by @sissbruecker in https://github.com/sissbruecker/linkding/pull/854
+* Fix select dropdown menu background in dark theme by @sissbruecker in https://github.com/sissbruecker/linkding/pull/858
+* Do not escape valid characters in custom CSS by @sissbruecker in https://github.com/sissbruecker/linkding/pull/863
+* Simplify Docker build by @sissbruecker in https://github.com/sissbruecker/linkding/pull/865
+* Improve error handling for auto tagging by @sissbruecker in https://github.com/sissbruecker/linkding/pull/855
+* Bump rollup from 4.13.0 to 4.22.4 by @dependabot in https://github.com/sissbruecker/linkding/pull/851
+* Bump rollup from 4.21.3 to 4.22.4 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/856
+
+### New Contributors
+* @vladh made their first contribution in https://github.com/sissbruecker/linkding/pull/850
+* @ixzhao made their first contribution in https://github.com/sissbruecker/linkding/pull/860
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.35.0...v1.36.0
+
+---
+
+## v1.35.0 (23/09/2024)

 ### What's Changed
 * Add configuration options for pagination by @sissbruecker in https://github.com/sissbruecker/linkding/pull/835
--- a/3
+++ b/3
@@ -4,13 +4,12 @@ serve:
 	python manage.py runserver

 tasks:
-	python manage.py process_tasks
+	python manage.py run_huey

 test:
 	pytest -n auto

 format:
 	black bookmarks
-	black siteroot
 	npx prettier bookmarks/frontend --write
 	npx prettier bookmarks/styles --write
--- a/README.md
+++ b/README.md
@@ -58,7 +58,7 @@ Small improvements, bugfixes and documentation improvements are always welcome.

 ## Development

-The application is built using the Django web framework. You can get started by checking out the excellent [Django docs](https://docs.djangoproject.com/en/4.1/). The `bookmarks` folder contains the actual bookmark application, `siteroot` is the Django root application. Other than that the code should be self-explanatory / standard Django stuff 🙂.
+The application is built using the Django web framework. You can get started by checking out the excellent [Django docs](https://docs.djangoproject.com/en/4.1/). The `bookmarks` folder contains the actual bookmark application. Other than that the code should be self-explanatory / standard Django stuff 🙂.

 ### Prerequisites
 - Python 3.12
--- a/bookmarks/admin.py
+++ b/bookmarks/admin.py
@@ -11,7 +11,15 @@ from huey.contrib.djhuey import HUEY as huey
 from rest_framework.authtoken.admin import TokenAdmin
 from rest_framework.authtoken.models import TokenProxy

-from bookmarks.models import Bookmark, BookmarkAsset, Tag, UserProfile, Toast, FeedToken
+from bookmarks.models import (
+    Bookmark,
+    BookmarkAsset,
+    BookmarkBundle,
+    Tag,
+    UserProfile,
+    Toast,
+    FeedToken,
+)
 from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark


@@ -256,6 +264,21 @@ class AdminTag(admin.ModelAdmin):
            )


+class AdminBookmarkBundle(admin.ModelAdmin):
+    list_display = (
+        "name",
+        "owner",
+        "order",
+        "search",
+        "any_tags",
+        "all_tags",
+        "excluded_tags",
+        "date_created",
+    )
+    search_fields = ["name", "search", "any_tags", "all_tags", "excluded_tags"]
+    list_filter = ("owner__username",)
+
+
 class AdminUserProfileInline(admin.StackedInline):
    model = UserProfile
    can_delete = False
@@ -289,6 +312,7 @@ linkding_admin_site = LinkdingAdminSite()
 linkding_admin_site.register(Bookmark, AdminBookmark)
 linkding_admin_site.register(BookmarkAsset, AdminBookmarkAsset)
 linkding_admin_site.register(Tag, AdminTag)
+linkding_admin_site.register(BookmarkBundle, AdminBookmarkBundle)
 linkding_admin_site.register(User, AdminCustomUser)
 linkding_admin_site.register(TokenProxy, TokenAdmin)
 linkding_admin_site.register(Toast, AdminToast)
--- a/bookmarks/api/auth.py
+++ b/bookmarks/api/auth.py
@@ -0,0 +1,34 @@
+from django.utils.translation import gettext_lazy as _
+from rest_framework import exceptions
+from rest_framework.authentication import TokenAuthentication, get_authorization_header
+
+
+class LinkdingTokenAuthentication(TokenAuthentication):
+    """
+    Extends DRF TokenAuthentication to add support for multiple keywords
+    """
+
+    keywords = [keyword.lower().encode() for keyword in ["Token", "Bearer"]]
+
+    def authenticate(self, request):
+        auth = get_authorization_header(request).split()
+
+        if not auth or auth[0].lower() not in self.keywords:
+            return None
+
+        if len(auth) == 1:
+            msg = _("Invalid token header. No credentials provided.")
+            raise exceptions.AuthenticationFailed(msg)
+        elif len(auth) > 2:
+            msg = _("Invalid token header. Token string should not contain spaces.")
+            raise exceptions.AuthenticationFailed(msg)
+
+        try:
+            token = auth[1].decode()
+        except UnicodeError:
+            msg = _(
+                "Invalid token header. Token string should not contain invalid characters."
+            )
+            raise exceptions.AuthenticationFailed(msg)
+
+        return self.authenticate_credentials(token)
--- a/bookmarks/api/routes.py
+++ b/bookmarks/api/routes.py
@@ -1,25 +1,34 @@
+import gzip
 import logging
+import os

+from django.conf import settings
+from django.http import Http404, StreamingHttpResponse
 from rest_framework import viewsets, mixins, status
 from rest_framework.decorators import action
 from rest_framework.permissions import AllowAny
 from rest_framework.response import Response
-from rest_framework.routers import DefaultRouter
+from rest_framework.routers import SimpleRouter, DefaultRouter

 from bookmarks import queries
 from bookmarks.api.serializers import (
    BookmarkSerializer,
+    BookmarkAssetSerializer,
    TagSerializer,
    UserProfileSerializer,
+    BookmarkBundleSerializer,
 )
-from bookmarks.models import Bookmark, BookmarkSearch, Tag, User
-from bookmarks.services import auto_tagging
-from bookmarks.services.bookmarks import (
-    archive_bookmark,
-    unarchive_bookmark,
-    website_loader,
+from bookmarks.models import (
+    Bookmark,
+    BookmarkAsset,
+    BookmarkSearch,
+    Tag,
+    User,
+    BookmarkBundle,
 )
-from bookmarks.services.website_loader import WebsiteMetadata
+from bookmarks.services import assets, bookmarks, bundles, auto_tagging, website_loader
+from bookmarks.type_defs import HttpRequest
+from bookmarks.views import access

 logger = logging.getLogger(__name__)

@@ -32,6 +41,7 @@ class BookmarkViewSet(
    mixins.UpdateModelMixin,
    mixins.DestroyModelMixin,
 ):
+    request: HttpRequest
    serializer_class = BookmarkSerializer

    def get_permissions(self):
@@ -46,67 +56,63 @@ class BookmarkViewSet(
        return super().get_permissions()

    def get_queryset(self):
+        # Provide filtered queryset for list actions
        user = self.request.user
-        # For list action, use query set that applies search and tag projections
+        search = BookmarkSearch.from_request(self.request, self.request.GET)
        if self.action == "list":
-            search = BookmarkSearch.from_request(self.request.GET)
            return queries.query_bookmarks(user, user.profile, search)
+        elif self.action == "archived":
+            return queries.query_archived_bookmarks(user, user.profile, search)
+        elif self.action == "shared":
+            user = User.objects.filter(username=search.user).first()
+            public_only = not self.request.user.is_authenticated
+            return queries.query_shared_bookmarks(
+                user, self.request.user_profile, search, public_only
+            )

-        # For single entity actions use default query set without projections
+        # For single entity actions return user owned bookmarks
        return Bookmark.objects.all().filter(owner=user)

    def get_serializer_context(self):
        disable_scraping = "disable_scraping" in self.request.GET
+        disable_html_snapshot = "disable_html_snapshot" in self.request.GET
        return {
            "request": self.request,
            "user": self.request.user,
            "disable_scraping": disable_scraping,
+            "disable_html_snapshot": disable_html_snapshot,
        }

    @action(methods=["get"], detail=False)
-    def archived(self, request):
-        user = request.user
-        search = BookmarkSearch.from_request(request.GET)
-        query_set = queries.query_archived_bookmarks(user, user.profile, search)
-        page = self.paginate_queryset(query_set)
-        serializer = self.get_serializer(page, many=True)
-        data = serializer.data
-        return self.get_paginated_response(data)
+    def archived(self, request: HttpRequest):
+        return self.list(request)

    @action(methods=["get"], detail=False)
-    def shared(self, request):
-        search = BookmarkSearch.from_request(request.GET)
-        user = User.objects.filter(username=search.user).first()
-        public_only = not request.user.is_authenticated
-        query_set = queries.query_shared_bookmarks(
-            user, request.user_profile, search, public_only
-        )
-        page = self.paginate_queryset(query_set)
-        serializer = self.get_serializer(page, many=True)
-        data = serializer.data
-        return self.get_paginated_response(data)
+    def shared(self, request: HttpRequest):
+        return self.list(request)

    @action(methods=["post"], detail=True)
-    def archive(self, request, pk):
+    def archive(self, request: HttpRequest, pk):
        bookmark = self.get_object()
-        archive_bookmark(bookmark)
+        bookmarks.archive_bookmark(bookmark)
        return Response(status=status.HTTP_204_NO_CONTENT)

    @action(methods=["post"], detail=True)
-    def unarchive(self, request, pk):
+    def unarchive(self, request: HttpRequest, pk):
        bookmark = self.get_object()
-        unarchive_bookmark(bookmark)
+        bookmarks.unarchive_bookmark(bookmark)
        return Response(status=status.HTTP_204_NO_CONTENT)

    @action(methods=["get"], detail=False)
-    def check(self, request):
+    def check(self, request: HttpRequest):
        url = request.GET.get("url")
+        ignore_cache = request.GET.get("ignore_cache", False) in ["true"]
        bookmark = Bookmark.objects.filter(owner=request.user, url=url).first()
        existing_bookmark_data = (
            self.get_serializer(bookmark).data if bookmark else None
        )

-        metadata = website_loader.load_website_metadata(url)
+        metadata = website_loader.load_website_metadata(url, ignore_cache=ignore_cache)

        # Return tags that would be automatically applied to the bookmark
        profile = request.user.profile
@@ -129,6 +135,116 @@ class BookmarkViewSet(
            status=status.HTTP_200_OK,
        )

+    @action(methods=["post"], detail=False)
+    def singlefile(self, request: HttpRequest):
+        if settings.LD_DISABLE_ASSET_UPLOAD:
+            return Response(
+                {"error": "Asset upload is disabled."},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+        url = request.POST.get("url")
+        file = request.FILES.get("file")
+
+        if not url or not file:
+            return Response(
+                {"error": "Both 'url' and 'file' parameters are required."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        bookmark = Bookmark.objects.filter(owner=request.user, url=url).first()
+
+        if not bookmark:
+            bookmark = Bookmark(url=url)
+            bookmark = bookmarks.create_bookmark(
+                bookmark, "", request.user, disable_html_snapshot=True
+            )
+            bookmarks.enhance_with_website_metadata(bookmark)
+
+        assets.upload_snapshot(bookmark, file.read())
+
+        return Response(
+            {"message": "Snapshot uploaded successfully."},
+            status=status.HTTP_201_CREATED,
+        )
+
+
+class BookmarkAssetViewSet(
+    viewsets.GenericViewSet,
+    mixins.ListModelMixin,
+    mixins.RetrieveModelMixin,
+    mixins.DestroyModelMixin,
+):
+    request: HttpRequest
+    serializer_class = BookmarkAssetSerializer
+
+    def get_queryset(self):
+        user = self.request.user
+        # limit access to assets to the owner of the bookmark for now
+        bookmark = access.bookmark_write(self.request, self.kwargs["bookmark_id"])
+        return BookmarkAsset.objects.filter(
+            bookmark_id=bookmark.id, bookmark__owner=user
+        )
+
+    def get_serializer_context(self):
+        return {"user": self.request.user}
+
+    @action(detail=True, methods=["get"], url_path="download")
+    def download(self, request: HttpRequest, bookmark_id, pk):
+        asset = self.get_object()
+        try:
+            file_path = os.path.join(settings.LD_ASSET_FOLDER, asset.file)
+            content_type = asset.content_type
+            file_stream = (
+                gzip.GzipFile(file_path, mode="rb")
+                if asset.gzip
+                else open(file_path, "rb")
+            )
+            response = StreamingHttpResponse(file_stream, content_type=content_type)
+            response["Content-Disposition"] = (
+                f'attachment; filename="{asset.download_name}"'
+            )
+            return response
+        except FileNotFoundError:
+            raise Http404("Asset file does not exist")
+        except Exception as e:
+            logger.error(
+                f"Failed to download asset. bookmark_id={bookmark_id}, asset_id={pk}",
+                exc_info=e,
+            )
+            return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @action(methods=["post"], detail=False)
+    def upload(self, request: HttpRequest, bookmark_id):
+        if settings.LD_DISABLE_ASSET_UPLOAD:
+            return Response(
+                {"error": "Asset upload is disabled."},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+        bookmark = access.bookmark_write(request, bookmark_id)
+
+        upload_file = request.FILES.get("file")
+        if not upload_file:
+            return Response(
+                {"error": "No file provided."}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            asset = assets.upload_asset(bookmark, upload_file)
+            serializer = self.get_serializer(asset)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        except Exception as e:
+            logger.error(
+                f"Failed to upload asset file. bookmark_id={bookmark_id}, file={upload_file.name}",
+                exc_info=e,
+            )
+            return Response(
+                {"error": "Failed to upload asset."},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    def perform_destroy(self, instance):
+        assets.remove_asset(instance)
+

 class TagViewSet(
    viewsets.GenericViewSet,
@@ -136,6 +252,7 @@ class TagViewSet(
    mixins.RetrieveModelMixin,
    mixins.CreateModelMixin,
 ):
+    request: HttpRequest
    serializer_class = TagSerializer

    def get_queryset(self):
@@ -148,11 +265,48 @@ class TagViewSet(

 class UserViewSet(viewsets.GenericViewSet):
    @action(methods=["get"], detail=False)
-    def profile(self, request):
+    def profile(self, request: HttpRequest):
        return Response(UserProfileSerializer(request.user.profile).data)


-router = DefaultRouter()
-router.register(r"bookmarks", BookmarkViewSet, basename="bookmark")
-router.register(r"tags", TagViewSet, basename="tag")
-router.register(r"user", UserViewSet, basename="user")
+class BookmarkBundleViewSet(
+    viewsets.GenericViewSet,
+    mixins.ListModelMixin,
+    mixins.RetrieveModelMixin,
+    mixins.CreateModelMixin,
+    mixins.UpdateModelMixin,
+    mixins.DestroyModelMixin,
+):
+    request: HttpRequest
+    serializer_class = BookmarkBundleSerializer
+
+    def get_queryset(self):
+        user = self.request.user
+        return BookmarkBundle.objects.filter(owner=user).order_by("order")
+
+    def get_serializer_context(self):
+        return {"user": self.request.user}
+
+    def perform_destroy(self, instance):
+        bundles.delete_bundle(instance)
+
+
+# DRF routers do not support nested view sets such as /bookmarks/<id>/assets/<id>/
+# Instead create separate routers for each view set and manually register them in urls.py
+# The default router is only used to allow reversing a URL for the API root
+default_router = DefaultRouter()
+
+bookmark_router = SimpleRouter()
+bookmark_router.register("", BookmarkViewSet, basename="bookmark")
+
+tag_router = SimpleRouter()
+tag_router.register("", TagViewSet, basename="tag")
+
+user_router = SimpleRouter()
+user_router.register("", UserViewSet, basename="user")
+
+bundle_router = SimpleRouter()
+bundle_router.register("", BookmarkBundleViewSet, basename="bundle")
+
+bookmark_asset_router = SimpleRouter()
+bookmark_asset_router.register("", BookmarkAssetViewSet, basename="bookmark_asset")
--- a/bookmarks/api/serializers.py
+++ b/bookmarks/api/serializers.py
@@ -1,15 +1,20 @@
-from django.db.models import prefetch_related_objects
+from django.db.models import Max, prefetch_related_objects
 from django.templatetags.static import static
 from rest_framework import serializers
 from rest_framework.serializers import ListSerializer

-from bookmarks.models import Bookmark, Tag, build_tag_string, UserProfile
-from bookmarks.services.bookmarks import (
-    create_bookmark,
-    update_bookmark,
-    enhance_with_website_metadata,
+from bookmarks.models import (
+    Bookmark,
+    BookmarkAsset,
+    Tag,
+    build_tag_string,
+    UserProfile,
+    BookmarkBundle,
 )
+from bookmarks.services import bookmarks, bundles
 from bookmarks.services.tags import get_or_create_tag
+from bookmarks.services.wayback import generate_fallback_webarchive_url
+from bookmarks.utils import app_version


 class TagListField(serializers.ListField):
@@ -24,6 +29,37 @@ class BookmarkListSerializer(ListSerializer):
        return super().to_representation(data)


+class EmtpyField(serializers.ReadOnlyField):
+    def to_representation(self, value):
+        return None
+
+
+class BookmarkBundleSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = BookmarkBundle
+        fields = [
+            "id",
+            "name",
+            "search",
+            "any_tags",
+            "all_tags",
+            "excluded_tags",
+            "order",
+            "date_created",
+            "date_modified",
+        ]
+        read_only_fields = [
+            "id",
+            "date_created",
+            "date_modified",
+        ]
+
+    def create(self, validated_data):
+        bundle = BookmarkBundle(**validated_data)
+        bundle.order = validated_data["order"] if "order" in validated_data else None
+        return bundles.create_bundle(bundle, self.context["user"])
+
+
 class BookmarkSerializer(serializers.ModelSerializer):
    class Meta:
        model = Bookmark
@@ -59,12 +95,13 @@ class BookmarkSerializer(serializers.ModelSerializer):

    # Custom tag_names field to allow passing a list of tag names to create/update
    tag_names = TagListField(required=False)
-    # Custom fields to return URLs for favicon and preview image
+    # Custom fields to generate URLs for favicon, preview image, and web archive snapshot
    favicon_url = serializers.SerializerMethodField()
    preview_image_url = serializers.SerializerMethodField()
+    web_archive_snapshot_url = serializers.SerializerMethodField()
    # Add dummy website title and description fields for backwards compatibility but keep them empty
-    website_title = serializers.SerializerMethodField()
-    website_description = serializers.SerializerMethodField()
+    website_title = EmtpyField()
+    website_description = EmtpyField()

    def get_favicon_url(self, obj: Bookmark):
        if not obj.favicon_file:
@@ -82,23 +119,31 @@ class BookmarkSerializer(serializers.ModelSerializer):
        preview_image_url = request.build_absolute_uri(preview_image_file_path)
        return preview_image_url

-    def get_website_title(self, obj: Bookmark):
-        return None
+    def get_web_archive_snapshot_url(self, obj: Bookmark):
+        if obj.web_archive_snapshot_url:
+            return obj.web_archive_snapshot_url

-    def get_website_description(self, obj: Bookmark):
-        return None
+        return generate_fallback_webarchive_url(obj.url, obj.date_added)

    def create(self, validated_data):
        tag_names = validated_data.pop("tag_names", [])
        tag_string = build_tag_string(tag_names)
        bookmark = Bookmark(**validated_data)

-        saved_bookmark = create_bookmark(bookmark, tag_string, self.context["user"])
+        disable_scraping = self.context.get("disable_scraping", False)
+        disable_html_snapshot = self.context.get("disable_html_snapshot", False)
+
+        saved_bookmark = bookmarks.create_bookmark(
+            bookmark,
+            tag_string,
+            self.context["user"],
+            disable_html_snapshot=disable_html_snapshot,
+        )
        # Unless scraping is explicitly disabled, enhance bookmark with website
        # metadata to preserve backwards compatibility with clients that expect
        # title and description to be populated automatically when left empty
-        if not self.context.get("disable_scraping", False):
-            enhance_with_website_metadata(saved_bookmark)
+        if not disable_scraping:
+            bookmarks.enhance_with_website_metadata(saved_bookmark)
        return saved_bookmark

    def update(self, instance: Bookmark, validated_data):
@@ -109,7 +154,7 @@ class BookmarkSerializer(serializers.ModelSerializer):
            if not field.read_only and field_name in validated_data:
                setattr(instance, field_name, validated_data[field_name])

-        return update_bookmark(instance, tag_string, self.context["user"])
+        return bookmarks.update_bookmark(instance, tag_string, self.context["user"])

    def validate(self, attrs):
        # When creating a bookmark, the service logic prevents duplicate URLs by
@@ -130,6 +175,21 @@ class BookmarkSerializer(serializers.ModelSerializer):
        return attrs


+class BookmarkAssetSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = BookmarkAsset
+        fields = [
+            "id",
+            "bookmark",
+            "date_created",
+            "file_size",
+            "asset_type",
+            "content_type",
+            "display_name",
+            "status",
+        ]
+
+
 class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
@@ -155,4 +215,7 @@ class UserProfileSerializer(serializers.ModelSerializer):
            "display_url",
            "permanent_notes",
            "search_preferences",
+            "version",
        ]
+
+    version = serializers.ReadOnlyField(default=app_version)
--- a/bookmarks/context_processors.py
+++ b/bookmarks/context_processors.py
@@ -1,6 +1,5 @@
-from bookmarks import queries
-from bookmarks.models import BookmarkSearch, Toast
 from bookmarks import utils
+from bookmarks.models import Toast


 def toasts(request):
--- a/bookmarks/e2e/e2e_test_new_bookmark_form.py
+++ b/bookmarks/e2e/e2e_test_new_bookmark_form.py
@@ -1,166 +0,0 @@
-from unittest.mock import patch
-from urllib.parse import quote
-
-from django.urls import reverse
-from playwright.sync_api import sync_playwright, expect
-
-from bookmarks.e2e.helpers import LinkdingE2ETestCase
-from bookmarks.services import website_loader
-
-mock_website_metadata = website_loader.WebsiteMetadata(
-    url="https://example.com",
-    title="Example Domain",
-    description="This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission.",
-    preview_image=None,
-)
-
-
-class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
-
-    def setUp(self) -> None:
-        super().setUp()
-        self.website_loader_patch = patch.object(
-            website_loader, "load_website_metadata", return_value=mock_website_metadata
-        )
-        self.website_loader_patch.start()
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        self.website_loader_patch.stop()
-
-    def test_enter_url_prefills_title_and_description(self):
-        with sync_playwright() as p:
-            page = self.open(reverse("bookmarks:new"), p)
-            url = page.get_by_label("URL")
-            title = page.get_by_label("Title")
-            description = page.get_by_label("Description")
-
-            url.fill("https://example.com")
-            expect(title).to_have_value("Example Domain")
-            expect(description).to_have_value(
-                "This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission."
-            )
-
-    def test_enter_url_does_not_overwrite_modified_title_and_description(self):
-        with sync_playwright() as p:
-            page = self.open(reverse("bookmarks:new"), p)
-            url = page.get_by_label("URL")
-            title = page.get_by_label("Title")
-            description = page.get_by_label("Description")
-
-            title.fill("Modified title")
-            description.fill("Modified description")
-            url.fill("https://example.com")
-            page.wait_for_timeout(timeout=1000)
-
-            expect(title).to_have_value("Modified title")
-            expect(description).to_have_value("Modified description")
-
-    def test_with_initial_url_prefills_title_and_description(self):
-        with sync_playwright() as p:
-            page_url = reverse("bookmarks:new") + f"?url={quote('https://example.com')}"
-            page = self.open(page_url, p)
-            url = page.get_by_label("URL")
-            title = page.get_by_label("Title")
-            description = page.get_by_label("Description")
-
-            page.wait_for_timeout(timeout=1000)
-
-            expect(url).to_have_value("https://example.com")
-            expect(title).to_have_value("Example Domain")
-            expect(description).to_have_value(
-                "This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission."
-            )
-
-    def test_with_initial_url_title_description_does_not_overwrite_title_and_description(
-        self,
-    ):
-        with sync_playwright() as p:
-            page_url = (
-                reverse("bookmarks:new")
-                + f"?url={quote('https://example.com')}&title=Initial+title&description=Initial+description"
-            )
-            page = self.open(page_url, p)
-            url = page.get_by_label("URL")
-            title = page.get_by_label("Title")
-            description = page.get_by_label("Description")
-
-            page.wait_for_timeout(timeout=1000)
-
-            expect(url).to_have_value("https://example.com")
-            expect(title).to_have_value("Initial title")
-            expect(description).to_have_value("Initial description")
-
-    def test_create_should_check_for_existing_bookmark(self):
-        existing_bookmark = self.setup_bookmark(
-            title="Existing title",
-            description="Existing description",
-            notes="Existing notes",
-            tags=[self.setup_tag(name="tag1"), self.setup_tag(name="tag2")],
-            unread=True,
-        )
-        tag_names = " ".join(existing_bookmark.tag_names)
-
-        with sync_playwright() as p:
-            page = self.open(reverse("bookmarks:new"), p)
-
-            # Enter bookmarked URL
-            page.get_by_label("URL").fill(existing_bookmark.url)
-            # Already bookmarked hint should be visible
-            page.get_by_text("This URL is already bookmarked.").wait_for(timeout=2000)
-            # Form should be pre-filled with data from existing bookmark
-            self.assertEqual(
-                existing_bookmark.title, page.get_by_label("Title").input_value()
-            )
-            self.assertEqual(
-                existing_bookmark.description,
-                page.get_by_label("Description").input_value(),
-            )
-            self.assertEqual(
-                existing_bookmark.notes, page.get_by_label("Notes").input_value()
-            )
-            self.assertEqual(tag_names, page.get_by_label("Tags").input_value())
-            self.assertTrue(tag_names, page.get_by_label("Mark as unread").is_checked())
-
-            # Enter non-bookmarked URL
-            page.get_by_label("URL").fill("https://example.com/unknown")
-            # Already bookmarked hint should be hidden
-            page.get_by_text("This URL is already bookmarked.").wait_for(
-                state="hidden", timeout=2000
-            )
-
-    def test_enter_url_of_existing_bookmark_should_show_notes(self):
-        bookmark = self.setup_bookmark(
-            notes="Existing notes", description="Existing description"
-        )
-
-        with sync_playwright() as p:
-            page = self.open(reverse("bookmarks:new"), p)
-
-            details = page.locator("details.notes")
-            expect(details).not_to_have_attribute("open", value="")
-
-            page.get_by_label("URL").fill(bookmark.url)
-            expect(details).to_have_attribute("open", value="")
-
-    def test_create_should_preview_auto_tags(self):
-        profile = self.get_or_create_test_user().profile
-        profile.auto_tagging_rules = "github.com dev github"
-        profile.save()
-
-        with sync_playwright() as p:
-            # Open page with URL that should have auto tags
-            url = (
-                reverse("bookmarks:new")
-                + "?url=https%3A%2F%2Fgithub.com%2Fsissbruecker%2Flinkding"
-            )
-            page = self.open(url, p)
-
-            auto_tags_hint = page.locator(".form-input-hint.auto-tags")
-            expect(auto_tags_hint).to_be_visible()
-            expect(auto_tags_hint).to_have_text("Auto tags: dev github")
-
-            # Change to URL without auto tags
-            page.get_by_label("URL").fill("https://example.com")
-
-            expect(auto_tags_hint).to_be_hidden()
--- a/bookmarks/feeds.py
+++ b/bookmarks/feeds.py
@@ -8,6 +8,7 @@ from django.urls import reverse

 from bookmarks import queries
 from bookmarks.models import Bookmark, BookmarkSearch, FeedToken, UserProfile
+from bookmarks.views import access


@dataclass
@@ -30,10 +31,16 @@ def sanitize(text: str):
 class BaseBookmarksFeed(Feed):
    def get_object(self, request, feed_key: str | None):
        feed_token = FeedToken.objects.get(key__exact=feed_key) if feed_key else None
+        bundle = None
+        bundle_id = request.GET.get("bundle")
+        if bundle_id:
+            bundle = access.bundle_read(request, bundle_id)
+
        search = BookmarkSearch(
            q=request.GET.get("q", ""),
            unread=request.GET.get("unread", ""),
            shared=request.GET.get("shared", ""),
+            bundle=bundle,
        )
        query_set = self.get_query_set(feed_token, search)
        return FeedContext(request, feed_token, query_set)
@@ -74,7 +81,7 @@ class AllBookmarksFeed(BaseBookmarksFeed):
        return queries.query_bookmarks(feed_token.user, feed_token.user.profile, search)

    def link(self, context: FeedContext):
-        return reverse("bookmarks:feeds.all", args=[context.feed_token.key])
+        return reverse("linkding:feeds.all", args=[context.feed_token.key])


 class UnreadBookmarksFeed(BaseBookmarksFeed):
@@ -87,7 +94,7 @@ class UnreadBookmarksFeed(BaseBookmarksFeed):
        ).filter(unread=True)

    def link(self, context: FeedContext):
-        return reverse("bookmarks:feeds.unread", args=[context.feed_token.key])
+        return reverse("linkding:feeds.unread", args=[context.feed_token.key])


 class SharedBookmarksFeed(BaseBookmarksFeed):
@@ -100,7 +107,7 @@ class SharedBookmarksFeed(BaseBookmarksFeed):
        )

    def link(self, context: FeedContext):
-        return reverse("bookmarks:feeds.shared", args=[context.feed_token.key])
+        return reverse("linkding:feeds.shared", args=[context.feed_token.key])


 class PublicSharedBookmarksFeed(BaseBookmarksFeed):
@@ -114,4 +121,4 @@ class PublicSharedBookmarksFeed(BaseBookmarksFeed):
        return queries.query_shared_bookmarks(None, UserProfile(), search, True)

    def link(self, context: FeedContext):
-        return reverse("bookmarks:feeds.public_shared")
+        return reverse("linkding:feeds.public_shared")
--- a/bookmarks/forms.py
+++ b/bookmarks/forms.py
@@ -0,0 +1,102 @@
+from django import forms
+from django.forms.utils import ErrorList
+
+from bookmarks.models import Bookmark, build_tag_string
+from bookmarks.validators import BookmarkURLValidator
+from bookmarks.type_defs import HttpRequest
+from bookmarks.services.bookmarks import create_bookmark, update_bookmark
+
+
+class CustomErrorList(ErrorList):
+    template_name = "shared/error_list.html"
+
+
+class BookmarkForm(forms.ModelForm):
+    # Use URLField for URL
+    url = forms.CharField(validators=[BookmarkURLValidator()])
+    tag_string = forms.CharField(required=False)
+    # Do not require title and description as they may be empty
+    title = forms.CharField(max_length=512, required=False)
+    description = forms.CharField(required=False, widget=forms.Textarea())
+    unread = forms.BooleanField(required=False)
+    shared = forms.BooleanField(required=False)
+    # Hidden field that determines whether to close window/tab after saving the bookmark
+    auto_close = forms.CharField(required=False)
+
+    class Meta:
+        model = Bookmark
+        fields = [
+            "url",
+            "tag_string",
+            "title",
+            "description",
+            "notes",
+            "unread",
+            "shared",
+            "auto_close",
+        ]
+
+    def __init__(self, request: HttpRequest, instance: Bookmark = None):
+        self.request = request
+
+        initial = None
+        if instance is None and request.method == "GET":
+            initial = {
+                "url": request.GET.get("url"),
+                "title": request.GET.get("title"),
+                "description": request.GET.get("description"),
+                "notes": request.GET.get("notes"),
+                "tag_string": request.GET.get("tags"),
+                "auto_close": "auto_close" in request.GET,
+                "unread": request.user_profile.default_mark_unread,
+            }
+        if instance is not None and request.method == "GET":
+            initial = {"tag_string": build_tag_string(instance.tag_names, " ")}
+        data = request.POST if request.method == "POST" else None
+        super().__init__(
+            data, instance=instance, initial=initial, error_class=CustomErrorList
+        )
+
+    @property
+    def is_auto_close(self):
+        return self.data.get("auto_close", False) == "True" or self.initial.get(
+            "auto_close", False
+        )
+
+    @property
+    def has_notes(self):
+        return self.initial.get("notes", None) or (
+            self.instance and self.instance.notes
+        )
+
+    def save(self, commit=False):
+        tag_string = convert_tag_string(self.data["tag_string"])
+        bookmark = super().save(commit=False)
+        if self.instance.pk:
+            return update_bookmark(bookmark, tag_string, self.request.user)
+        else:
+            return create_bookmark(bookmark, tag_string, self.request.user)
+
+    def clean_url(self):
+        # When creating a bookmark, the service logic prevents duplicate URLs by
+        # updating the existing bookmark instead, which is also communicated in
+        # the form's UI. When editing a bookmark, there is no assumption that
+        # it would update a different bookmark if the URL is a duplicate, so
+        # raise a validation error in that case.
+        url = self.cleaned_data["url"]
+        if self.instance.pk:
+            is_duplicate = (
+                Bookmark.objects.filter(owner=self.instance.owner, url=url)
+                .exclude(pk=self.instance.pk)
+                .exists()
+            )
+            if is_duplicate:
+                raise forms.ValidationError("A bookmark with this URL already exists.")
+
+        return url
+
+
+def convert_tag_string(tag_string: str):
+    # Tag strings coming from inputs are space-separated, however services.bookmarks functions expect comma-separated
+    # strings
+    return tag_string.replace(" ", ",")
--- a/bookmarks/frontend/behaviors/details-modal.js
+++ b/bookmarks/frontend/behaviors/details-modal.js
@@ -1,60 +1,22 @@
-import { Behavior, registerBehavior } from "./index";
+import { registerBehavior } from "./index";
+import { isKeyboardActive, setAfterPageLoadFocusTarget } from "./focus-utils";
+import { ModalBehavior } from "./modal";

-class DetailsModalBehavior extends Behavior {
-  constructor(element) {
-    super(element);
+class DetailsModalBehavior extends ModalBehavior {
+  doClose() {
+    super.doClose();

-    this.onClose = this.onClose.bind(this);
-    this.onKeyDown = this.onKeyDown.bind(this);
+    // Navigate to close URL
+    const closeUrl = this.element.dataset.closeUrl;
+    Turbo.visit(closeUrl, {
+      action: "replace",
+      frame: "details-modal",
+    });

-    this.overlayLink = element.querySelector("a:has(.modal-overlay)");
-    this.buttonLink = element.querySelector("a:has(button.close)");
-
-    this.overlayLink.addEventListener("click", this.onClose);
-    this.buttonLink.addEventListener("click", this.onClose);
-    document.addEventListener("keydown", this.onKeyDown);
-  }
-
-  destroy() {
-    this.overlayLink.removeEventListener("click", this.onClose);
-    this.buttonLink.removeEventListener("click", this.onClose);
-    document.removeEventListener("keydown", this.onKeyDown);
-  }
-
-  onKeyDown(event) {
-    // Skip if event occurred within an input element
-    const targetNodeName = event.target.nodeName;
-    const isInputTarget =
-      targetNodeName === "INPUT" ||
-      targetNodeName === "SELECT" ||
-      targetNodeName === "TEXTAREA";
-
-    if (isInputTarget) {
-      return;
-    }
-
-    if (event.key === "Escape") {
-      this.onClose(event);
-    }
-  }
-
-  onClose(event) {
-    event.preventDefault();
-    this.element.classList.add("closing");
-    this.element.addEventListener(
-      "animationend",
-      (event) => {
-        if (event.animationName === "fade-out") {
-          this.element.remove();
-
-          const closeUrl = this.overlayLink.href;
-          Turbo.visit(closeUrl, {
-            action: "replace",
-            frame: "details-modal",
-          });
-        }
-      },
-      { once: true },
+    // Try restore focus to view details to view details link of respective bookmark
+    const bookmarkId = this.element.dataset.bookmarkId;
+    setAfterPageLoadFocusTarget(
+      `ul.bookmark-list li[data-bookmark-id='${bookmarkId}'] a.view-action`,
    );
  }
 }
--- a/bookmarks/frontend/behaviors/dropdown.js
+++ b/bookmarks/frontend/behaviors/dropdown.js
@@ -6,23 +6,38 @@ class DropdownBehavior extends Behavior {
    this.opened = false;
    this.onClick = this.onClick.bind(this);
    this.onOutsideClick = this.onOutsideClick.bind(this);
+    this.onEscape = this.onEscape.bind(this);
+    this.onFocusOut = this.onFocusOut.bind(this);
+
+    // Prevent opening the dropdown automatically on focus, so that it only
+    // opens on click then JS is enabled
+    this.element.style.setProperty("--dropdown-focus-display", "none");
+    this.element.addEventListener("keydown", this.onEscape);
+    this.element.addEventListener("focusout", this.onFocusOut);

    this.toggle = element.querySelector(".dropdown-toggle");
+    this.toggle.setAttribute("aria-expanded", "false");
    this.toggle.addEventListener("click", this.onClick);
  }

  destroy() {
    this.close();
    this.toggle.removeEventListener("click", this.onClick);
+    this.element.removeEventListener("keydown", this.onEscape);
+    this.element.removeEventListener("focusout", this.onFocusOut);
  }

  open() {
+    this.opened = true;
    this.element.classList.add("active");
+    this.toggle.setAttribute("aria-expanded", "true");
    document.addEventListener("click", this.onOutsideClick);
  }

  close() {
+    this.opened = false;
    this.element.classList.remove("active");
+    this.toggle.setAttribute("aria-expanded", "false");
    document.removeEventListener("click", this.onOutsideClick);
  }

@@ -39,6 +54,20 @@ class DropdownBehavior extends Behavior {
      this.close();
    }
  }
+
+  onEscape(event) {
+    if (event.key === "Escape" && this.opened) {
+      event.preventDefault();
+      this.close();
+      this.toggle.focus();
+    }
+  }
+
+  onFocusOut(event) {
+    if (!this.element.contains(event.relatedTarget)) {
+      this.close();
+    }
+  }
 }

 registerBehavior("ld-dropdown", DropdownBehavior);
--- a/bookmarks/frontend/behaviors/filter-drawer.js
+++ b/bookmarks/frontend/behaviors/filter-drawer.js
@@ -0,0 +1,97 @@
+import { Behavior, registerBehavior } from "./index";
+import { ModalBehavior } from "./modal";
+import { isKeyboardActive } from "./focus-utils";
+
+class FilterDrawerTriggerBehavior extends Behavior {
+  constructor(element) {
+    super(element);
+
+    this.onClick = this.onClick.bind(this);
+
+    element.addEventListener("click", this.onClick);
+  }
+
+  destroy() {
+    this.element.removeEventListener("click", this.onClick);
+  }
+
+  onClick() {
+    const modal = document.createElement("div");
+    modal.classList.add("modal", "drawer", "filter-drawer");
+    modal.setAttribute("ld-filter-drawer", "");
+    modal.innerHTML = `
+      <div class="modal-overlay"></div>
+      <div class="modal-container" role="dialog" aria-modal="true">
+        <div class="modal-header">
+          <h2>Filters</h2>
+          <button class="close" aria-label="Close dialog">
+            <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" stroke-width="2"
+                 stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
+              <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+              <path d="M18 6l-12 12"></path>
+              <path d="M6 6l12 12"></path>
+            </svg>
+          </button>
+        </div>
+        <div class="modal-body">
+          <div class="content"></div>
+        </div>
+      </div>    
+    `;
+    document.body.querySelector(".modals").appendChild(modal);
+  }
+}
+
+class FilterDrawerBehavior extends ModalBehavior {
+  init() {
+    // Teleport content before creating focus trap, otherwise it will not detect
+    // focusable content elements
+    this.teleport();
+    super.init();
+    // Add active class to start slide-in animation
+    this.element.classList.add("active");
+  }
+
+  destroy() {
+    super.destroy();
+    // Always close on destroy to restore drawer content to original location
+    // before turbo caches DOM
+    this.doClose();
+  }
+
+  mapHeading(container, from, to) {
+    const headings = container.querySelectorAll(from);
+    headings.forEach((heading) => {
+      const newHeading = document.createElement(to);
+      newHeading.textContent = heading.textContent;
+      heading.replaceWith(newHeading);
+    });
+  }
+
+  teleport() {
+    const content = this.element.querySelector(".content");
+    const sidePanel = document.querySelector(".side-panel");
+    content.append(...sidePanel.children);
+    this.mapHeading(content, "h2", "h3");
+  }
+
+  teleportBack() {
+    const sidePanel = document.querySelector(".side-panel");
+    const content = this.element.querySelector(".content");
+    sidePanel.append(...content.children);
+    this.mapHeading(sidePanel, "h3", "h2");
+  }
+
+  doClose() {
+    super.doClose();
+    this.teleportBack();
+
+    // Try restore focus to drawer trigger
+    const restoreFocusElement =
+      document.querySelector("[ld-filter-drawer-trigger]") || document.body;
+    restoreFocusElement.focus({ focusVisible: isKeyboardActive() });
+  }
+}
+
+registerBehavior("ld-filter-drawer-trigger", FilterDrawerTriggerBehavior);
+registerBehavior("ld-filter-drawer", FilterDrawerBehavior);
--- a/bookmarks/frontend/behaviors/focus-utils.js
+++ b/bookmarks/frontend/behaviors/focus-utils.js
@@ -0,0 +1,124 @@
+let keyboardActive = false;
+
+window.addEventListener(
+  "keydown",
+  () => {
+    keyboardActive = true;
+  },
+  { capture: true },
+);
+
+window.addEventListener(
+  "mousedown",
+  () => {
+    keyboardActive = false;
+  },
+  { capture: true },
+);
+
+export function isKeyboardActive() {
+  return keyboardActive;
+}
+
+export class FocusTrapController {
+  constructor(element) {
+    this.element = element;
+    this.focusableElements = this.element.querySelectorAll(
+      'a[href]:not([disabled]), button:not([disabled]), textarea:not([disabled]), input[type="text"]:not([disabled]), input[type="radio"]:not([disabled]), input[type="checkbox"]:not([disabled]), select:not([disabled])',
+    );
+    this.firstFocusableElement = this.focusableElements[0];
+    this.lastFocusableElement =
+      this.focusableElements[this.focusableElements.length - 1];
+
+    this.onKeyDown = this.onKeyDown.bind(this);
+
+    this.firstFocusableElement.focus({ focusVisible: keyboardActive });
+    this.element.addEventListener("keydown", this.onKeyDown);
+  }
+
+  destroy() {
+    this.element.removeEventListener("keydown", this.onKeyDown);
+  }
+
+  onKeyDown(event) {
+    if (event.key !== "Tab") {
+      return;
+    }
+    if (event.shiftKey) {
+      if (document.activeElement === this.firstFocusableElement) {
+        event.preventDefault();
+        this.lastFocusableElement.focus();
+      }
+    } else {
+      if (document.activeElement === this.lastFocusableElement) {
+        event.preventDefault();
+        this.firstFocusableElement.focus();
+      }
+    }
+  }
+}
+
+let afterPageLoadFocusTarget = [];
+let firstPageLoad = true;
+
+export function setAfterPageLoadFocusTarget(...targets) {
+  afterPageLoadFocusTarget = targets;
+}
+
+function programmaticFocus(element) {
+  // Ensure element is focusable
+  // Hide focus outline if element is not focusable by default - might
+  // reconsider this later
+  const isFocusable = element.tabIndex >= 0;
+  if (!isFocusable) {
+    // Apparently the default tabIndex is -1, even though an element is still
+    // not focusable with that. Setting an explicit -1 also sets the attribute
+    // and the element becomes focusable.
+    element.tabIndex = -1;
+    // `focusVisible` is not supported in all browsers, so hide the outline manually
+    element.style["outline"] = "none";
+  }
+  element.focus({
+    focusVisible: isKeyboardActive() && isFocusable,
+    preventScroll: true,
+  });
+}
+
+// Register global listener for navigation and try to focus an element that
+// results in a meaningful announcement.
+document.addEventListener("turbo:load", () => {
+  // Ignore initial page load to let the browser handle announcements
+  if (firstPageLoad) {
+    firstPageLoad = false;
+    return;
+  }
+
+  // Check if there is an explicit focus target for the next page load
+  for (const target of afterPageLoadFocusTarget) {
+    const element = document.querySelector(target);
+    if (element) {
+      programmaticFocus(element);
+      return;
+    }
+  }
+  afterPageLoadFocusTarget = [];
+
+  // If there is some autofocus element, let the browser handle it
+  const autofocus = document.querySelector("[autofocus]");
+  if (autofocus) {
+    return;
+  }
+
+  // If there is a toast as a result of some action, focus it
+  const toast = document.querySelector(".toast");
+  if (toast) {
+    programmaticFocus(toast);
+    return;
+  }
+
+  // Otherwise go with main
+  const main = document.querySelector("main");
+  if (main) {
+    programmaticFocus(main);
+  }
+});
--- a/bookmarks/frontend/behaviors/modal.js
+++ b/bookmarks/frontend/behaviors/modal.js
@@ -0,0 +1,91 @@
+import { Behavior } from "./index";
+import { FocusTrapController } from "./focus-utils";
+
+export class ModalBehavior extends Behavior {
+  constructor(element) {
+    super(element);
+
+    this.onClose = this.onClose.bind(this);
+    this.onKeyDown = this.onKeyDown.bind(this);
+
+    this.overlay = element.querySelector(".modal-overlay");
+    this.closeButton = element.querySelector(".modal-header .close");
+
+    this.overlay.addEventListener("click", this.onClose);
+    this.closeButton.addEventListener("click", this.onClose);
+    document.addEventListener("keydown", this.onKeyDown);
+
+    this.init();
+  }
+
+  destroy() {
+    this.overlay.removeEventListener("click", this.onClose);
+    this.closeButton.removeEventListener("click", this.onClose);
+    document.removeEventListener("keydown", this.onKeyDown);
+
+    this.clearInert();
+    this.focusTrap.destroy();
+  }
+
+  init() {
+    this.setupInert();
+    this.focusTrap = new FocusTrapController(
+      this.element.querySelector(".modal-container"),
+    );
+  }
+
+  setupInert() {
+    // Inert all other elements on the page
+    document
+      .querySelectorAll("body > *:not(.modals)")
+      .forEach((el) => el.setAttribute("inert", ""));
+    // Lock scroll on the body
+    document.body.classList.add("scroll-lock");
+  }
+
+  clearInert() {
+    // Clear inert attribute from all elements to allow focus outside the modal again
+    document
+      .querySelectorAll("body > *")
+      .forEach((el) => el.removeAttribute("inert"));
+    // Remove scroll lock from the body
+    document.body.classList.remove("scroll-lock");
+  }
+
+  onKeyDown(event) {
+    // Skip if event occurred within an input element
+    const targetNodeName = event.target.nodeName;
+    const isInputTarget =
+      targetNodeName === "INPUT" ||
+      targetNodeName === "SELECT" ||
+      targetNodeName === "TEXTAREA";
+
+    if (isInputTarget) {
+      return;
+    }
+
+    if (event.key === "Escape") {
+      this.onClose(event);
+    }
+  }
+
+  onClose(event) {
+    event.preventDefault();
+    this.element.classList.add("closing");
+    this.element.addEventListener(
+      "animationend",
+      (event) => {
+        if (event.animationName === "fade-out") {
+          this.doClose();
+        }
+      },
+      { once: true },
+    );
+  }
+
+  doClose() {
+    this.element.remove();
+    this.clearInert();
+    this.element.dispatchEvent(new CustomEvent("modal:close"));
+  }
+}
--- a/bookmarks/frontend/behaviors/tag-autocomplete.js
+++ b/bookmarks/frontend/behaviors/tag-autocomplete.js
@@ -19,6 +19,7 @@ class TagAutocomplete extends Behavior {
        name: input.name,
        value: input.value,
        placeholder: input.getAttribute("placeholder") || "",
+        ariaDescribedBy: input.getAttribute("aria-describedby") || "",
        variant: input.getAttribute("variant"),
      },
    });
--- a/bookmarks/frontend/behaviors/tag-modal.js
+++ b/bookmarks/frontend/behaviors/tag-modal.js
@@ -1,68 +0,0 @@
-import { Behavior, registerBehavior } from "./index";
-
-class TagModalBehavior extends Behavior {
-  constructor(element) {
-    super(element);
-
-    this.onClick = this.onClick.bind(this);
-    this.onClose = this.onClose.bind(this);
-
-    element.addEventListener("click", this.onClick);
-  }
-
-  destroy() {
-    this.onClose();
-    this.element.removeEventListener("click", this.onClick);
-  }
-
-  onClick() {
-    const modal = document.createElement("div");
-    modal.classList.add("modal", "active");
-    modal.innerHTML = `
-      <div class="modal-overlay" aria-label="Close"></div>
-      <div class="modal-container">
-        <div class="modal-header">
-          <h2>Tags</h2>
-          <button class="close" aria-label="Close">
-            <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" stroke-width="2"
-                 stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
-              <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
-              <path d="M18 6l-12 12"></path>
-              <path d="M6 6l12 12"></path>
-            </svg>
-          </button>
-        </div>
-        <div class="modal-body">
-          <div class="content"></div>
-        </div>
-      </div>    
-    `;
-
-    const tagCloud = document.querySelector(".tag-cloud");
-    const tagCloudContainer = tagCloud.parentElement;
-
-    const content = modal.querySelector(".content");
-    content.appendChild(tagCloud);
-
-    const overlay = modal.querySelector(".modal-overlay");
-    const closeButton = modal.querySelector(".close");
-    overlay.addEventListener("click", this.onClose);
-    closeButton.addEventListener("click", this.onClose);
-
-    this.modal = modal;
-    this.tagCloud = tagCloud;
-    this.tagCloudContainer = tagCloudContainer;
-    document.body.appendChild(modal);
-  }
-
-  onClose() {
-    if (!this.modal) {
-      return;
-    }
-
-    this.modal.remove();
-    this.tagCloudContainer.appendChild(this.tagCloud);
-  }
-}
-
-registerBehavior("ld-tag-modal", TagModalBehavior);
--- a/bookmarks/frontend/components/TagAutocomplete.svelte
+++ b/bookmarks/frontend/components/TagAutocomplete.svelte
@@ -6,6 +6,7 @@
  export let name;
  export let value;
  export let placeholder;
+  export let ariaDescribedBy;
  export let variant = 'default';

  let isFocus = false;
@@ -77,6 +78,7 @@
    const bounds = getCurrentWordBounds(input);
    const value = input.value;
    input.value = value.substring(0, bounds.start) + suggestion.name + ' ' + value.substring(bounds.end);
+    input.dispatchEvent(new CustomEvent('change', {bubbles: true}));

    close();
  }
@@ -109,6 +111,7 @@
    <!-- autocomplete real input box -->
    <input id="{id}" name="{name}" value="{value ||''}" placeholder="{placeholder || ' '}"
           class="form-input" type="text" autocomplete="off" autocapitalize="off"
+           aria-describedby="{ariaDescribedBy}"
           on:input={handleInput} on:keydown={handleKeyDown}
           on:focus={handleFocus} on:blur={handleBlur}>
  </div>
@@ -128,41 +131,41 @@
 </div>

 <style>
-    .menu {
-        display: none;
-        max-height: 200px;
-        overflow: auto;
-    }
+  .menu {
+    display: none;
+    max-height: 200px;
+    overflow: auto;
+  }

-    .menu.open {
-        display: block;
-    }
+  .menu.open {
+    display: block;
+  }

-    .form-autocomplete-input {
-        box-sizing: border-box;
-        height: var(--control-size);
-        min-height: var(--control-size);
-        padding: 0;
-    }
+  .form-autocomplete-input {
+    box-sizing: border-box;
+    height: var(--control-size);
+    min-height: var(--control-size);
+    padding: 0;
+  }

-    .form-autocomplete-input input {
-        width: 100%;
-        height: 100%;
-        border: none;
-        margin: 0;
-    }
+  .form-autocomplete-input input {
+    width: 100%;
+    height: 100%;
+    border: none;
+    margin: 0;
+  }

-    .form-autocomplete.small .form-autocomplete-input {
-        height: var(--control-size-sm);
-        min-height: var(--control-size-sm);
-    }
+  .form-autocomplete.small .form-autocomplete-input {
+    height: var(--control-size-sm);
+    min-height: var(--control-size-sm);
+  }

-    .form-autocomplete.small .form-autocomplete-input input {
-        padding: 0.05rem 0.3rem;
-        font-size: var(--font-size-sm);
-    }
+  .form-autocomplete.small .form-autocomplete-input input {
+    padding: 0.05rem 0.3rem;
+    font-size: var(--font-size-sm);
+  }

-    .form-autocomplete.small .menu .menu-item {
-        font-size: var(--font-size-sm);
-    }
+  .form-autocomplete.small .menu .menu-item {
+    font-size: var(--font-size-sm);
+  }
 </style>
--- a/bookmarks/frontend/index.js
+++ b/bookmarks/frontend/index.js
@@ -3,13 +3,13 @@ import "./behaviors/bookmark-page";
 import "./behaviors/bulk-edit";
 import "./behaviors/clear-button";
 import "./behaviors/confirm-button";
-import "./behaviors/dropdown";
-import "./behaviors/form";
 import "./behaviors/details-modal";
+import "./behaviors/dropdown";
+import "./behaviors/filter-drawer";
+import "./behaviors/form";
 import "./behaviors/global-shortcuts";
 import "./behaviors/search-autocomplete";
 import "./behaviors/tag-autocomplete";
-import "./behaviors/tag-modal";

 export { default as TagAutoComplete } from "./components/TagAutocomplete.svelte";
 export { default as SearchAutoComplete } from "./components/SearchAutoComplete.svelte";
--- a/bookmarks/migrations/0043_userprofile_collapse_side_panel.py
+++ b/bookmarks/migrations/0043_userprofile_collapse_side_panel.py
@@ -0,0 +1,18 @@
+# Generated by Django 5.1.5 on 2025-02-02 09:35
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0042_userprofile_custom_css_hash"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="collapse_side_panel",
+            field=models.BooleanField(default=False),
+        ),
+    ]
--- a/bookmarks/migrations/0044_bookmark_latest_snapshot.py
+++ b/bookmarks/migrations/0044_bookmark_latest_snapshot.py
@@ -0,0 +1,46 @@
+# Generated by Django 5.1.7 on 2025-03-22 12:28
+
+import django.db.models.deletion
+from django.db import migrations, models
+from django.db.models import OuterRef, Subquery
+
+
+def forwards(apps, schema_editor):
+    # Update the latest snapshot for each bookmark
+    Bookmark = apps.get_model("bookmarks", "bookmark")
+    BookmarkAsset = apps.get_model("bookmarks", "bookmarkasset")
+
+    latest_snapshots = (
+        BookmarkAsset.objects.filter(
+            bookmark=OuterRef("pk"), asset_type="snapshot", status="complete"
+        )
+        .order_by("-date_created")
+        .values("id")[:1]
+    )
+    Bookmark.objects.update(latest_snapshot_id=Subquery(latest_snapshots))
+
+
+def reverse(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0043_userprofile_collapse_side_panel"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="bookmark",
+            name="latest_snapshot",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="latest_snapshot",
+                to="bookmarks.bookmarkasset",
+            ),
+        ),
+        migrations.RunPython(forwards, reverse),
+    ]
--- a/bookmarks/migrations/0045_userprofile_hide_bundles_bookmarkbundle.py
+++ b/bookmarks/migrations/0045_userprofile_hide_bundles_bookmarkbundle.py
@@ -0,0 +1,50 @@
+# Generated by Django 5.1.9 on 2025-06-19 08:48
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0044_bookmark_latest_snapshot"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="hide_bundles",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.CreateModel(
+            name="BookmarkBundle",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.CharField(max_length=256)),
+                ("search", models.CharField(blank=True, max_length=256)),
+                ("any_tags", models.CharField(blank=True, max_length=1024)),
+                ("all_tags", models.CharField(blank=True, max_length=1024)),
+                ("excluded_tags", models.CharField(blank=True, max_length=1024)),
+                ("order", models.IntegerField(default=0)),
+                ("date_created", models.DateTimeField(auto_now_add=True)),
+                ("date_modified", models.DateTimeField(auto_now=True)),
+                (
+                    "owner",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+    ]
--- a/bookmarks/models.py
+++ b/bookmarks/models.py
@@ -2,11 +2,11 @@ import binascii
 import hashlib
 import logging
 import os
+from functools import cached_property
 from typing import List

 from django import forms
 from django.conf import settings
-from django.contrib.auth import get_user_model
 from django.contrib.auth.models import User
 from django.core.validators import MinValueValidator
 from django.db import models
@@ -23,7 +23,7 @@ logger = logging.getLogger(__name__)
 class Tag(models.Model):
    name = models.CharField(max_length=64)
    date_added = models.DateTimeField()
-    owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
+    owner = models.ForeignKey(User, on_delete=models.CASCADE)

    def __str__(self):
        return self.name
@@ -40,7 +40,7 @@ def parse_tag_string(tag_string: str, delimiter: str = ","):
        return []
    names = tag_string.strip().split(delimiter)
    # remove empty names, sanitize remaining names
-    names = [sanitize_tag_name(name) for name in names if name]
+    names = [sanitize_tag_name(name) for name in names if name.strip()]
    # remove duplicates
    names = unique(names, str.lower)
    names.sort(key=str.lower)
@@ -70,8 +70,15 @@ class Bookmark(models.Model):
    date_added = models.DateTimeField()
    date_modified = models.DateTimeField()
    date_accessed = models.DateTimeField(blank=True, null=True)
-    owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
+    owner = models.ForeignKey(User, on_delete=models.CASCADE)
    tags = models.ManyToManyField(Tag)
+    latest_snapshot = models.ForeignKey(
+        "BookmarkAsset",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="latest_snapshot",
+    )

    @property
    def resolved_title(self):
@@ -93,6 +100,19 @@ class Bookmark(models.Model):
        return self.resolved_title + " (" + self.url[:30] + "...)"


+@receiver(post_delete, sender=Bookmark)
+def bookmark_deleted(sender, instance, **kwargs):
+    if instance.preview_image_file:
+        filepath = os.path.join(settings.LD_PREVIEW_FOLDER, instance.preview_image_file)
+        if os.path.isfile(filepath):
+            try:
+                os.remove(filepath)
+            except Exception as error:
+                logger.error(
+                    f"Failed to delete preview image: {filepath}", exc_info=error
+                )
+
+
 class BookmarkAsset(models.Model):
    TYPE_SNAPSHOT = "snapshot"
    TYPE_UPLOAD = "upload"
@@ -113,6 +133,14 @@ class BookmarkAsset(models.Model):
    status = models.CharField(max_length=64, blank=False, null=False)
    gzip = models.BooleanField(default=False, null=False)

+    @property
+    def download_name(self):
+        return (
+            f"{self.display_name}.html"
+            if self.asset_type == BookmarkAsset.TYPE_SNAPSHOT
+            else self.display_name
+        )
+
    def save(self, *args, **kwargs):
        if self.file:
            try:
@@ -138,54 +166,25 @@ def bookmark_asset_deleted(sender, instance, **kwargs):
                logger.error(f"Failed to delete asset file: {filepath}", exc_info=error)


-class BookmarkForm(forms.ModelForm):
-    # Use URLField for URL
-    url = forms.CharField(validators=[BookmarkURLValidator()])
-    tag_string = forms.CharField(required=False)
-    # Do not require title and description as they may be empty
-    title = forms.CharField(max_length=512, required=False)
-    description = forms.CharField(required=False, widget=forms.Textarea())
-    unread = forms.BooleanField(required=False)
-    shared = forms.BooleanField(required=False)
-    # Hidden field that determines whether to close window/tab after saving the bookmark
-    auto_close = forms.CharField(required=False)
+class BookmarkBundle(models.Model):
+    name = models.CharField(max_length=256, blank=False)
+    search = models.CharField(max_length=256, blank=True)
+    any_tags = models.CharField(max_length=1024, blank=True)
+    all_tags = models.CharField(max_length=1024, blank=True)
+    excluded_tags = models.CharField(max_length=1024, blank=True)
+    order = models.IntegerField(null=False, default=0)
+    date_created = models.DateTimeField(auto_now_add=True, null=False)
+    date_modified = models.DateTimeField(auto_now=True, null=False)
+    owner = models.ForeignKey(User, on_delete=models.CASCADE)

+    def __str__(self):
+        return self.name
+
+
+class BookmarkBundleForm(forms.ModelForm):
    class Meta:
-        model = Bookmark
-        fields = [
-            "url",
-            "tag_string",
-            "title",
-            "description",
-            "notes",
-            "unread",
-            "shared",
-            "auto_close",
-        ]
-
-    @property
-    def has_notes(self):
-        return self.initial.get("notes", None) or (
-            self.instance and self.instance.notes
-        )
-
-    def clean_url(self):
-        # When creating a bookmark, the service logic prevents duplicate URLs by
-        # updating the existing bookmark instead, which is also communicated in
-        # the form's UI. When editing a bookmark, there is no assumption that
-        # it would update a different bookmark if the URL is a duplicate, so
-        # raise a validation error in that case.
-        url = self.cleaned_data["url"]
-        if self.instance.pk:
-            is_duplicate = (
-                Bookmark.objects.filter(owner=self.instance.owner, url=url)
-                .exclude(pk=self.instance.pk)
-                .exists()
-            )
-            if is_duplicate:
-                raise forms.ValidationError("A bookmark with this URL already exists.")
-
-        return url
+        model = BookmarkBundle
+        fields = ["name", "search", "any_tags", "all_tags", "excluded_tags"]


 class BookmarkSearch:
@@ -202,34 +201,54 @@ class BookmarkSearch:
    FILTER_UNREAD_YES = "yes"
    FILTER_UNREAD_NO = "no"

-    params = ["q", "user", "sort", "shared", "unread"]
+    params = [
+        "q",
+        "user",
+        "bundle",
+        "sort",
+        "shared",
+        "unread",
+        "modified_since",
+        "added_since",
+    ]
    preferences = ["sort", "shared", "unread"]
    defaults = {
        "q": "",
        "user": "",
+        "bundle": None,
        "sort": SORT_ADDED_DESC,
        "shared": FILTER_SHARED_OFF,
        "unread": FILTER_UNREAD_OFF,
+        "modified_since": None,
+        "added_since": None,
    }

    def __init__(
        self,
        q: str = None,
        user: str = None,
+        bundle: BookmarkBundle = None,
        sort: str = None,
        shared: str = None,
        unread: str = None,
+        modified_since: str = None,
+        added_since: str = None,
        preferences: dict = None,
+        request: any = None,
    ):
        if not preferences:
            preferences = {}
        self.defaults = {**BookmarkSearch.defaults, **preferences}
+        self.request = request

        self.q = q or self.defaults["q"]
        self.user = user or self.defaults["user"]
+        self.bundle = bundle or self.defaults["bundle"]
        self.sort = sort or self.defaults["sort"]
        self.shared = shared or self.defaults["shared"]
        self.unread = unread or self.defaults["unread"]
+        self.modified_since = modified_since or self.defaults["modified_since"]
+        self.added_since = added_since or self.defaults["added_since"]

    def is_modified(self, param):
        value = self.__dict__[param]
@@ -257,7 +276,14 @@ class BookmarkSearch:

    @property
    def query_params(self):
-        return {param: self.__dict__[param] for param in self.modified_params}
+        query_params = {}
+        for param in self.modified_params:
+            value = self.__dict__[param]
+            if isinstance(value, models.Model):
+                query_params[param] = value.id
+            else:
+                query_params[param] = value
+        return query_params

    @property
    def preferences_dict(self):
@@ -266,14 +292,21 @@ class BookmarkSearch:
        }

    @staticmethod
-    def from_request(query_dict: QueryDict, preferences: dict = None):
+    def from_request(request: any, query_dict: QueryDict, preferences: dict = None):
        initial_values = {}
        for param in BookmarkSearch.params:
            value = query_dict.get(param)
            if value:
-                initial_values[param] = value
+                if param == "bundle":
+                    initial_values[param] = BookmarkBundle.objects.filter(
+                        owner=request.user, pk=value
+                    ).first()
+                else:
+                    initial_values[param] = value

-        return BookmarkSearch(**initial_values, preferences=preferences)
+        return BookmarkSearch(
+            **initial_values, preferences=preferences, request=request
+        )


 class BookmarkSearchForm(forms.Form):
@@ -296,9 +329,12 @@ class BookmarkSearchForm(forms.Form):

    q = forms.CharField()
    user = forms.ChoiceField(required=False)
+    bundle = forms.CharField(required=False)
    sort = forms.ChoiceField(choices=SORT_CHOICES)
    shared = forms.ChoiceField(choices=FILTER_SHARED_CHOICES, widget=forms.RadioSelect)
    unread = forms.ChoiceField(choices=FILTER_UNREAD_CHOICES, widget=forms.RadioSelect)
+    modified_since = forms.CharField(required=False)
+    added_since = forms.CharField(required=False)

    def __init__(
        self,
@@ -318,7 +354,11 @@ class BookmarkSearchForm(forms.Form):

        for param in search.params:
            # set initial values for modified params
-            self.fields[param].initial = search.__dict__[param]
+            value = search.__dict__.get(param)
+            if isinstance(value, models.Model):
+                self.fields[param].initial = value.id
+            else:
+                self.fields[param].initial = value

            # Mark non-editable modified fields as hidden. That way, templates
            # rendering a form can just loop over hidden_fields to ensure that
@@ -374,9 +414,7 @@ class UserProfile(models.Model):
        (TAG_GROUPING_ALPHABETICAL, "Alphabetical"),
        (TAG_GROUPING_DISABLED, "Disabled"),
    ]
-    user = models.OneToOneField(
-        get_user_model(), related_name="profile", on_delete=models.CASCADE
-    )
+    user = models.OneToOneField(User, related_name="profile", on_delete=models.CASCADE)
    theme = models.CharField(
        max_length=10, choices=THEME_CHOICES, blank=False, default=THEME_AUTO
    )
@@ -440,6 +478,8 @@ class UserProfile(models.Model):
        null=False, default=30, validators=[MinValueValidator(10)]
    )
    sticky_pagination = models.BooleanField(default=False, null=False)
+    collapse_side_panel = models.BooleanField(default=False, null=False)
+    hide_bundles = models.BooleanField(default=False, null=False)

    def save(self, *args, **kwargs):
        if self.custom_css:
@@ -479,16 +519,18 @@ class UserProfileForm(forms.ModelForm):
            "auto_tagging_rules",
            "items_per_page",
            "sticky_pagination",
+            "collapse_side_panel",
+            "hide_bundles",
        ]


-@receiver(post_save, sender=get_user_model())
+@receiver(post_save, sender=User)
 def create_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)


-@receiver(post_save, sender=get_user_model())
+@receiver(post_save, sender=User)
 def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()

@@ -497,7 +539,7 @@ class Toast(models.Model):
    key = models.CharField(max_length=50)
    message = models.TextField()
    acknowledged = models.BooleanField(default=False)
-    owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
+    owner = models.ForeignKey(User, on_delete=models.CASCADE)


 class FeedToken(models.Model):
@@ -507,7 +549,7 @@ class FeedToken(models.Model):

    key = models.CharField(max_length=40, primary_key=True)
    user = models.OneToOneField(
-        get_user_model(),
+        User,
        related_name="feed_token",
        on_delete=models.CASCADE,
    )
@@ -541,7 +583,7 @@ class GlobalSettings(models.Model):
        default=LANDING_PAGE_LOGIN,
    )
    guest_profile_user = models.ForeignKey(
-        get_user_model(), on_delete=models.SET_NULL, null=True, blank=True
+        User, on_delete=models.SET_NULL, null=True, blank=True
    )
    enable_link_prefetch = models.BooleanField(default=False, null=False)

--- a/bookmarks/queries.py
+++ b/bookmarks/queries.py
@@ -2,16 +2,26 @@ from typing import Optional

 from django.conf import settings
 from django.contrib.auth.models import User
+from django.core.exceptions import ValidationError
 from django.db.models import Q, QuerySet, Exists, OuterRef, Case, When, CharField
 from django.db.models.expressions import RawSQL
 from django.db.models.functions import Lower

-from bookmarks.models import Bookmark, BookmarkSearch, Tag, UserProfile
+from bookmarks.models import (
+    Bookmark,
+    BookmarkBundle,
+    BookmarkSearch,
+    Tag,
+    UserProfile,
+    parse_tag_string,
+)
 from bookmarks.utils import unique


 def query_bookmarks(
-    user: User, profile: UserProfile, search: BookmarkSearch
+    user: User,
+    profile: UserProfile,
+    search: BookmarkSearch,
 ) -> QuerySet:
    return _base_bookmarks_query(user, profile, search).filter(is_archived=False)

@@ -35,8 +45,51 @@ def query_shared_bookmarks(
    return _base_bookmarks_query(user, profile, search).filter(conditions)


+def _filter_bundle(query_set: QuerySet, bundle: BookmarkBundle) -> QuerySet:
+    # Search terms
+    search_terms = parse_query_string(bundle.search)["search_terms"]
+    for term in search_terms:
+        conditions = (
+            Q(title__icontains=term)
+            | Q(description__icontains=term)
+            | Q(notes__icontains=term)
+            | Q(url__icontains=term)
+        )
+        query_set = query_set.filter(conditions)
+
+    # Any tags - at least one tag must match
+    any_tags = parse_tag_string(bundle.any_tags, " ")
+    if len(any_tags) > 0:
+        tag_conditions = Q()
+        for tag in any_tags:
+            tag_conditions |= Q(tags__name__iexact=tag)
+
+        query_set = query_set.filter(
+            Exists(Bookmark.objects.filter(tag_conditions, id=OuterRef("id")))
+        )
+
+    # All tags - all tags must match
+    all_tags = parse_tag_string(bundle.all_tags, " ")
+    for tag in all_tags:
+        query_set = query_set.filter(tags__name__iexact=tag)
+
+    # Excluded tags - no tags must match
+    exclude_tags = parse_tag_string(bundle.excluded_tags, " ")
+    if len(exclude_tags) > 0:
+        tag_conditions = Q()
+        for tag in exclude_tags:
+            tag_conditions |= Q(tags__name__iexact=tag)
+        query_set = query_set.exclude(
+            Exists(Bookmark.objects.filter(tag_conditions, id=OuterRef("id")))
+        )
+
+    return query_set
+
+
 def _base_bookmarks_query(
-    user: Optional[User], profile: UserProfile, search: BookmarkSearch
+    user: Optional[User],
+    profile: UserProfile,
+    search: BookmarkSearch,
 ) -> QuerySet:
    query_set = Bookmark.objects

@@ -44,6 +97,22 @@ def _base_bookmarks_query(
    if user:
        query_set = query_set.filter(owner=user)

+    # Filter by modified_since if provided
+    if search.modified_since:
+        try:
+            query_set = query_set.filter(date_modified__gt=search.modified_since)
+        except ValidationError:
+            # If the date format is invalid, ignore the filter
+            pass
+
+    # Filter by added_since if provided
+    if search.added_since:
+        try:
+            query_set = query_set.filter(date_added__gt=search.added_since)
+        except ValidationError:
+            # If the date format is invalid, ignore the filter
+            pass
+
    # Split query into search terms and tags
    query = parse_query_string(search.q)

@@ -85,6 +154,10 @@ def _base_bookmarks_query(
    elif search.shared == BookmarkSearch.FILTER_SHARED_UNSHARED:
        query_set = query_set.filter(shared=False)

+    # Filter by bundle
+    if search.bundle:
+        query_set = _filter_bundle(query_set, search.bundle)
+
    # Sort
    if (
        search.sort == BookmarkSearch.SORT_TITLE_ASC
--- a/bookmarks/services/assets.py
+++ b/bookmarks/services/assets.py
@@ -0,0 +1,177 @@
+import gzip
+import logging
+import os
+import shutil
+
+from django.conf import settings
+from django.core.files.uploadedfile import UploadedFile
+from django.utils import timezone, formats
+
+from bookmarks.models import Bookmark, BookmarkAsset
+from bookmarks.services import singlefile
+
+MAX_ASSET_FILENAME_LENGTH = 192
+
+logger = logging.getLogger(__name__)
+
+
+def create_snapshot_asset(bookmark: Bookmark) -> BookmarkAsset:
+    date_created = timezone.now()
+    timestamp = formats.date_format(date_created, "SHORT_DATE_FORMAT")
+    asset = BookmarkAsset(
+        bookmark=bookmark,
+        asset_type=BookmarkAsset.TYPE_SNAPSHOT,
+        date_created=date_created,
+        content_type=BookmarkAsset.CONTENT_TYPE_HTML,
+        display_name=f"HTML snapshot from {timestamp}",
+        status=BookmarkAsset.STATUS_PENDING,
+    )
+    return asset
+
+
+def create_snapshot(asset: BookmarkAsset):
+    try:
+        # Create snapshot into temporary file
+        temp_filename = _generate_asset_filename(asset, asset.bookmark.url, "tmp")
+        temp_filepath = os.path.join(settings.LD_ASSET_FOLDER, temp_filename)
+        singlefile.create_snapshot(asset.bookmark.url, temp_filepath)
+
+        # Store as gzip in asset folder
+        filename = _generate_asset_filename(asset, asset.bookmark.url, "html.gz")
+        filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
+        with open(temp_filepath, "rb") as temp_file, gzip.open(
+            filepath, "wb"
+        ) as gz_file:
+            shutil.copyfileobj(temp_file, gz_file)
+
+        # Remove temporary file
+        os.remove(temp_filepath)
+
+        asset.status = BookmarkAsset.STATUS_COMPLETE
+        asset.file = filename
+        asset.gzip = True
+        asset.save()
+
+        asset.bookmark.latest_snapshot = asset
+        asset.bookmark.date_modified = timezone.now()
+        asset.bookmark.save()
+    except Exception as error:
+        asset.status = BookmarkAsset.STATUS_FAILURE
+        asset.save()
+        raise error
+
+
+def upload_snapshot(bookmark: Bookmark, html: bytes):
+    asset = create_snapshot_asset(bookmark)
+    filename = _generate_asset_filename(asset, asset.bookmark.url, "html.gz")
+    filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
+
+    with gzip.open(filepath, "wb") as gz_file:
+        gz_file.write(html)
+
+    # Only save the asset if the file was written successfully
+    asset.status = BookmarkAsset.STATUS_COMPLETE
+    asset.file = filename
+    asset.gzip = True
+    asset.save()
+
+    asset.bookmark.latest_snapshot = asset
+    asset.bookmark.date_modified = timezone.now()
+    asset.bookmark.save()
+
+    return asset
+
+
+def upload_asset(bookmark: Bookmark, upload_file: UploadedFile):
+    try:
+        asset = BookmarkAsset(
+            bookmark=bookmark,
+            asset_type=BookmarkAsset.TYPE_UPLOAD,
+            date_created=timezone.now(),
+            content_type=upload_file.content_type,
+            display_name=upload_file.name,
+            status=BookmarkAsset.STATUS_COMPLETE,
+            gzip=False,
+        )
+        name, extension = os.path.splitext(upload_file.name)
+
+        # automatically gzip the file if it is not already gzipped
+        if upload_file.content_type != "application/gzip":
+            filename = _generate_asset_filename(
+                asset, name, extension.lstrip(".") + ".gz"
+            )
+            filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
+            with gzip.open(filepath, "wb", compresslevel=9) as f:
+                for chunk in upload_file.chunks():
+                    f.write(chunk)
+            asset.gzip = True
+            asset.file = filename
+            asset.file_size = os.path.getsize(filepath)
+        else:
+            filename = _generate_asset_filename(asset, name, extension.lstrip("."))
+            filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
+            with open(filepath, "wb") as f:
+                for chunk in upload_file.chunks():
+                    f.write(chunk)
+            asset.file = filename
+            asset.file_size = upload_file.size
+
+        asset.save()
+
+        asset.bookmark.date_modified = timezone.now()
+        asset.bookmark.save()
+
+        logger.info(
+            f"Successfully uploaded asset file. bookmark={bookmark} file={upload_file.name}"
+        )
+        return asset
+    except Exception as e:
+        logger.error(
+            f"Failed to upload asset file. bookmark={bookmark} file={upload_file.name}",
+            exc_info=e,
+        )
+        raise e
+
+
+def remove_asset(asset: BookmarkAsset):
+    # If this asset is the latest_snapshot for a bookmark, try to find the next most recent snapshot
+    bookmark = asset.bookmark
+    if bookmark and bookmark.latest_snapshot == asset:
+        latest = (
+            BookmarkAsset.objects.filter(
+                bookmark=bookmark,
+                asset_type=BookmarkAsset.TYPE_SNAPSHOT,
+                status=BookmarkAsset.STATUS_COMPLETE,
+            )
+            .exclude(pk=asset.pk)
+            .order_by("-date_created")
+            .first()
+        )
+
+        bookmark.latest_snapshot = latest
+
+    asset.delete()
+    bookmark.date_modified = timezone.now()
+    bookmark.save()
+
+
+def _generate_asset_filename(
+    asset: BookmarkAsset, filename: str, extension: str
+) -> str:
+    def sanitize_char(char):
+        if char.isalnum() or char in ("-", "_", "."):
+            return char
+        else:
+            return "_"
+
+    formatted_datetime = asset.date_created.strftime("%Y-%m-%d_%H%M%S")
+    sanitized_filename = "".join(sanitize_char(char) for char in filename)
+
+    # Calculate the length of fixed parts of the final filename
+    non_filename_length = len(f"{asset.asset_type}_{formatted_datetime}_.{extension}")
+    # Calculate the maximum length for the dynamic part of the filename
+    max_filename_length = MAX_ASSET_FILENAME_LENGTH - non_filename_length
+    # Truncate the filename if necessary
+    sanitized_filename = sanitized_filename[:max_filename_length]
+
+    return f"{asset.asset_type}_{formatted_datetime}_{sanitized_filename}.{extension}"
--- a/bookmarks/services/auto_tagging.py
+++ b/bookmarks/services/auto_tagging.py
@@ -11,10 +11,18 @@ def get_tags(script: str, url: str):
        return result

    for line in script.lower().split("\n"):
-        if "#" in line:
-            i = line.index("#")
-            line = line[:i]
+        line = line.strip()

+        # Skip empty lines or lines that start with a comment
+        if not line or line.startswith("#"):
+            continue
+
+        # Remove trailing comment - only if # is preceded by whitespace
+        comment_match = re.search(r"\s+#", line)
+        if comment_match:
+            line = line[: comment_match.start()]
+
+        # Ignore lines that don't contain a URL and a tag
        parts = line.split()
        if len(parts) < 2:
            continue
@@ -36,6 +44,11 @@ def get_tags(script: str, url: str):
        ):
            continue

+        if parsed_pattern.fragment and not _fragment_matches(
+            parsed_pattern.fragment, parsed_url.fragment
+        ):
+            continue
+
        for tag in parts[1:]:
            result.add(tag)

@@ -65,3 +78,7 @@ def _qs_matches(expected_qs: str, actual_qs: str) -> bool:
                return False

    return True
+
+
+def _fragment_matches(expected_fragment: str, actual_fragment: str) -> bool:
+    return actual_fragment.startswith(expected_fragment)
--- a/bookmarks/services/bookmarks.py
+++ b/bookmarks/services/bookmarks.py
@@ -1,22 +1,23 @@
 import logging
-import os
 from typing import Union

-from django.conf import settings
-from django.contrib.auth.models import User
-from django.core.files.uploadedfile import UploadedFile
 from django.utils import timezone

-from bookmarks.models import Bookmark, BookmarkAsset, parse_tag_string
+from bookmarks.models import Bookmark, User, parse_tag_string
+from bookmarks.services import auto_tagging
 from bookmarks.services import tasks
 from bookmarks.services import website_loader
-from bookmarks.services import auto_tagging
 from bookmarks.services.tags import get_or_create_tags

 logger = logging.getLogger(__name__)


-def create_bookmark(bookmark: Bookmark, tag_string: str, current_user: User):
+def create_bookmark(
+    bookmark: Bookmark,
+    tag_string: str,
+    current_user: User,
+    disable_html_snapshot: bool = False,
+):
    # If URL is already bookmarked, then update it
    existing_bookmark: Bookmark = Bookmark.objects.filter(
        owner=current_user, url=bookmark.url
@@ -42,7 +43,10 @@ def create_bookmark(bookmark: Bookmark, tag_string: str, current_user: User):
    # Load preview image
    tasks.load_preview_image(current_user, bookmark)
    # Create HTML snapshot
-    if current_user.profile.enable_automatic_html_snapshots:
+    if (
+        current_user.profile.enable_automatic_html_snapshots
+        and not disable_html_snapshot
+    ):
        tasks.create_html_snapshot(bookmark)

    return bookmark
@@ -193,44 +197,24 @@ def unshare_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
    )


-def _generate_upload_asset_filename(asset: BookmarkAsset, filename: str):
-    formatted_datetime = asset.date_created.strftime("%Y-%m-%d_%H%M%S")
-    return f"{asset.asset_type}_{formatted_datetime}_{filename}"
-
-
-def upload_asset(bookmark: Bookmark, upload_file: UploadedFile) -> BookmarkAsset:
-    asset = BookmarkAsset(
-        bookmark=bookmark,
-        asset_type=BookmarkAsset.TYPE_UPLOAD,
-        content_type=upload_file.content_type,
-        display_name=upload_file.name,
-        status=BookmarkAsset.STATUS_PENDING,
-        gzip=False,
+def refresh_bookmarks_metadata(bookmark_ids: [Union[int, str]], current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+    owned_bookmarks = Bookmark.objects.filter(
+        owner=current_user, id__in=sanitized_bookmark_ids
    )
-    asset.save()

-    try:
-        filename = _generate_upload_asset_filename(asset, upload_file.name)
-        filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
-        with open(filepath, "wb") as f:
-            for chunk in upload_file.chunks():
-                f.write(chunk)
-        asset.status = BookmarkAsset.STATUS_COMPLETE
-        asset.file = filename
-        asset.file_size = upload_file.size
-        logger.info(
-            f"Successfully uploaded asset file. bookmark={bookmark} file={upload_file.name}"
-        )
-    except Exception as e:
-        logger.error(
-            f"Failed to upload asset file. bookmark={bookmark} file={upload_file.name}",
-            exc_info=e,
-        )
-        asset.status = BookmarkAsset.STATUS_FAILURE
+    for bookmark in owned_bookmarks:
+        tasks.refresh_metadata(bookmark)
+        tasks.load_preview_image(current_user, bookmark)

-    asset.save()

-    return asset
+def create_html_snapshots(bookmark_ids: list[Union[int, str]], current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+    owned_bookmarks = Bookmark.objects.filter(
+        owner=current_user, id__in=sanitized_bookmark_ids
+    )
+
+    tasks.create_html_snapshots(owned_bookmarks)


 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):
--- a/bookmarks/services/bundles.py
+++ b/bookmarks/services/bundles.py
@@ -0,0 +1,37 @@
+from django.db.models import Max
+
+from bookmarks.models import BookmarkBundle, User
+
+
+def create_bundle(bundle: BookmarkBundle, current_user: User):
+    bundle.owner = current_user
+    if bundle.order is None:
+        max_order_result = BookmarkBundle.objects.filter(owner=current_user).aggregate(
+            Max("order", default=-1)
+        )
+        bundle.order = max_order_result["order__max"] + 1
+    bundle.save()
+    return bundle
+
+
+def move_bundle(bundle_to_move: BookmarkBundle, new_order: int):
+    user_bundles = list(
+        BookmarkBundle.objects.filter(owner=bundle_to_move.owner).order_by("order")
+    )
+
+    if new_order != user_bundles.index(bundle_to_move):
+        user_bundles.remove(bundle_to_move)
+        user_bundles.insert(new_order, bundle_to_move)
+        for bundle_index, bundle in enumerate(user_bundles):
+            bundle.order = bundle_index
+
+        BookmarkBundle.objects.bulk_update(user_bundles, ["order"])
+
+
+def delete_bundle(bundle: BookmarkBundle):
+    bundle.delete()
+
+    user_bundles = BookmarkBundle.objects.filter(owner=bundle.owner).order_by("order")
+    for index, user_bundle in enumerate(user_bundles):
+        user_bundle.order = index
+    BookmarkBundle.objects.bulk_update(user_bundles, ["order"])
--- a/bookmarks/services/exporter.py
+++ b/bookmarks/services/exporter.py
@@ -35,7 +35,7 @@ def append_bookmark(doc: BookmarkDocument, bookmark: Bookmark):
        desc += f"[linkding-notes]{html.escape(bookmark.notes)}[/linkding-notes]"
    tag_names = bookmark.tag_names
    if bookmark.is_archived:
-        tag_names.append("linkding:archived")
+        tag_names.append("linkding:bookmarks.archived")
    tags = ",".join(tag_names)
    toread = "1" if bookmark.unread else "0"
    private = "0" if bookmark.shared else "1"
--- a/bookmarks/services/importer.py
+++ b/bookmarks/services/importer.py
@@ -96,6 +96,13 @@ def _create_missing_tags(netscape_bookmarks: List[NetscapeBookmark], user: User)

    for netscape_bookmark in netscape_bookmarks:
        for tag_name in netscape_bookmark.tag_names:
+            # Skip tag names that exceed the maximum allowed length
+            if len(tag_name) > 64:
+                logger.warning(
+                    f"Ignoring tag '{tag_name}' (length {len(tag_name)}) as it exceeds maximum length of 64 characters"
+                )
+                continue
+
            tag = tag_cache.get(tag_name)
            if not tag:
                tag = Tag(name=tag_name, owner=user)
--- a/bookmarks/services/parser.py
+++ b/bookmarks/services/parser.py
@@ -62,9 +62,9 @@ class BookmarkParser(HTMLParser):
    def handle_start_a(self, attrs: Dict[str, str]):
        vars(self).update(attrs)
        tag_names = parse_tag_string(self.tags)
-        archived = "linkding:archived" in self.tags
+        archived = "linkding:bookmarks.archived" in self.tags
        try:
-            tag_names.remove("linkding:archived")
+            tag_names.remove("linkding:bookmarks.archived")
        except ValueError:
            pass

--- a/bookmarks/services/singlefile.py
+++ b/bookmarks/services/singlefile.py
@@ -1,8 +1,6 @@
-import gzip
 import logging
 import os
 import shlex
-import shutil
 import signal
 import subprocess

@@ -18,27 +16,20 @@ logger = logging.getLogger(__name__)

 def create_snapshot(url: str, filepath: str):
    singlefile_path = settings.LD_SINGLEFILE_PATH
+
    # parse options to list of arguments
    ublock_options = shlex.split(settings.LD_SINGLEFILE_UBLOCK_OPTIONS)
    custom_options = shlex.split(settings.LD_SINGLEFILE_OPTIONS)
-    temp_filepath = filepath + ".tmp"
    # concat lists
-    args = [singlefile_path] + ublock_options + custom_options + [url, temp_filepath]
+    args = [singlefile_path] + ublock_options + custom_options + [url, filepath]
    try:
        # Use start_new_session=True to create a new process group
        process = subprocess.Popen(args, start_new_session=True)
        process.wait(timeout=settings.LD_SINGLEFILE_TIMEOUT_SEC)

        # check if the file was created
-        if not os.path.exists(temp_filepath):
+        if not os.path.exists(filepath):
            raise SingleFileError("Failed to create snapshot")
-
-        with open(temp_filepath, "rb") as raw_file, gzip.open(
-            filepath, "wb"
-        ) as gz_file:
-            shutil.copyfileobj(raw_file, gz_file)
-
-        os.remove(temp_filepath)
    except subprocess.TimeoutExpired:
        # First try to terminate properly
        try:
--- a/bookmarks/services/tasks.py
+++ b/bookmarks/services/tasks.py
@@ -1,22 +1,20 @@
 import functools
 import logging
-import os
 from typing import List

 import waybackpy
 from django.conf import settings
-from django.contrib.auth import get_user_model
 from django.contrib.auth.models import User
 from django.db.models import Q
-from django.utils import timezone, formats
+from django.utils import timezone
 from huey import crontab
 from huey.contrib.djhuey import HUEY as huey
 from huey.exceptions import TaskLockedException
 from waybackpy.exceptions import WaybackError, TooManyRequestsError

 from bookmarks.models import Bookmark, BookmarkAsset, UserProfile
-from bookmarks.services import favicon_loader, singlefile, preview_image_loader
-from bookmarks.services.website_loader import DEFAULT_USER_AGENT
+from bookmarks.services import assets, favicon_loader, preview_image_loader
+from bookmarks.services.website_loader import DEFAULT_USER_AGENT, load_website_metadata

 logger = logging.getLogger(__name__)

@@ -159,7 +157,7 @@ def schedule_bookmarks_without_favicons(user: User):

@task()
 def _schedule_bookmarks_without_favicons_task(user_id: int):
-    user = get_user_model().objects.get(id=user_id)
+    user = User.objects.get(id=user_id)
    bookmarks = Bookmark.objects.filter(favicon_file__exact="", owner=user)

    # TODO: Implement bulk task creation
@@ -175,7 +173,7 @@ def schedule_refresh_favicons(user: User):

@task()
 def _schedule_refresh_favicons_task(user_id: int):
-    user = get_user_model().objects.get(id=user_id)
+    user = User.objects.get(id=user_id)
    bookmarks = Bookmark.objects.filter(owner=user)

    # TODO: Implement bulk task creation
@@ -214,7 +212,7 @@ def schedule_bookmarks_without_previews(user: User):

@task()
 def _schedule_bookmarks_without_previews_task(user_id: int):
-    user = get_user_model().objects.get(id=user_id)
+    user = User.objects.get(id=user_id)
    bookmarks = Bookmark.objects.filter(
        Q(preview_image_file__exact=""),
        owner=user,
@@ -228,6 +226,31 @@ def _schedule_bookmarks_without_previews_task(user_id: int):
            logging.exception(exc)


+def refresh_metadata(bookmark: Bookmark):
+    if not settings.LD_DISABLE_BACKGROUND_TASKS:
+        _refresh_metadata_task(bookmark.id)
+
+
+@task()
+def _refresh_metadata_task(bookmark_id: int):
+    try:
+        bookmark = Bookmark.objects.get(id=bookmark_id)
+    except Bookmark.DoesNotExist:
+        return
+
+    logger.info(f"Refresh metadata for bookmark. url={bookmark.url}")
+
+    metadata = load_website_metadata(bookmark.url)
+    if metadata.title:
+        bookmark.title = metadata.title
+    if metadata.description:
+        bookmark.description = metadata.description
+    bookmark.date_modified = timezone.now()
+
+    bookmark.save()
+    logger.info(f"Successfully refreshed metadata for bookmark. url={bookmark.url}")
+
+
 def is_html_snapshot_feature_active() -> bool:
    return settings.LD_ENABLE_SNAPSHOTS and not settings.LD_DISABLE_BACKGROUND_TASKS

@@ -236,7 +259,7 @@ def create_html_snapshot(bookmark: Bookmark):
    if not is_html_snapshot_feature_active():
        return

-    asset = _create_snapshot_asset(bookmark)
+    asset = assets.create_snapshot_asset(bookmark)
    asset.save()


@@ -246,47 +269,12 @@ def create_html_snapshots(bookmark_list: List[Bookmark]):

    assets_to_create = []
    for bookmark in bookmark_list:
-        asset = _create_snapshot_asset(bookmark)
+        asset = assets.create_snapshot_asset(bookmark)
        assets_to_create.append(asset)

    BookmarkAsset.objects.bulk_create(assets_to_create)


-MAX_SNAPSHOT_FILENAME_LENGTH = 192
-
-
-def _create_snapshot_asset(bookmark: Bookmark) -> BookmarkAsset:
-    timestamp = formats.date_format(timezone.now(), "SHORT_DATE_FORMAT")
-    asset = BookmarkAsset(
-        bookmark=bookmark,
-        asset_type=BookmarkAsset.TYPE_SNAPSHOT,
-        content_type="text/html",
-        display_name=f"HTML snapshot from {timestamp}",
-        status=BookmarkAsset.STATUS_PENDING,
-    )
-    return asset
-
-
-def _generate_snapshot_filename(asset: BookmarkAsset) -> str:
-    def sanitize_char(char):
-        if char.isalnum() or char in ("-", "_", "."):
-            return char
-        else:
-            return "_"
-
-    formatted_datetime = asset.date_created.strftime("%Y-%m-%d_%H%M%S")
-    sanitized_url = "".join(sanitize_char(char) for char in asset.bookmark.url)
-
-    # Calculate the length of the non-URL parts of the filename
-    non_url_length = len(f"{asset.asset_type}{formatted_datetime}__.html.gz")
-    # Calculate the maximum length for the URL part
-    max_url_length = MAX_SNAPSHOT_FILENAME_LENGTH - non_url_length
-    # Truncate the URL if necessary
-    sanitized_url = sanitized_url[:max_url_length]
-
-    return f"{asset.asset_type}_{formatted_datetime}_{sanitized_url}.html.gz"
-
-
 # singe-file does not support running multiple instances in parallel, so we can
 # not queue up multiple snapshot tasks at once. Instead, schedule a periodic
 # task that grabs a number of pending assets and creates snapshots for them in
@@ -313,13 +301,8 @@ def _create_html_snapshot_task(asset_id: int):
    logger.info(f"Create HTML snapshot for bookmark. url={asset.bookmark.url}")

    try:
-        filename = _generate_snapshot_filename(asset)
-        filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
-        singlefile.create_snapshot(asset.bookmark.url, filepath)
-        asset.status = BookmarkAsset.STATUS_COMPLETE
-        asset.file = filename
-        asset.gzip = True
-        asset.save()
+        assets.create_snapshot(asset)
+
        logger.info(
            f"Successfully created HTML snapshot for bookmark. url={asset.bookmark.url}"
        )
@@ -328,8 +311,6 @@ def _create_html_snapshot_task(asset_id: int):
            f"Failed to HTML snapshot for bookmark. url={asset.bookmark.url}",
            exc_info=error,
        )
-        asset.status = BookmarkAsset.STATUS_FAILURE
-        asset.save()


 def create_missing_html_snapshots(user: User) -> int:
--- a/bookmarks/services/website_loader.py
+++ b/bookmarks/services/website_loader.py
@@ -27,10 +27,20 @@ class WebsiteMetadata:
        }


+def load_website_metadata(url: str, ignore_cache: bool = False):
+    if ignore_cache:
+        return _load_website_metadata(url)
+    return _load_website_metadata_cached(url)
+
+
 # Caching metadata avoids scraping again when saving bookmarks, in case the
 # metadata was already scraped to show preview values in the bookmark form
@lru_cache(maxsize=10)
-def load_website_metadata(url: str):
+def _load_website_metadata_cached(url: str):
+    return _load_website_metadata(url)
+
+
+def _load_website_metadata(url: str):
    title = None
    description = None
    preview_image = None
--- a/bookmarks/settings/init.py
+++ b/bookmarks/settings/init.py
--- a/bookmarks/settings/base.py
+++ b/bookmarks/settings/base.py
@@ -58,7 +58,7 @@ MIDDLEWARE = [
    "django.middleware.locale.LocaleMiddleware",
 ]

-ROOT_URLCONF = "siteroot.urls"
+ROOT_URLCONF = "bookmarks.urls"

 TEMPLATES = [
    {
@@ -80,7 +80,7 @@ TEMPLATES = [

 DEFAULT_AUTO_FIELD = "django.db.models.AutoField"

-WSGI_APPLICATION = "siteroot.wsgi.application"
+WSGI_APPLICATION = "bookmarks.wsgi.application"

 # Password validation
 # https://docs.djangoproject.com/en/2.2/ref/settings/#auth-password-validators
@@ -116,8 +116,6 @@ TIME_ZONE = os.getenv("TZ", "UTC")

 USE_I18N = True

-USE_L10N = True
-
 USE_TZ = True

 # Static files (CSS, JavaScript, Images)
@@ -131,7 +129,7 @@ STATIC_ROOT = os.path.join(BASE_DIR, "static")
 # REST framework
 REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": [
-        "rest_framework.authentication.TokenAuthentication",
+        "bookmarks.api.auth.LinkdingTokenAuthentication",
        "rest_framework.authentication.SessionAuthentication",
    ],
    "DEFAULT_PERMISSION_CLASSES": ["rest_framework.permissions.IsAuthenticated"],
@@ -146,6 +144,7 @@ ALLOW_REGISTRATION = False
 LD_DISABLE_URL_VALIDATION = os.getenv("LD_DISABLE_URL_VALIDATION", False) in (
    True,
    "True",
+    "true",
    "1",
 )

@@ -153,6 +152,7 @@ LD_DISABLE_URL_VALIDATION = os.getenv("LD_DISABLE_URL_VALIDATION", False) in (
 LD_DISABLE_BACKGROUND_TASKS = os.getenv("LD_DISABLE_BACKGROUND_TASKS", False) in (
    True,
    "True",
+    "true",
    "1",
 )

@@ -179,7 +179,7 @@ HUEY = {


 # Enable OICD support if configured
-LD_ENABLE_OIDC = os.getenv("LD_ENABLE_OIDC", False) in (True, "True", "1")
+LD_ENABLE_OIDC = os.getenv("LD_ENABLE_OIDC", False) in (True, "True", "true", "1")

 AUTHENTICATION_BACKENDS = ["django.contrib.auth.backends.ModelBackend"]

@@ -194,11 +194,18 @@ if LD_ENABLE_OIDC:
    OIDC_RP_CLIENT_ID = os.getenv("OIDC_RP_CLIENT_ID")
    OIDC_RP_CLIENT_SECRET = os.getenv("OIDC_RP_CLIENT_SECRET")
    OIDC_RP_SIGN_ALGO = os.getenv("OIDC_RP_SIGN_ALGO", "RS256")
-    OIDC_USE_PKCE = os.getenv("OIDC_USE_PKCE", True) in (True, "True", "1")
-    OIDC_VERIFY_SSL = os.getenv("OIDC_VERIFY_SSL", True) in (True, "True", "1")
+    OIDC_RP_SCOPES = os.getenv("OIDC_RP_SCOPES", "openid email profile")
+    OIDC_USE_PKCE = os.getenv("OIDC_USE_PKCE", True) in (True, "True", "true", "1")
+    OIDC_VERIFY_SSL = os.getenv("OIDC_VERIFY_SSL", True) in (True, "True", "true", "1")
+    OIDC_USERNAME_CLAIM = os.getenv("OIDC_USERNAME_CLAIM", "email")

 # Enable authentication proxy support if configured
-LD_ENABLE_AUTH_PROXY = os.getenv("LD_ENABLE_AUTH_PROXY", False) in (True, "True", "1")
+LD_ENABLE_AUTH_PROXY = os.getenv("LD_ENABLE_AUTH_PROXY", False) in (
+    True,
+    "True",
+    "true",
+    "1",
+)
 LD_AUTH_PROXY_USERNAME_HEADER = os.getenv(
    "LD_AUTH_PROXY_USERNAME_HEADER", "REMOTE_USER"
 )
@@ -265,6 +272,7 @@ LD_FAVICON_FOLDER = os.path.join(BASE_DIR, "data", "favicons")
 LD_ENABLE_REFRESH_FAVICONS = os.getenv("LD_ENABLE_REFRESH_FAVICONS", True) in (
    True,
    "True",
+    "true",
    "1",
 )

@@ -286,6 +294,13 @@ LD_ASSET_FOLDER = os.path.join(BASE_DIR, "data", "assets")
 LD_ENABLE_SNAPSHOTS = os.getenv("LD_ENABLE_SNAPSHOTS", False) in (
    True,
    "True",
+    "true",
+    "1",
+)
+LD_DISABLE_ASSET_UPLOAD = os.getenv("LD_DISABLE_ASSET_UPLOAD", False) in (
+    True,
+    "True",
+    "true",
    "1",
 )
 LD_SINGLEFILE_PATH = os.getenv("LD_SINGLEFILE_PATH", "single-file")
--- a/bookmarks/settings/custom.py
+++ b/bookmarks/settings/custom.py
--- a/bookmarks/settings/dev.py
+++ b/bookmarks/settings/dev.py
--- a/bookmarks/settings/prod.py
+++ b/bookmarks/settings/prod.py
--- a/bookmarks/static/robots.txt
+++ b/bookmarks/static/robots.txt
@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /
--- a/bookmarks/styles/bookmark-details.css
+++ b/bookmarks/styles/bookmark-details.css
@@ -1,5 +1,13 @@
 /* Common styles */
 .bookmark-details {
+  .title {
+    word-break: break-word;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    -webkit-line-clamp: 5;
+    overflow: hidden;
+  }
+
  & .weblinks {
    display: flex;
    flex-direction: column;
@@ -36,57 +44,22 @@
    }
  }

-  & dl {
-    margin-bottom: 0;
+  & .sections section {
+    margin-top: var(--unit-4);
+  }
+
+  & .sections h3 {
+    margin-bottom: var(--unit-2);
+    font-size: var(--font-size);
+    font-weight: bold;
  }

  & .assets {
    margin-top: var(--unit-2);

-    & .asset {
-      display: flex;
-      align-items: center;
-      gap: var(--unit-2);
-      padding: var(--unit-2) 0;
-      border-top: var(--unit-o) solid var(--secondary-border-color);
-    }
-
-    & .asset:last-child {
-      border-bottom: var(--unit-o) solid var(--secondary-border-color);
-    }
-
-    & .asset-icon {
-      display: flex;
-      align-items: center;
-      justify-content: center;
-    }
-
-    & .asset-text {
-      flex: 1 1 0;
-      gap: var(--unit-2);
-      min-width: 0;
-      display: flex;
-    }
-
-    & .asset-text .truncate {
-      flex-shrink: 1;
-    }
-
-    & .asset-text .filesize {
+    & .filesize {
      color: var(--tertiary-text-color);
    }
-
-    & .asset-actions {
-      display: flex;
-      gap: var(--unit-4);
-      align-items: center;
-
-      & .btn.btn-link {
-        height: unset;
-        padding: 0;
-        border: none;
-      }
-    }
  }

  & .assets-actions {
--- a/bookmarks/styles/bookmark-form.css
+++ b/bookmarks/styles/bookmark-form.css
@@ -1,5 +1,5 @@
 .bookmarks-form-page {
-  section {
+  main {
    max-width: 550px;
    margin: 0 auto;
  }
@@ -15,14 +15,23 @@
    visibility: hidden;
  }

-  & .form-group .clear-button {
-    display: none;
+  & .form-group .suffix-button {
    padding: 0;
    border: none;
    height: auto;
    font-size: var(--font-size-sm);
  }

+  & .form-group .clear-button,
+  & .form-group #refresh-button {
+    display: none;
+  }
+
+  & .form-group input.modified,
+  & .form-group textarea.modified {
+    background: var(--primary-color-shade);
+  }
+
  & .form-input-hint.bookmark-exists {
    display: none;
    color: var(--warning-color);
--- a/bookmarks/styles/bookmark-page.css
+++ b/bookmarks/styles/bookmark-page.css
@@ -10,8 +10,38 @@
 }

 /* Bookmark page grid */
-.bookmarks-page.grid {
-  grid-gap: var(--unit-9);
+.bookmarks-page {
+  &.grid {
+    grid-gap: var(--unit-9);
+  }
+
+  [ld-filter-drawer-trigger] {
+    display: none;
+  }
+
+  @media (max-width: 840px) {
+    section.side-panel {
+      display: none;
+    }
+
+    [ld-filter-drawer-trigger] {
+      display: inline-block;
+    }
+  }
+
+  &.collapse-side-panel {
+    main {
+      grid-column: span var(--grid-columns);
+    }
+
+    .side-panel {
+      display: none;
+    }
+
+    [ld-filter-drawer-trigger] {
+      display: inline-block;
+    }
+  }
 }

 /* Bookmark area header controls */
@@ -349,6 +379,26 @@ li[ld-bookmark-item] {
  }
 }

+.bundle-menu {
+  list-style-type: none;
+  margin: 0 0 var(--unit-6);
+
+  .bundle-menu-item {
+    margin: 0;
+    margin-bottom: var(--unit-2);
+  }
+
+  .bundle-menu-item a {
+    padding: var(--unit-1) var(--unit-2);
+    border-radius: var(--border-radius);
+  }
+
+  .bundle-menu-item.selected a {
+    background: var(--primary-color);
+    color: var(--contrast-text-color);
+  }
+}
+
 .tag-cloud {
  /* Increase line-height for better separation within / between items */
  line-height: 1.1rem;
@@ -429,7 +479,7 @@ ul.bookmark-list {

  /* Hide section border when bulk edit bar is opened, otherwise borders overlap in dark mode due to using contrast colors */

-  &.active section:first-of-type .content-area-header {
+  &.active .main .section-header {
    border-bottom-color: transparent;
  }

--- a/bookmarks/styles/bundles.css
+++ b/bookmarks/styles/bundles.css
@@ -0,0 +1,34 @@
+.bundles-page {
+  h1 {
+    font-size: var(--font-size-lg);
+    margin-bottom: var(--unit-6);
+  }
+
+  .item-list {
+    .list-item .list-item-icon {
+      cursor: grab;
+    }
+
+    .list-item.drag-start {
+      --secondary-border-color: transparent;
+    }
+
+    .list-item.dragging > * {
+      visibility: hidden;
+    }
+  }
+}
+
+.bundles-editor-page {
+  &.grid {
+    gap: var(--unit-9);
+  }
+
+  .form-footer {
+    position: sticky;
+    bottom: 0;
+    border-top: solid 1px var(--secondary-border-color);
+    background: var(--body-color);
+    padding: var(--unit-3) 0;
+  }
+}
--- a/bookmarks/styles/components.css
+++ b/bookmarks/styles/components.css
@@ -1,34 +1,31 @@
 /* Shared components */

-/* Content area component */
-section.content-area {
-  h2 {
+/* Section header component */
+.section-header {
+  border-bottom: solid 1px var(--secondary-border-color);
+  display: flex;
+  flex-wrap: wrap;
+  column-gap: var(--unit-5);
+  padding-bottom: var(--unit-2);
+  margin-bottom: var(--unit-4);
+
+  h1,
+  h2,
+  h3 {
    font-size: var(--font-size-lg);
+    flex: 0 0 auto;
+    line-height: var(--unit-9);
+    margin: 0;
  }

-  .content-area-header {
-    border-bottom: solid 1px var(--secondary-border-color);
+  .header-controls {
+    flex: 1 1 0;
    display: flex;
-    flex-wrap: wrap;
-    column-gap: var(--unit-5);
-    padding-bottom: var(--unit-2);
-    margin-bottom: var(--unit-4);
-
-    h2 {
-      flex: 0 0 auto;
-      line-height: var(--unit-9);
-      margin: 0;
-    }
-
-    .header-controls {
-      flex: 1 1 0;
-      display: flex;
-    }
  }
 }

@media (max-width: 600px) {
-  section.content-area .content-area-header {
+  .section-header:not(.no-wrap) {
    flex-direction: column;
  }
 }
@@ -63,3 +60,60 @@ span.confirmation {
 .turbo-progress-bar {
  background-color: var(--primary-color);
 }
+
+/* Messages */
+.message-list {
+  margin: var(--unit-4) 0;
+
+  .toast {
+    margin-bottom: var(--unit-2);
+  }
+
+  .toast a.btn-clear:visited {
+    color: currentColor;
+  }
+}
+
+/* Item list */
+.item-list {
+  & .list-item {
+    display: flex;
+    align-items: center;
+    gap: var(--unit-2);
+    padding: var(--unit-2) 0;
+    border-top: var(--unit-o) solid var(--secondary-border-color);
+  }
+
+  & .list-item:last-child {
+    border-bottom: var(--unit-o) solid var(--secondary-border-color);
+  }
+
+  & .list-item-icon {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }
+
+  & .list-item-text {
+    flex: 1 1 0;
+    gap: var(--unit-2);
+    min-width: 0;
+    display: flex;
+  }
+
+  & .list-item-text .truncate {
+    flex-shrink: 1;
+  }
+
+  & .list-item-actions {
+    display: flex;
+    gap: var(--unit-4);
+    align-items: center;
+
+    & .btn.btn-link {
+      height: unset;
+      padding: 0;
+      border: none;
+    }
+  }
+}
--- a/bookmarks/styles/layout.css
+++ b/bookmarks/styles/layout.css
@@ -11,29 +11,19 @@ body {
 header {
  margin-bottom: var(--unit-9);

-  .logo {
+  a.app-link:hover {
+    text-decoration: none;
+  }
+
+  .app-logo {
    width: 28px;
    height: 28px;
  }

-  a:hover {
-    text-decoration: none;
-  }
-
-  h1 {
-    margin: 0 0 0 var(--unit-3);
+  .app-name {
+    margin-left: var(--unit-3);
    font-size: var(--font-size-lg);
-  }
-}
-
-header .toasts {
-  margin-bottom: 20px;
-
-  .toast {
-    margin-bottom: 0.4rem;
-  }
-
-  .toast a.btn-clear:visited {
-    color: currentColor;
+    font-weight: 500;
+    line-height: 1.2;
  }
 }
--- a/bookmarks/styles/settings.css
+++ b/bookmarks/styles/settings.css
@@ -1,8 +1,14 @@
 .settings-page {
-  section.content-area {
+  h1 {
+    font-size: var(--font-size-xl);
+    margin-bottom: var(--unit-6);
+  }
+
+  section {
    margin-bottom: var(--unit-10);

    h2 {
+      font-size: var(--font-size-lg);
      margin-bottom: var(--unit-3);
    }
  }
--- a/bookmarks/styles/theme-light.css
+++ b/bookmarks/styles/theme-light.css
@@ -28,3 +28,4 @@
@import "markdown.css";
@import "reader-mode.css";
@import "settings.css";
+@import "bundles.css";
--- a/bookmarks/styles/theme/base.css
+++ b/bookmarks/styles/theme/base.css
@@ -10,7 +10,6 @@ html {
  font-size: var(--html-font-size);
  line-height: var(--html-line-height);
  -webkit-tap-highlight-color: transparent;
-  scrollbar-gutter: stable;
 }

 /* Reserve space for vert. scrollbar to avoid layout shifting when scrollbars are added */
--- a/bookmarks/styles/theme/dropdowns.css
+++ b/bookmarks/styles/theme/dropdowns.css
@@ -1,5 +1,7 @@
 /* Dropdown */
 .dropdown {
+  --dropdown-focus-display: block;
+
  display: inline-block;
  position: relative;

@@ -20,9 +22,13 @@
    }
  }

-  &.active .menu,
-  .dropdown-toggle:focus + .menu,
-  .menu:hover {
+  &:focus-within .menu {
+    /* Use custom CSS property to allow disabling opening on focus when using JS */
+    display: var(--dropdown-focus-display);
+  }
+
+  &.active .menu {
+    /* Always show menu when class is added through JS */
    display: block;
  }

--- a/bookmarks/styles/theme/forms.css
+++ b/bookmarks/styles/theme/forms.css
@@ -224,12 +224,13 @@ textarea.form-input {
  position: relative;

  input {
-    clip: rect(0, 0, 0, 0);
-    height: 1px;
-    margin: -1px;
-    overflow: hidden;
+    opacity: 0;
    position: absolute;
-    width: 1px;
+    top: calc((var(--control-size-sm) - var(--control-icon-size)) / 2);
+    left: 0;
+    height: var(--control-icon-size);
+    width: var(--control-icon-size);
+    cursor: pointer;

    &:focus-visible + .form-icon {
      outline: var(--focus-outline);
@@ -243,9 +244,9 @@ textarea.form-input {
  }

  .form-icon {
+    pointer-events: none;
    border: var(--border-width) solid var(--checkbox-border-color);
    box-shadow: var(--input-box-shadow);
-    cursor: pointer;
    display: inline-block;
    position: absolute;
    transition:
--- a/bookmarks/styles/theme/modals.css
+++ b/bookmarks/styles/theme/modals.css
@@ -62,13 +62,14 @@
  gap: var(--unit-4);
  max-height: 75vh;
  max-width: var(--control-width-md);
-  padding: var(--unit-6);
  width: 100%;

  & .modal-header {
    display: flex;
    align-items: flex-start;
    gap: var(--unit-2);
+    padding: var(--unit-6);
+    padding-bottom: 0;
    color: var(--text-color);

    & h2 {
@@ -78,7 +79,7 @@
      margin: 0;
    }

-    & button.close {
+    & .close {
      background: none;
      border: none;
      padding: 0;
@@ -95,10 +96,53 @@

  & .modal-body {
    overflow-y: auto;
-    position: relative;
+    padding: 0 var(--unit-6);
+  }
+
+  & .modal-body:not(:has(+ .modal-footer)) {
+    margin-bottom: var(--unit-6);
  }

  & .modal-footer {
+    padding: var(--unit-6);
+    padding-top: 0;
    text-align: right;
  }
 }
+
+.modal.drawer {
+  display: block;
+
+  & .modal-container {
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: 400px;
+    max-width: 100%;
+    height: 100%;
+    max-height: 100%;
+    border: none;
+    border-left: solid 1px var(--modal-container-border-color);
+    border-radius: 0;
+    transform: translateX(100%);
+    animation: fade-in 0.25s ease 1;
+    transition: transform 0.25s ease;
+  }
+
+  &.active {
+    & .modal-container {
+      transform: translateX(0);
+    }
+  }
+
+  &.active.closing {
+    & .modal-container {
+      animation: fade-out 0.25s ease 1;
+      transform: translateX(100%);
+    }
+  }
+}
+
+.scroll-lock {
+  overflow: hidden !important;
+}
--- a/bookmarks/styles/theme/utilities.css
+++ b/bookmarks/styles/theme/utilities.css
@@ -242,6 +242,14 @@
  margin-top: var(--unit-4) !important;
 }

+.ml-auto {
+  margin-left: auto;
+}
+
+.mr-auto {
+  margin-right: auto;
+}
+
 .mx-auto {
  margin-left: auto;
  margin-right: auto;
--- a/bookmarks/styles/theme/variables.css
+++ b/bookmarks/styles/theme/variables.css
@@ -87,6 +87,7 @@
  --font-size: 0.7rem;
  --font-size-sm: 0.65rem;
  --font-size-lg: 0.8rem;
+  --font-size-xl: 1rem;
  --line-height: 1rem;

  /* Sizes */
--- a/bookmarks/templates/bookmarks/archive.html
+++ b/bookmarks/templates/bookmarks/archive.html
@@ -4,17 +4,17 @@
 {% load bookmarks %}

 {% block content %}
-  <div ld-bulk-edit class="bookmarks-page grid columns-md-1">
+  <div ld-bulk-edit
+       class="bookmarks-page grid columns-md-1 {% if bookmark_list.collapse_side_panel %}collapse-side-panel{% endif %}">

    {# Bookmark list #}
-    <section class="content-area col-2">
-      <div class="content-area-header mb-0">
-        <h2>Archived bookmarks</h2>
+    <main class="main col-2" aria-labelledby="main-heading">
+      <div class="section-header mb-0">
+        <h1 id="main-heading">Archived bookmarks</h1>
        <div class="header-controls">
          {% bookmark_search bookmark_list.search mode='archived' %}
          {% include 'bookmarks/bulk_edit/toggle.html' %}
-          <button ld-tag-modal class="btn ml-2 show-md">Tags
-          </button>
+          <button ld-filter-drawer-trigger class="btn ml-2">Filters</button>
        </div>
      </div>

@@ -28,23 +28,21 @@
          {% include 'bookmarks/bookmark_list.html' %}
        </div>
      </form>
-    </section>
+    </main>

-    {# Tag cloud #}
-    <section class="content-area col-1 hide-md">
-      <div class="content-area-header">
-        <h2>Tags</h2>
-      </div>
-      <div id="tag-cloud-container">
-        {% include 'bookmarks/tag_cloud.html' %}
-      </div>
-    </section>
-
-    {# Bookmark details #}
-    <turbo-frame id="details-modal" target="_top">
-      {% if details %}
-        {% include 'bookmarks/details/modal.html' %}
-      {% endif %}
-    </turbo-frame>
+    {# Filters #}
+    <div class="side-panel col-1 hide-md">
+      {% include 'bookmarks/bundle_section.html' %}
+      {% include 'bookmarks/tag_section.html' %}
+    </div>
  </div>
 {% endblock %}
+
+{% block overlays %}
+  {# Bookmark details #}
+  <turbo-frame id="details-modal" target="_top">
+    {% if details %}
+      {% include 'bookmarks/details/modal.html' %}
+    {% endif %}
+  </turbo-frame>
+{% endblock %}
--- a/bookmarks/templates/bookmarks/bookmark_list.html
+++ b/bookmarks/templates/bookmarks/bookmark_list.html
@@ -5,157 +5,166 @@
 {% if bookmark_list.is_empty %}
  {% include 'bookmarks/empty_bookmarks.html' %}
 {% else %}
-  <ul class="bookmark-list{% if bookmark_list.show_notes %} show-notes{% endif %}"
-      style="--ld-bookmark-description-max-lines:{{ bookmark_list.description_max_lines }};"
-      data-bookmarks-total="{{ bookmark_list.bookmarks_total }}">
-    {% for bookmark_item in bookmark_list.items %}
-      <li ld-bookmark-item{% if bookmark_item.css_classes %} class="{{ bookmark_item.css_classes }}"{% endif %}>
-        <div class="content">
-          <div class="title">
-            <label class="form-checkbox bulk-edit-checkbox">
-              <input type="checkbox" name="bookmark_id" value="{{ bookmark_item.id }}">
-              <i class="form-icon"></i>
-            </label>
-            {% if bookmark_item.favicon_file and bookmark_list.show_favicons %}
-              <img class="favicon" src="{% static bookmark_item.favicon_file %}" alt="">
-            {% endif %}
-            <a href="{{ bookmark_item.url }}" target="{{ bookmark_list.link_target }}" rel="noopener">
-              <span>{{ bookmark_item.title }}</span>
-            </a>
-          </div>
-          {% if bookmark_list.show_url %}
-            <div class="url-path truncate">
-              <a href="{{ bookmark_item.url }}" target="{{ bookmark_list.link_target }}" rel="noopener"
-                 class="url-display">
-                {{ bookmark_item.url }}
+  <section aria-label="Bookmark list">
+    <ul class="bookmark-list{% if bookmark_list.show_notes %} show-notes{% endif %}"
+        role="list" tabindex="-1"
+        style="--ld-bookmark-description-max-lines:{{ bookmark_list.description_max_lines }};"
+        data-bookmarks-total="{{ bookmark_list.bookmarks_total }}">
+      {% for bookmark_item in bookmark_list.items %}
+        <li ld-bookmark-item data-bookmark-id="{{ bookmark_item.id }}" role="listitem"
+            {% if bookmark_item.css_classes %}class="{{ bookmark_item.css_classes }}"{% endif %}>
+          <div class="content">
+            <div class="title">
+              <label class="form-checkbox bulk-edit-checkbox">
+                <input type="checkbox" name="bookmark_id" value="{{ bookmark_item.id }}">
+                <i class="form-icon"></i>
+              </label>
+              {% if bookmark_item.favicon_file and bookmark_list.show_favicons %}
+                <img class="favicon" src="{% static bookmark_item.favicon_file %}" alt="">
+              {% endif %}
+              <a href="{{ bookmark_item.url }}" target="{{ bookmark_list.link_target }}" rel="noopener">
+                <span>{{ bookmark_item.title }}</span>
              </a>
            </div>
-          {% endif %}
-          {% if bookmark_list.description_display == 'inline' %}
-            <div class="description inline truncate">
-              {% if bookmark_item.tag_names %}
-                <span class="tags">
+            {% if bookmark_list.show_url %}
+              <div class="url-path truncate">
+                <a href="{{ bookmark_item.url }}" target="{{ bookmark_list.link_target }}" rel="noopener"
+                   class="url-display">
+                  {{ bookmark_item.url }}
+                </a>
+              </div>
+            {% endif %}
+            {% if bookmark_list.description_display == 'inline' %}
+              <div class="description inline truncate">
+                {% if bookmark_item.tag_names %}
+                  <span class="tags">
                  {% for tag_name in bookmark_item.tag_names %}
                    <a href="?{% add_tag_to_query tag_name %}">{{ tag_name|hash_tag }}</a>
                  {% endfor %}
                </span>
-              {% endif %}
-              {% if bookmark_item.tag_names and bookmark_item.description %} | {% endif %}
-              {% if bookmark_item.description %}
-                <span>{{ bookmark_item.description }}</span>
-              {% endif %}
-            </div>
-          {% else %}
-            {% if bookmark_item.description %}
-              <div class="description separate">{{ bookmark_item.description }}</div>
-            {% endif %}
-            {% if bookmark_item.tag_names %}
-              <div class="tags">
-                {% for tag_name in bookmark_item.tag_names %}
-                  <a href="?{% add_tag_to_query tag_name %}">{{ tag_name|hash_tag }}</a>
-                {% endfor %}
-              </div>
-            {% endif %}
-          {% endif %}
-          {% if bookmark_item.notes %}
-            <div class="notes">
-              <div class="markdown">{% markdown bookmark_item.notes %}</div>
-            </div>
-          {% endif %}
-          <div class="actions">
-            {% if bookmark_item.display_date %}
-              {% if bookmark_item.web_archive_snapshot_url %}
-                <a href="{{ bookmark_item.web_archive_snapshot_url }}"
-                   title="Show snapshot on the Internet Archive Wayback Machine"
-                   target="{{ bookmark_list.link_target }}"
-                   rel="noopener">
-                  {{ bookmark_item.display_date }}
-                </a>
-              {% else %}
-                <span>{{ bookmark_item.display_date }}</span>
-              {% endif %}
-              <span>|</span>
-            {% endif %}
-            {# View link is visible for both owned and shared bookmarks #}
-            {% if bookmark_list.show_view_action %}
-              <a href="{{ bookmark_item.details_url }}" data-turbo-action="replace" data-turbo-frame="details-modal">View</a>
-            {% endif %}
-            {% if bookmark_item.is_editable %}
-              {# Bookmark owner actions #}
-              {% if bookmark_list.show_edit_action %}
-                <a href="{% url 'bookmarks:edit' bookmark_item.id %}?return_url={{ bookmark_list.return_url|urlencode }}">Edit</a>
-              {% endif %}
-              {% if bookmark_list.show_archive_action %}
-                {% if bookmark_item.is_archived %}
-                  <button type="submit" name="unarchive" value="{{ bookmark_item.id }}"
-                          class="btn btn-link btn-sm">Unarchive
-                  </button>
-                {% else %}
-                  <button type="submit" name="archive" value="{{ bookmark_item.id }}"
-                          class="btn btn-link btn-sm">Archive
-                  </button>
                {% endif %}
-              {% endif %}
-              {% if bookmark_list.show_remove_action %}
-                <button ld-confirm-button type="submit" name="remove" value="{{ bookmark_item.id }}"
-                        class="btn btn-link btn-sm">Remove
-                </button>
-              {% endif %}
+                {% if bookmark_item.tag_names and bookmark_item.description %} | {% endif %}
+                {% if bookmark_item.description %}
+                  <span>{{ bookmark_item.description }}</span>
+                {% endif %}
+              </div>
            {% else %}
-              {# Shared bookmark actions #}
-              <span>Shared by
-                <a href="?{% replace_query_param user=bookmark_item.owner.username %}">{{ bookmark_item.owner.username }}</a>
-              </span>
+              {% if bookmark_item.description %}
+                <div class="description separate">{{ bookmark_item.description }}</div>
+              {% endif %}
+              {% if bookmark_item.tag_names %}
+                <div class="tags">
+                  {% for tag_name in bookmark_item.tag_names %}
+                    <a href="?{% add_tag_to_query tag_name %}">{{ tag_name|hash_tag }}</a>
+                  {% endfor %}
+                </div>
+              {% endif %}
            {% endif %}
-            {% if bookmark_item.has_extra_actions %}
-              <div class="extra-actions">
-                <span class="hide-sm">|</span>
-                {% if bookmark_item.show_mark_as_read %}
-                  <button type="submit" name="mark_as_read" value="{{ bookmark_item.id }}"
-                          class="btn btn-link btn-sm btn-icon"
-                          ld-confirm-button ld-confirm-icon="ld-icon-read" ld-confirm-question="Mark as read?">
-                    <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16">
-                      <use xlink:href="#ld-icon-unread"></use>
-                    </svg>
-                    Unread
-                  </button>
-                {% endif %}
-                {% if bookmark_item.show_unshare %}
-                  <button type="submit" name="unshare" value="{{ bookmark_item.id }}"
-                          class="btn btn-link btn-sm btn-icon"
-                          ld-confirm-button ld-confirm-icon="ld-icon-unshare" ld-confirm-question="Unshare?">
-                    <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16">
-                      <use xlink:href="#ld-icon-share"></use>
-                    </svg>
-                    Shared
-                  </button>
-                {% endif %}
-                {% if bookmark_item.show_notes_button %}
-                  <button type="button" class="btn btn-link btn-sm btn-icon toggle-notes">
-                    <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16">
-                      <use xlink:href="#ld-icon-note"></use>
-                    </svg>
-                    Notes
-                  </button>
-                {% endif %}
+            {% if bookmark_item.notes %}
+              <div class="notes">
+                <div class="markdown">{% markdown bookmark_item.notes %}</div>
              </div>
            {% endif %}
-          </div>
-        </div>
-        {% if bookmark_list.show_preview_images %}
-          {% if bookmark_item.preview_image_file %}
-            <img class="preview-image" src="{% static bookmark_item.preview_image_file %}" loading="lazy"/>
-          {% else %}
-            <div class="preview-image placeholder">
-              <div class="img"/>
+            <div class="actions">
+              {% if bookmark_item.display_date %}
+                {% if bookmark_item.snapshot_url %}
+                  <a href="{{ bookmark_item.snapshot_url }}"
+                     title="{{ bookmark_item.snapshot_title }}"
+                     target="{{ bookmark_list.link_target }}"
+                     rel="noopener">
+                    {{ bookmark_item.display_date }}
+                  </a>
+                {% else %}
+                  <span>{{ bookmark_item.display_date }}</span>
+                {% endif %}
+                {% if not bookmark_list.is_preview %}
+                  <span>|</span>
+                {% endif %}
+              {% endif %}
+              {% if not bookmark_list.is_preview %}
+                {# View link is visible for both owned and shared bookmarks #}
+                {% if bookmark_list.show_view_action %}
+                  <a href="{{ bookmark_item.details_url }}" class="view-action"
+                    data-turbo-action="replace" data-turbo-frame="details-modal">View</a>
+                {% endif %}
+                {% if bookmark_item.is_editable %}
+                  {# Bookmark owner actions #}
+                  {% if bookmark_list.show_edit_action %}
+                    <a href="{% url 'linkding:bookmarks.edit' bookmark_item.id %}?return_url={{ bookmark_list.return_url|urlencode }}">Edit</a>
+                  {% endif %}
+                  {% if bookmark_list.show_archive_action %}
+                    {% if bookmark_item.is_archived %}
+                      <button type="submit" name="unarchive" value="{{ bookmark_item.id }}"
+                              class="btn btn-link btn-sm">Unarchive
+                      </button>
+                    {% else %}
+                      <button type="submit" name="archive" value="{{ bookmark_item.id }}"
+                              class="btn btn-link btn-sm">Archive
+                      </button>
+                    {% endif %}
+                  {% endif %}
+                  {% if bookmark_list.show_remove_action %}
+                    <button ld-confirm-button type="submit" name="remove" value="{{ bookmark_item.id }}"
+                            class="btn btn-link btn-sm">Remove
+                    </button>
+                  {% endif %}
+                {% else %}
+                  {# Shared bookmark actions #}
+                  <span>Shared by
+                  <a href="?{% replace_query_param user=bookmark_item.owner.username %}">{{ bookmark_item.owner.username }}</a>
+                </span>
+                {% endif %}
+                {% if bookmark_item.has_extra_actions %}
+                  <div class="extra-actions">
+                    <span class="hide-sm">|</span>
+                    {% if bookmark_item.show_mark_as_read %}
+                      <button type="submit" name="mark_as_read" value="{{ bookmark_item.id }}"
+                              class="btn btn-link btn-sm btn-icon"
+                              ld-confirm-button ld-confirm-icon="ld-icon-read" ld-confirm-question="Mark as read?">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16">
+                          <use xlink:href="#ld-icon-unread"></use>
+                        </svg>
+                        Unread
+                      </button>
+                    {% endif %}
+                    {% if bookmark_item.show_unshare %}
+                      <button type="submit" name="unshare" value="{{ bookmark_item.id }}"
+                              class="btn btn-link btn-sm btn-icon"
+                              ld-confirm-button ld-confirm-icon="ld-icon-unshare" ld-confirm-question="Unshare?">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16">
+                          <use xlink:href="#ld-icon-share"></use>
+                        </svg>
+                        Shared
+                      </button>
+                    {% endif %}
+                    {% if bookmark_item.show_notes_button %}
+                      <button type="button" class="btn btn-link btn-sm btn-icon toggle-notes">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16">
+                          <use xlink:href="#ld-icon-note"></use>
+                        </svg>
+                        Notes
+                      </button>
+                    {% endif %}
+                  </div>
+                {% endif %}
+              {% endif %}
            </div>
+          </div>
+          {% if bookmark_list.show_preview_images %}
+            {% if bookmark_item.preview_image_file %}
+              <img class="preview-image" src="{% static bookmark_item.preview_image_file %}" loading="lazy"/>
+            {% else %}
+              <div class="preview-image placeholder">
+                <div class="img"/>
+              </div>
+            {% endif %}
          {% endif %}
-        {% endif %}
-      </li>
-    {% endfor %}
-  </ul>
+        </li>
+      {% endfor %}
+    </ul>

-  <div class="bookmark-pagination{% if request.user_profile.sticky_pagination %} sticky{% endif %}">
-    {% pagination bookmark_list.bookmarks_page %}
-  </div>
+    <div class="bookmark-pagination{% if request.user_profile.sticky_pagination %} sticky{% endif %}">
+      {% pagination bookmark_list.bookmarks_page %}
+    </div>
+  </section>
 {% endif %}
--- a/bookmarks/templates/bookmarks/bulk_edit/bar.html
+++ b/bookmarks/templates/bookmarks/bulk_edit/bar.html
@@ -22,6 +22,10 @@
          <option value="bulk_share">Share</option>
          <option value="bulk_unshare">Unshare</option>
        {% endif %}
+        <option value="bulk_refresh">Refresh from website</option>
+        {% if bookmark_list.snapshot_feature_enabled %}
+          <option value="bulk_snapshot">Create HTML snapshot</option>
+        {% endif %}
      </select>
      <div class="tag-autocomplete d-none" ld-tag-autocomplete>
        <input name="bulk_tag_string" class="form-input input-sm" placeholder="Tag names..." variant="small">
--- a/bookmarks/templates/bookmarks/bundle_section.html
+++ b/bookmarks/templates/bookmarks/bundle_section.html
@@ -0,0 +1,36 @@
+{% if not request.user_profile.hide_bundles %}
+  <section aria-labelledby="bundles-heading">
+    <div class="section-header no-wrap">
+      <h2 id="bundles-heading">Bundles</h2>
+      <div ld-dropdown class="dropdown dropdown-right ml-auto">
+        <button class="btn dropdown-toggle" aria-label="Bundles menu">
+          <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none"
+               stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <path stroke="none" d="M0 0h24v24H0z" fill="none"/>
+            <path d="M4 6l16 0"/>
+            <path d="M4 12l16 0"/>
+            <path d="M4 18l16 0"/>
+          </svg>
+        </button>
+        <ul class="menu" role="list" tabindex="-1">
+          <li class="menu-item">
+            <a href="{% url 'linkding:bundles.index' %}" class="menu-link">Manage bundles</a>
+          </li>
+          {% if bookmark_list.search.q %}
+            <li class="menu-item">
+              <a href="{% url 'linkding:bundles.new' %}?q={{ bookmark_list.search.q|urlencode }}" class="menu-link">Create
+                bundle from search</a>
+            </li>
+          {% endif %}
+        </ul>
+      </div>
+    </div>
+    <ul class="bundle-menu">
+      {% for bundle in bundles.bundles %}
+        <li class="bundle-menu-item {% if bundle.id == bundles.selected_bundle.id %}selected{% endif %}">
+          <a href="?bundle={{ bundle.id }}">{{ bundle.name }}</a>
+        </li>
+      {% endfor %}
+    </ul>
+  </section>
+{% endif %}
--- a/bookmarks/templates/bookmarks/details/assets.html
+++ b/bookmarks/templates/bookmarks/details/assets.html
@@ -1,12 +1,12 @@
 <div>
  {% if details.assets %}
-    <div class="assets">
+    <div class="item-list assets">
      {% for asset in details.assets %}
-        <div class="asset" data-asset-id="{{ asset.id }}">
-          <div class="asset-icon {{ asset.icon_classes }}">
+        <div class="list-item" data-asset-id="{{ asset.id }}">
+          <div class="list-item-icon {{ asset.icon_classes }}">
            {% include 'bookmarks/details/asset_icon.html' %}
          </div>
-          <div class="asset-text {{ asset.text_classes }}">
+          <div class="list-item-text {{ asset.text_classes }}">
          <span class="truncate">
            {{ asset.display_name }}
            {% if asset.status == 'pending' %}(queued){% endif %}
@@ -16,9 +16,9 @@
              <span class="filesize">{{ asset.file_size|filesizeformat }}</span>
            {% endif %}
          </div>
-          <div class="asset-actions">
+          <div class="list-item-actions">
            {% if asset.file %}
-              <a class="btn btn-link" href="{% url 'bookmarks:assets.view' asset.id %}" target="_blank">View</a>
+              <a class="btn btn-link" href="{% url 'linkding:assets.view' asset.id %}" target="_blank">View</a>
            {% endif %}
            {% if details.is_editable %}
              <button ld-confirm-button type="submit" name="remove_asset" value="{{ asset.id }}" class="btn btn-link">
@@ -33,12 +33,16 @@

  {% if details.is_editable %}
    <div class="assets-actions">
-      <button type="submit" name="create_html_snapshot" value="{{ details.bookmark.id }}" class="btn btn-sm"
-              {% if details.has_pending_assets %}disabled{% endif %}>Create HTML snapshot
-      </button>
-      <button ld-upload-button id="upload-asset" name="upload_asset" value="{{ details.bookmark.id }}" type="submit"
-              class="btn btn-sm">Upload file
-      </button>
+      {% if details.snapshots_enabled %}
+        <button type="submit" name="create_html_snapshot" value="{{ details.bookmark.id }}" class="btn btn-sm"
+                {% if details.has_pending_assets %}disabled{% endif %}>Create HTML snapshot
+        </button>
+      {% endif %}
+      {% if details.uploads_enabled %}
+        <button ld-upload-button id="upload-asset" name="upload_asset" value="{{ details.bookmark.id }}" type="submit"
+                class="btn btn-sm">Upload file
+        </button>
+      {% endif %}
      <input id="upload-asset-file" name="upload_asset_file" type="file" class="d-hide">
    </div>
  {% endif %}
--- a/bookmarks/templates/bookmarks/details/form.html
+++ b/bookmarks/templates/bookmarks/details/form.html
@@ -14,7 +14,7 @@
      <span>{{ details.bookmark.url }}</span>
    </a>
    {% if details.latest_snapshot %}
-      <a class="weblink" href="{% url 'bookmarks:assets.read' details.latest_snapshot.id %}"
+      <a class="weblink" href="{% url 'linkding:assets.read' details.latest_snapshot.id %}"
         target="{{ details.profile.bookmark_link_target }}">
        {% if details.show_link_icons %}
          <svg class="favicon" xmlns="http://www.w3.org/2000/svg">
@@ -40,14 +40,14 @@
  </div>
  {% if details.preview_image_enabled and details.bookmark.preview_image_file %}
    <div class="preview-image">
-      <img src="{% static details.bookmark.preview_image_file %}"/>
+      <img src="{% static details.bookmark.preview_image_file %}" alt=""/>
    </div>
  {% endif %}
-  <dl class="grid columns-2 columns-sm-1 gap-0">
+  <div class="sections grid columns-2 columns-sm-1 gap-0">
    {% if details.is_editable %}
-      <div class="status col-2">
-        <dt>Status</dt>
-        <dd class="d-flex" style="gap: .8rem">
+      <section class="status col-2">
+        <h3>Status</h3>
+        <div class="d-flex" style="gap: .8rem">
          <div class="form-group">
            <label class="form-switch">
              <input ld-auto-submit type="checkbox" name="is_archived"
@@ -71,44 +71,42 @@
              </label>
            </div>
          {% endif %}
-        </dd>
-      </div>
+        </div>
+      </section>
    {% endif %}
-    {% if details.show_files %}
-      <div class="files col-2">
-        <dt>Files</dt>
-        <dd>
-          {% include 'bookmarks/details/assets.html' %}
-        </dd>
+    <section class="files col-2">
+      <h3>Files</h3>
+      <div>
+        {% include 'bookmarks/details/assets.html' %}
      </div>
-    {% endif %}
+    </section>
    {% if details.bookmark.tag_names %}
-      <div class="tags col-1">
-        <dt>Tags</dt>
-        <dd>
+      <section class="tags col-1">
+        <h3 id="details-modal-tags-title">Tags</h3>
+        <div>
          {% for tag_name in details.bookmark.tag_names %}
-            <a href="{% url 'bookmarks:index' %}?{% add_tag_to_query tag_name %}">{{ tag_name|hash_tag }}</a>
+            <a href="{% url 'linkding:bookmarks.index' %}?{% add_tag_to_query tag_name %}">{{ tag_name|hash_tag }}</a>
          {% endfor %}
-        </dd>
-      </div>
+        </div>
+      </section>
    {% endif %}
-    <div class="date-added col-1">
-      <dt>Date added</dt>
-      <dd>
+    <section class="date-added col-1">
+      <h3>Date added</h3>
+      <div>
        <span>{{ details.bookmark.date_added }}</span>
-      </dd>
-    </div>
-    {% if details.bookmark.resolved_description %}
-      <div class="description col-2">
-        <dt>Description</dt>
-        <dd>{{ details.bookmark.resolved_description }}</dd>
      </div>
+    </section>
+    {% if details.bookmark.resolved_description %}
+      <section class="description col-2">
+        <h3>Description</h3>
+        <div>{{ details.bookmark.resolved_description }}</div>
+      </section>
    {% endif %}
    {% if details.bookmark.notes %}
-      <div class="notes col-2">
-        <dt>Notes</dt>
-        <dd class="markdown">{% markdown details.bookmark.notes %}</dd>
-      </div>
+      <section class="notes col-2">
+        <h3>Notes</h3>
+        <div class="markdown">{% markdown details.bookmark.notes %}</div>
+      </section>
    {% endif %}
-  </dl>
+  </div>
 </form>
--- a/bookmarks/templates/bookmarks/details/modal.html
+++ b/bookmarks/templates/bookmarks/details/modal.html
@@ -1,21 +1,17 @@
-<div class="modal active bookmark-details"
-     ld-details-modal>
-  <a href="{{ details.close_url }}" data-turbo-frame="details-modal">
-    <div class="modal-overlay" aria-label="Close"></div>
-  </a>
-  <div class="modal-container">
+<div class="modal active bookmark-details" ld-details-modal
+     data-bookmark-id="{{ details.bookmark.id }}" data-close-url="{{ details.close_url }}">
+  <div class="modal-overlay"></div>
+  <div class="modal-container" role="dialog" aria-modal="true">
    <div class="modal-header">
-      <h2>{{ details.bookmark.resolved_title }}</h2>
-      <a href="{{ details.close_url }}" data-turbo-frame="details-modal">
-        <button class="close">
-          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" stroke-width="2"
-               stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
-            <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
-            <path d="M18 6l-12 12"></path>
-            <path d="M6 6l12 12"></path>
-          </svg>
-        </button>
-      </a>
+      <h2 class="title">{{ details.bookmark.resolved_title }}</h2>
+      <button class="close" aria-label="Close dialog">
+        <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" stroke-width="2"
+             stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
+          <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+          <path d="M18 6l-12 12"></path>
+          <path d="M6 6l12 12"></path>
+        </svg>
+      </button>
    </div>
    <div class="modal-body">
      <div class="content">
@@ -28,7 +24,7 @@
        <div class="actions">
          <div class="left-actions">
            <a class="btn btn-wide"
-               href="{% url 'bookmarks:edit' details.bookmark.id %}?return_url={{ details.edit_return_url|urlencode }}">Edit</a>
+               href="{% url 'linkding:bookmarks.edit' details.bookmark.id %}?return_url={{ details.edit_return_url|urlencode }}">Edit</a>
          </div>
          <div class="right-actions">
            <form action="{{ details.delete_url }}" method="post" data-turbo-action="replace">
--- a/bookmarks/templates/bookmarks/edit.html
+++ b/bookmarks/templates/bookmarks/edit.html
@@ -1,16 +1,21 @@
 {% extends 'bookmarks/layout.html' %}
-{% load bookmarks %}
+
+{% block head %}
+  {% with page_title="Edit bookmark - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}

 {% block content %}
  <div class="bookmarks-form-page">
-    <section class="content-area">
-      <div class="content-area-header">
-        <h2>Edit bookmark</h2>
+    <main aria-labelledby="main-heading">
+      <div class="section-header">
+        <h1 id="main-heading">Edit bookmark</h1>
      </div>
-      <form action="{% url 'bookmarks:edit' bookmark_id %}?return_url={{ return_url|urlencode }}" method="post"
+      <form action="{% url 'linkding:bookmarks.edit' bookmark_id %}?return_url={{ return_url|urlencode }}" method="post"
            novalidate>
-        {% bookmark_form form return_url bookmark_id %}
+        {% include 'bookmarks/form.html' %}
      </form>
-    </section>
+    </main>
  </div>
 {% endblock %}
--- a/bookmarks/templates/bookmarks/empty_bookmarks.html
+++ b/bookmarks/templates/bookmarks/empty_bookmarks.html
@@ -1,9 +1,9 @@
 <div class="empty">
  <p class="empty-title h5">You have no bookmarks yet</p>
  <p class="empty-subtitle">
-    You can get started by <a href="{% url 'bookmarks:new' %}">adding</a> bookmarks,
-    <a href="{% url 'bookmarks:settings.general' %}">importing</a> your existing bookmarks or configuring the
-    <a href="{% url 'bookmarks:settings.integrations' %}">browser extension</a> or the <a
-      href="{% url 'bookmarks:settings.integrations' %}">bookmarklet</a>.
+    You can get started by <a href="{% url 'linkding:bookmarks.new' %}">adding</a> bookmarks,
+    <a href="{% url 'linkding:settings.general' %}">importing</a> your existing bookmarks or configuring the
+    <a href="{% url 'linkding:settings.integrations' %}">browser extension</a> or the <a
+      href="{% url 'linkding:settings.integrations' %}">bookmarklet</a>.
  </p>
 </div>
--- a/bookmarks/templates/bookmarks/form.html
+++ b/bookmarks/templates/bookmarks/form.html
@@ -1,5 +1,6 @@
 {% load widget_tweaks %}
 {% load static %}
+{% load shared %}

 <div class="bookmarks-form">
  {% csrf_token %}
@@ -7,7 +8,7 @@
  <div class="form-group {% if form.url.errors %}has-error{% endif %}">
    <label for="{{ form.url.id_for_label }}" class="form-label">URL</label>
    <div class="has-icon-right">
-      {{ form.url|add_class:"form-input"|attr:"autofocus"|attr:"placeholder: " }}
+      {{ form.url|form_field:"validation"|add_class:"form-input"|attr:"autofocus" }}
      <i class="form-icon loading"></i>
    </div>
    {% if form.url.errors %}
@@ -22,8 +23,8 @@
  </div>
  <div class="form-group" ld-tag-autocomplete>
    <label for="{{ form.tag_string.id_for_label }}" class="form-label">Tags</label>
-    {{ form.tag_string|add_class:"form-input"|attr:"autocomplete:off"|attr:"autocapitalize:off" }}
-    <div class="form-input-hint">
+    {{ form.tag_string|form_field:"help"|add_class:"form-input"|attr:"autocomplete:off"|attr:"autocapitalize:off" }}
+    <div id="{{ form.tag_string.auto_id }}_help" class="form-input-hint">
      Enter any number of tags separated by space and <strong>without</strong> the hash (#).
      If a tag does not exist it will be automatically created.
    </div>
@@ -33,9 +34,13 @@
  <div class="form-group">
    <div class="d-flex justify-between align-baseline">
      <label for="{{ form.title.id_for_label }}" class="form-label">Title</label>
-      <button ld-clear-button data-for="{{ form.title.id_for_label }}" class="btn btn-link clear-button"
-              type="button">Clear
-      </button>
+      <div class="flex">
+        <button id="refresh-button" class="btn btn-link suffix-button" type="button">Refresh from website</button>
+        <button ld-clear-button data-for="{{ form.title.id_for_label }}"
+                class="ml-2 btn btn-link suffix-button clear-button"
+                type="button">Clear
+        </button>
+      </div>
    </div>
    {{ form.title|add_class:"form-input"|attr:"autocomplete:off" }}
    {{ form.title.errors }}
@@ -43,7 +48,8 @@
  <div class="form-group">
    <div class="d-flex justify-between align-baseline">
      <label for="{{ form.description.id_for_label }}" class="form-label">Description</label>
-      <button ld-clear-button data-for="{{ form.description.id_for_label }}" class="btn btn-link clear-button"
+      <button ld-clear-button data-for="{{ form.description.id_for_label }}"
+              class="btn btn-link suffix-button clear-button"
              type="button">Clear
      </button>
    </div>
@@ -56,31 +62,31 @@
        <span class="form-label d-inline-block">Notes</span>
      </summary>
      <label for="{{ form.notes.id_for_label }}" class="text-assistive">Notes</label>
-      {{ form.notes|add_class:"form-input"|attr:"rows:8" }}
-      <div class="form-input-hint">
+      {{ form.notes|form_field:"help"|add_class:"form-input"|attr:"rows:8" }}
+      <div id="{{ form.notes.auto_id }}_help" class="form-input-hint">
        Additional notes, supports Markdown.
      </div>
    </details>
    {{ form.notes.errors }}
  </div>
  <div class="form-group">
-    <label for="{{ form.unread.id_for_label }}" class="form-checkbox">
-      {{ form.unread }}
+    <div class="form-checkbox">
+      {{ form.unread|form_field:"help" }}
      <i class="form-icon"></i>
-      <span>Mark as unread</span>
-    </label>
-    <div class="form-input-hint">
+      <label for="{{ form.unread.id_for_label }}">Mark as unread</label>
+    </div>
+    <div id="{{ form.unread.auto_id }}_help" class="form-input-hint">
      Unread bookmarks can be filtered for, and marked as read after you had a chance to look at them.
    </div>
  </div>
  {% if request.user_profile.enable_sharing %}
    <div class="form-group">
-      <label for="{{ form.shared.id_for_label }}" class="form-checkbox">
-        {{ form.shared }}
+      <div class="form-checkbox">
+        {{ form.shared|form_field:"help" }}
        <i class="form-icon"></i>
-        <span>Share</span>
-      </label>
-      <div class="form-input-hint">
+        <label for="{{ form.shared.id_for_label }}">Share</label>
+      </div>
+      <div id="{{ form.shared.auto_id }}_help" class="form-input-hint">
        {% if request.user_profile.enable_public_sharing %}
          Share this bookmark with other registered users and anonymous users.
        {% else %}
@@ -91,12 +97,12 @@
  {% endif %}
  <div class="divider"></div>
  <div class="form-group d-flex justify-between">
-    {% if auto_close %}
+    {% if form.is_auto_close %}
      <input type="submit" value="Save and close" class="btn btn-primary btn-wide">
    {% else %}
      <input type="submit" value="Save" class="btn btn-primary btn btn-primary btn-wide">
    {% endif %}
-    <a href="{{ cancel_url }}" class="btn">Nevermind</a>
+    <a href="{{ return_url }}" class="btn">Cancel</a>
  </div>
  <script type="application/javascript">
    /**
@@ -111,8 +117,9 @@
      const notesInput = document.getElementById('{{ form.notes.id_for_label }}');
      const unreadCheckbox = document.getElementById('{{ form.unread.id_for_label }}');
      const sharedCheckbox = document.getElementById('{{ form.shared.id_for_label }}');
+      const refreshButton = document.getElementById('refresh-button');
      const bookmarkExistsHint = document.querySelector('.form-input-hint.bookmark-exists');
-      const editedBookmarkId = {{ bookmark_id }};
+      const editedBookmarkId = {{ form.instance.id|default:0 }};
      let isTitleModified = !!titleInput.value;
      let isDescriptionModified = !!descriptionInput.value;

@@ -144,7 +151,7 @@
        toggleLoadingIcon(urlInput, true);

        const websiteUrl = encodeURIComponent(urlInput.value);
-        const requestUrl = `{% url 'bookmarks:api-root' %}bookmarks/check?url=${websiteUrl}`;
+        const requestUrl = `{% url 'linkding:api-root' %}bookmarks/check?url=${websiteUrl}`;
        fetch(requestUrl)
          .then(response => response.json())
          .then(data => {
@@ -154,6 +161,7 @@
            // Display hint if URL is already bookmarked
            const existingBookmark = data.bookmark;
            bookmarkExistsHint.style['display'] = existingBookmark ? 'block' : 'none';
+            refreshButton.style['display'] = existingBookmark ? 'inline-block' : 'none';

            // Prefill form with existing bookmark data
            if (existingBookmark) {
@@ -193,6 +201,37 @@
          });
      }

+      function refreshMetadata() {
+        if (!urlInput.value) {
+          return;
+        }
+
+        toggleLoadingIcon(urlInput, true);
+
+        const websiteUrl = encodeURIComponent(urlInput.value);
+        const requestUrl = `{% url 'linkding:api-root' %}bookmarks/check?url=${websiteUrl}&ignore_cache=true`;
+
+        fetch(requestUrl)
+          .then(response => response.json())
+          .then(data => {
+            const metadata = data.metadata;
+            const existingBookmark = data.bookmark;
+            toggleLoadingIcon(urlInput, false);
+
+            if (metadata.title && metadata.title !== existingBookmark?.title) {
+              titleInput.value = metadata.title;
+              titleInput.classList.add("modified");
+            }
+
+            if (metadata.description && metadata.description !== existingBookmark?.description) {
+              descriptionInput.value = metadata.description;
+              descriptionInput.classList.add("modified");
+            }
+          });
+      }
+
+      refreshButton.addEventListener('click', refreshMetadata);
+
      // Fetch website metadata when page loads and when URL changes, unless we are editing an existing bookmark
      if (!editedBookmarkId) {
        checkUrl();
@@ -203,6 +242,8 @@
        descriptionInput.addEventListener('input', () => {
          isDescriptionModified = true;
        });
+      } else {
+        refreshButton.style['display'] = 'inline-block';
      }
    })();
  </script>
--- a/bookmarks/templates/bookmarks/head.html
+++ b/bookmarks/templates/bookmarks/head.html
@@ -6,13 +6,14 @@
  <link rel="icon" href="{% static 'favicon.svg' %}" sizes="any" type="image/svg+xml">
  <link rel="apple-touch-icon" sizes="180x180" href="{% static 'apple-touch-icon.png' %}">
  <link rel="mask-icon" href="{% static 'safari-pinned-tab.svg' %}" color="#5856e0">
-  <link rel="manifest" href="{% url 'bookmarks:manifest' %}">
+  <link rel="manifest" href="{% url 'linkding:manifest' %}">
+  <link rel="search" type="application/opensearchdescription+xml" title="Linkding" href="{% url 'linkding:opensearch' %}"/>
  <meta name="apple-mobile-web-app-capable" content="yes">
  <meta name="viewport" content="width=device-width, initial-scale=1.0, minimal-ui">
  <meta name="description" content="Self-hosted bookmark service">
  <meta name="robots" content="index,follow">
  <meta name="author" content="Sascha Ißbrücker">
-  <title>linkding</title>
+  <title>{{ page_title|default:'Linkding' }}</title>
  {# Include specific theme variant based on user profile setting #}
  {% if request.user_profile.theme == 'light' %}
    <link href="{% static 'theme-light.css' %}?v={{ app_version }}" rel="stylesheet" type="text/css"/>
@@ -30,11 +31,14 @@
    <meta name="theme-color" media="(prefers-color-scheme: light)" content="#5856e0">
  {% endif %}
  {% if request.user_profile.custom_css %}
-    <link href="{% url 'bookmarks:custom_css' %}?hash={{ request.user_profile.custom_css_hash }}" rel="stylesheet" type="text/css"/>
+    <link href="{% url 'linkding:custom_css' %}?hash={{ request.user_profile.custom_css_hash }}" rel="stylesheet" type="text/css"/>
  {% endif %}
  <meta name="turbo-cache-control" content="no-preview">
  {% if not request.global_settings.enable_link_prefetch %}
    <meta name="turbo-prefetch" content="false">
  {% endif %}
+  {% if rss_feed_url %}
+    <link rel="alternate" type="application/rss+xml" href="{{ rss_feed_url }}" />
+  {% endif %}
  <script src="{% static "bundle.js" %}?v={{ app_version }}"></script>
 </head>
--- a/bookmarks/templates/bookmarks/index.html
+++ b/bookmarks/templates/bookmarks/index.html
@@ -3,17 +3,20 @@
 {% load shared %}
 {% load bookmarks %}

+{% block title %}Bookmarks - Linkding{% endblock %}
+
 {% block content %}
-  <div ld-bulk-edit class="bookmarks-page grid columns-md-1">
+  <div ld-bulk-edit
+       class="bookmarks-page grid columns-md-1 {% if bookmark_list.collapse_side_panel %}collapse-side-panel{% endif %}">

    {# Bookmark list #}
-    <section class="content-area col-2">
-      <div class="content-area-header mb-0">
-        <h2>Bookmarks</h2>
+    <main class="main col-2" aria-labelledby="main-heading">
+      <div class="section-header mb-0">
+        <h1 id="main-heading">Bookmarks</h1>
        <div class="header-controls">
          {% bookmark_search bookmark_list.search %}
          {% include 'bookmarks/bulk_edit/toggle.html' %}
-          <button ld-tag-modal class="btn ml-2 show-md">Tags</button>
+          <button ld-filter-drawer-trigger class="btn ml-2">Filters</button>
        </div>
      </div>

@@ -27,23 +30,21 @@
          {% include 'bookmarks/bookmark_list.html' %}
        </div>
      </form>
-    </section>
+    </main>

-    {# Tag cloud #}
-    <section class="content-area col-1 hide-md">
-      <div class="content-area-header">
-        <h2>Tags</h2>
-      </div>
-      <div id="tag-cloud-container">
-        {% include 'bookmarks/tag_cloud.html' %}
-      </div>
-    </section>
-
-    {# Bookmark details #}
-    <turbo-frame id="details-modal" target="_top">
-      {% if details %}
-        {% include 'bookmarks/details/modal.html' %}
-      {% endif %}
-    </turbo-frame>
+    {# Filters #}
+    <div class="side-panel col-1 hide-md">
+      {% include 'bookmarks/bundle_section.html' %}
+      {% include 'bookmarks/tag_section.html' %}
+    </div>
  </div>
 {% endblock %}
+
+{% block overlays %}
+  {# Bookmark details #}
+  <turbo-frame id="details-modal" target="_top">
+    {% if details %}
+      {% include 'bookmarks/details/modal.html' %}
+    {% endif %}
+  </turbo-frame>
+{% endblock %}
--- a/bookmarks/templates/bookmarks/layout.html
+++ b/bookmarks/templates/bookmarks/layout.html
@@ -2,8 +2,8 @@

 <!DOCTYPE html>
 {# Use data attributes as storage for access in static scripts #}
-<html lang="en" data-api-base-url="{% url 'bookmarks:api-root' %}">
-{% include 'bookmarks/head.html' %}
+<html lang="en" data-api-base-url="{% url 'linkding:api-root' %}">
+{% block head %}{% include 'bookmarks/head.html' %}{% endblock %}
 <body ld-global-shortcuts>

 <div class="d-none">
@@ -67,8 +67,8 @@

 <header class="container">
  {% if has_toasts %}
-    <div class="toasts">
-      <form action="{% url 'bookmarks:toasts.acknowledge' %}?return_url={{ request.path | urlencode }}" method="post">
+    <div class="message-list">
+      <form action="{% url 'linkding:toasts.acknowledge' %}?return_url={{ request.path | urlencode }}" method="post">
        {% csrf_token %}
        {% for toast in toast_messages %}
          <div class="toast d-flex">
@@ -80,22 +80,28 @@
    </div>
  {% endif %}
  <div class="d-flex justify-between">
-    <a href="{% url 'bookmarks:root' %}" class="d-flex align-center">
-      <img class="logo" src="{% static 'logo.png' %}" alt="Application logo">
-      <h1>LINKDING</h1>
+    <a href="{% url 'linkding:root' %}" class="app-link d-flex align-center">
+      <img class="app-logo" src="{% static 'logo.png' %}" alt="Application logo">
+      <span class="app-name">LINKDING</span>
    </a>
-    {% if request.user.is_authenticated %}
-      {# Only show nav items menu when logged in #}
-      {% include 'bookmarks/nav_menu.html' %}
-    {% else %}
-      {# Otherwise show login link #}
-      <a href="{% url 'login' %}" class="btn btn-link">Login</a>
-    {% endif %}
+    <nav>
+      {% if request.user.is_authenticated %}
+        {# Only show nav items menu when logged in #}
+        {% include 'bookmarks/nav_menu.html' %}
+      {% else %}
+        {# Otherwise show login link #}
+        <a href="{% url 'login' %}" class="btn btn-link">Login</a>
+      {% endif %}
+    </nav>
  </div>
 </header>
 <div class="content container">
  {% block content %}
  {% endblock %}
 </div>
+<div class="modals">
+  {% block overlays %}
+  {% endblock %}
+</div>
 </body>
 </html>
--- a/bookmarks/templates/bookmarks/nav_menu.html
+++ b/bookmarks/templates/bookmarks/nav_menu.html
@@ -2,77 +2,103 @@
 {% htmlmin %}
  {# Basic menu list #}
  <div class="hide-md">
-    <a href="{% url 'bookmarks:new' %}" class="btn btn-primary mr-2">Add bookmark</a>
-    <div class="dropdown">
+    <a href="{% url 'linkding:bookmarks.new' %}" class="btn btn-primary mr-2">Add bookmark</a>
+    <div ld-dropdown class="dropdown">
      <button class="btn btn-link dropdown-toggle" tabindex="0">
        Bookmarks
      </button>
-      <ul class="menu">
+      <ul class="menu" role="list" tabindex="-1">
        <li class="menu-item">
-          <a href="{% url 'bookmarks:index' %}" class="menu-link">Active</a>
+          <a href="{% url 'linkding:bookmarks.index' %}" class="menu-link">Active</a>
        </li>
        <li class="menu-item">
-          <a href="{% url 'bookmarks:archived' %}" class="menu-link">Archived</a>
+          <a href="{% url 'linkding:bookmarks.archived' %}" class="menu-link">Archived</a>
        </li>
        {% if request.user_profile.enable_sharing %}
          <li class="menu-item">
-            <a href="{% url 'bookmarks:shared' %}" class="menu-link">Shared</a>
+            <a href="{% url 'linkding:bookmarks.shared' %}" class="menu-link">Shared</a>
          </li>
        {% endif %}
        <li class="menu-item">
-          <a href="{% url 'bookmarks:index' %}?unread=yes" class="menu-link">Unread</a>
+          <a href="{% url 'linkding:bookmarks.index' %}?unread=yes" class="menu-link">Unread</a>
        </li>
        <li class="menu-item">
-          <a href="{% url 'bookmarks:index' %}?q=!untagged" class="menu-link">Untagged</a>
+          <a href="{% url 'linkding:bookmarks.index' %}?q=!untagged" class="menu-link">Untagged</a>
        </li>
      </ul>
    </div>
-    <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
-    <form class="d-inline" action="{% url 'logout' %}" method="post">
+    <div ld-dropdown class="dropdown">
+      <button class="btn btn-link dropdown-toggle" tabindex="0">
+        Settings
+      </button>
+      <ul class="menu" role="list" tabindex="-1">
+        <li class="menu-item">
+          <a href="{% url 'linkding:settings.general' %}" class="menu-link">General</a>
+        </li>
+        <li class="menu-item">
+          <a href="{% url 'linkding:settings.integrations' %}" class="menu-link">Integrations</a>
+        </li>
+        {% if request.user.is_superuser %}
+          <li class="menu-item">
+            <a href="{% url 'admin:index' %}" class="menu-link" data-turbo="false">Admin</a>
+          </li>
+        {% endif %}
+      </ul>
+    </div>
+    <form class="d-inline" action="{% url 'logout' %}" method="post" data-turbo="false">
      {% csrf_token %}
      <button type="submit" class="btn btn-link">Logout</button>
    </form>
  </div>
  {# Menu drop-down for smaller devices #}
  <div class="show-md">
-    <a href="{% url 'bookmarks:new' %}" class="btn btn-primary">
+    <a href="{% url 'linkding:bookmarks.new' %}" aria-label="Add bookmark" class="btn btn-primary">
      <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor"
           style="width: 24px; height: 24px">
        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 6v6m0 0v6m0-6h6m-6 0H6"></path>
      </svg>
    </a>
    <div ld-dropdown class="dropdown dropdown-right">
-      <button class="btn btn-link dropdown-toggle" tabindex="0">
+      <button class="btn btn-link dropdown-toggle" aria-label="Navigation menu" tabindex="0">
        <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor"
             style="width: 24px; height: 24px">
          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 6h16M4 12h16M4 18h16"></path>
        </svg>
      </button>
      <!-- menu component -->
-      <ul class="menu">
+      <ul class="menu" role="list" tabindex="-1">
        <li class="menu-item">
-          <a href="{% url 'bookmarks:index' %}" class="menu-link">Bookmarks</a>
+          <a href="{% url 'linkding:bookmarks.index' %}" class="menu-link">Bookmarks</a>
        </li>
        <li class="menu-item">
-          <a href="{% url 'bookmarks:archived' %}" class="menu-link">Archived</a>
+          <a href="{% url 'linkding:bookmarks.archived' %}" class="menu-link">Archived bookmarks</a>
        </li>
        {% if request.user_profile.enable_sharing %}
          <li class="menu-item">
-            <a href="{% url 'bookmarks:shared' %}" class="menu-link">Shared</a>
+            <a href="{% url 'linkding:bookmarks.shared' %}" class="menu-link">Shared bookmarks</a>
          </li>
        {% endif %}
        <li class="menu-item">
-          <a href="{% url 'bookmarks:index' %}?unread=yes" class="menu-link">Unread</a>
+          <a href="{% url 'linkding:bookmarks.index' %}?unread=yes" class="menu-link">Unread</a>
        </li>
        <li class="menu-item">
-          <a href="{% url 'bookmarks:index' %}?q=!untagged" class="menu-link">Untagged</a>
+          <a href="{% url 'linkding:bookmarks.index' %}?q=!untagged" class="menu-link">Untagged</a>
        </li>
        <div class="divider"></div>
        <li class="menu-item">
-          <a href="{% url 'bookmarks:settings.index' %}" class="menu-link">Settings</a>
+          <a href="{% url 'linkding:settings.general' %}" class="menu-link">Settings</a>
        </li>
        <li class="menu-item">
-          <form class="d-inline" action="{% url 'logout' %}" method="post">
+          <a href="{% url 'linkding:settings.integrations' %}" class="menu-link">Integrations</a>
+        </li>
+        {% if request.user.is_superuser %}
+          <li class="menu-item">
+            <a href="{% url 'admin:index' %}" class="menu-link" data-turbo="false">Admin</a>
+          </li>
+        {% endif %}
+        <div class="divider"></div>
+        <li class="menu-item">
+          <form class="d-inline" action="{% url 'logout' %}" method="post" data-turbo="false">
            {% csrf_token %}
            <button type="submit" class="btn btn-link menu-link">Logout</button>
          </form>
--- a/bookmarks/templates/bookmarks/new.html
+++ b/bookmarks/templates/bookmarks/new.html
@@ -1,15 +1,20 @@
 {% extends 'bookmarks/layout.html' %}
-{% load bookmarks %}
+
+{% block head %}
+  {% with page_title="New bookmark - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}

 {% block content %}
  <div class="bookmarks-form-page">
-    <section class="content-area">
-      <div class="content-area-header">
-        <h2>New bookmark</h2>
+    <main aria-labelledby="main-heading">
+      <div class="section-header">
+        <h1 id="main-heading">New bookmark</h1>
      </div>
-      <form action="{% url 'bookmarks:new' %}" method="post" novalidate>
-        {% bookmark_form form return_url auto_close=auto_close %}
+      <form action="{% url 'linkding:bookmarks.new' %}" method="post" novalidate>
+        {% include 'bookmarks/form.html' %}
      </form>
-    </section>
+    </main>
  </div>
 {% endblock %}
--- a/bookmarks/templates/bookmarks/pagination.html
+++ b/bookmarks/templates/bookmarks/pagination.html
@@ -3,7 +3,7 @@
 <ul class="pagination">
  {% if prev_link %}
    <li class="page-item">
-      <a href="?{{ prev_link }}" tabindex="-1">Previous</a>
+      <a href="{{ prev_link }}" tabindex="-1">Previous</a>
    </li>
  {% else %}
    <li class="page-item disabled">
@@ -14,7 +14,7 @@
  {% for page_link in page_links %}
    {% if page_link %}
      <li class="page-item {% if page_link.active %}active{% endif %}">
-        <a href="?{{ page_link.link }}">{{ page_link.number }}</a>
+        <a href="{{ page_link.link }}">{{ page_link.number }}</a>
      </li>
    {% else %}
      <li class="page-item">
@@ -25,7 +25,7 @@

  {% if next_link %}
    <li class="page-item">
-      <a href="?{{ next_link }}" tabindex="-1">Next</a>
+      <a href="{{ next_link }}" tabindex="-1">Next</a>
    </li>
  {% else %}
    <li class="page-item disabled">
--- a/bookmarks/templates/bookmarks/read.html
+++ b/bookmarks/templates/bookmarks/read.html
@@ -21,6 +21,9 @@
    <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#161822">
    <meta name="theme-color" media="(prefers-color-scheme: light)" content="#5856e0">
  {% endif %}
+  {% if request.user_profile.custom_css %}
+    <link href="{% url 'linkding:custom_css' %}?hash={{ request.user_profile.custom_css_hash }}" rel="stylesheet" type="text/css"/>
+  {% endif %}
 </head>
 <body>
 <template id="content">{{ content|safe }}</template>
--- a/bookmarks/templates/bookmarks/search.html
+++ b/bookmarks/templates/bookmarks/search.html
@@ -15,7 +15,8 @@
    {% endfor %}
  </form>
  <div ld-dropdown class="search-options dropdown dropdown-right">
-    <button type="button" class="btn dropdown-toggle{% if search.has_modified_preferences %} badge{% endif %}">
+    <button type="button" aria-label="Search preferences"
+            class="btn dropdown-toggle{% if search.has_modified_preferences %} badge{% endif %}">
      <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" stroke-width="2"
           stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
        <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
@@ -41,8 +42,11 @@
          </div>
        {% endif %}
        {% if 'shared' in preferences_form.editable_fields %}
-          <div class="form-group radio-group">
-            <div class="form-label{% if 'shared' in search.modified_params %} text-bold{% endif %}">Shared filter</div>
+          <div class="form-group radio-group" role="radiogroup" aria-labelledby="search-shared-label">
+            <label id="search-shared-label"
+                   class="form-label{% if 'shared' in search.modified_params %} text-bold{% endif %}">
+              Shared filter
+            </label>
            {% for radio in preferences_form.shared %}
              <label for="{{ radio.id_for_label }}" class="form-radio form-inline">
                {{ radio.tag }}
@@ -53,8 +57,11 @@
          </div>
        {% endif %}
        {% if 'unread' in preferences_form.editable_fields %}
-          <div class="form-group radio-group">
-            <div class="form-label{% if 'unread' in search.modified_params %} text-bold{% endif %}">Unread filter</div>
+          <div class="form-group radio-group" role="radiogroup" aria-labelledby="search-unread-label">
+            <label id="search-unread-label"
+                   class="form-label{% if 'unread' in search.modified_params %} text-bold{% endif %}">
+              Unread filter
+            </label>
            {% for radio in preferences_form.unread %}
              <label for="{{ radio.id_for_label }}" class="form-radio form-inline">
                {{ radio.tag }}
--- a/bookmarks/templates/bookmarks/shared.html
+++ b/bookmarks/templates/bookmarks/shared.html
@@ -4,16 +4,16 @@
 {% load bookmarks %}

 {% block content %}
-  <div class="bookmarks-page grid columns-md-1">
+  <div
+      class="bookmarks-page grid columns-md-1 {% if bookmark_list.collapse_side_panel %}collapse-side-panel{% endif %}">

    {# Bookmark list #}
-    <section class="content-area col-2">
-      <div class="content-area-header">
-        <h2>Shared bookmarks</h2>
+    <main class="main col-2" aria-labelledby="main-heading">
+      <div class="section-header">
+        <h1 id="main-heading">Shared bookmarks</h1>
        <div class="header-controls">
          {% bookmark_search bookmark_list.search mode='shared' %}
-          <button ld-tag-modal class="btn ml-2 show-md">Tags
-          </button>
+          <button ld-filter-drawer-trigger class="btn ml-2">Filters</button>
        </div>
      </div>

@@ -25,30 +25,29 @@
          {% include 'bookmarks/bookmark_list.html' %}
        </div>
      </form>
-    </section>
+    </main>

    {# Filters #}
-    <section class="content-area col-1 hide-md">
-      <div class="content-area-header">
-        <h2>User</h2>
-      </div>
-      <div>
-        {% user_select bookmark_list.search users %}
-        <br>
-      </div>
-      <div class="content-area-header">
-        <h2>Tags</h2>
-      </div>
-      <div id="tag-cloud-container">
-        {% include 'bookmarks/tag_cloud.html' %}
-      </div>
-    </section>
-
-    {# Bookmark details #}
-    <turbo-frame id="details-modal" target="_top">
-      {% if details %}
-        {% include 'bookmarks/details/modal.html' %}
-      {% endif %}
-    </turbo-frame>
+    <div class="side-panel col-1 hide-md">
+      <section aria-labelledby="user-heading">
+        <div class="section-header">
+          <h2 id="user-heading">User</h2>
+        </div>
+        <div>
+          {% user_select bookmark_list.search users %}
+          <br>
+        </div>
+      </section>
+      {% include 'bookmarks/tag_section.html' %}
+    </div>
  </div>
 {% endblock %}
+
+{% block overlays %}
+  {# Bookmark details #}
+  <turbo-frame id="details-modal" target="_top">
+    {% if details %}
+      {% include 'bookmarks/details/modal.html' %}
+    {% endif %}
+  </turbo-frame>
+{% endblock %}
--- a/bookmarks/templates/bookmarks/tag_section.html
+++ b/bookmarks/templates/bookmarks/tag_section.html
@@ -0,0 +1,8 @@
+<section aria-labelledby="tags-heading">
+  <div class="section-header">
+    <h2 id="tags-heading">Tags</h2>
+  </div>
+  <div id="tag-cloud-container">
+    {% include 'bookmarks/tag_cloud.html' %}
+  </div>
+</section>
--- a/bookmarks/templates/bundles/edit.html
+++ b/bookmarks/templates/bundles/edit.html
@@ -0,0 +1,33 @@
+{% extends 'bookmarks/layout.html' %}
+{% load widget_tweaks %}
+
+{% block head %}
+  {% with page_title="Edit bundle - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}
+
+{% block content %}
+  <div class="bundles-editor-page grid columns-md-1">
+    <main aria-labelledby="main-heading">
+      <div class="section-header">
+        <h1 id="main-heading">Edit bundle</h1>
+      </div>
+
+      {% include 'shared/messages.html' %}
+
+      <form id="bundle-form" action="{% url 'linkding:bundles.edit' bundle.id %}" method="post" novalidate>
+        {% csrf_token %}
+        {% include 'bundles/form.html' %}
+      </form>
+    </main>
+
+    <aside class="col-2" aria-labelledby="preview-heading">
+      <div class="section-header">
+        <h2 id="preview-heading">Preview</h2>
+      </div>
+
+      {% include 'bundles/preview.html' %}
+    </aside>
+  </div>
+{% endblock %}
--- a/bookmarks/templates/bundles/form.html
+++ b/bookmarks/templates/bundles/form.html
@@ -0,0 +1,91 @@
+{% load widget_tweaks %}
+
+<div class="form-group {% if form.name.errors %}has-error{% endif %}">
+  <label for="{{ form.name.id_for_label }}" class="form-label">Name</label>
+  {{ form.name|add_class:"form-input"|attr:"autocomplete:off"|attr:"placeholder: " }}
+  {% if form.name.errors %}
+    <div class="form-input-hint">
+      {{ form.name.errors }}
+    </div>
+  {% endif %}
+</div>
+
+<div class="form-group {% if form.search.errors %}has-error{% endif %}">
+  <label for="{{ form.search.id_for_label }}" class="form-label">Search</label>
+  {{ form.search|add_class:"form-input"|attr:"autocomplete:off"|attr:"placeholder: " }}
+  {% if form.search.errors %}
+    <div class="form-input-hint">
+      {{ form.search.errors }}
+    </div>
+  {% endif %}
+  <div class="form-input-hint">
+    Search terms to match bookmarks in this bundle.
+  </div>
+</div>
+
+<div class="form-group" ld-tag-autocomplete>
+  <label for="{{ form.any_tags.id_for_label }}" class="form-label">Tags</label>
+  {{ form.any_tags|add_class:"form-input"|attr:"autocomplete:off"|attr:"autocapitalize:off" }}
+  <div class="form-input-hint">
+    At least one of these tags must be present in a bookmark to match.
+  </div>
+</div>
+
+<div class="form-group" ld-tag-autocomplete>
+  <label for="{{ form.all_tags.id_for_label }}" class="form-label">Required tags</label>
+  {{ form.all_tags|add_class:"form-input"|attr:"autocomplete:off"|attr:"autocapitalize:off" }}
+  <div class="form-input-hint">
+    All of these tags must be present in a bookmark to match.
+  </div>
+</div>
+
+<div class="form-group" ld-tag-autocomplete>
+  <label for="{{ form.excluded_tags.id_for_label }}" class="form-label">Excluded tags</label>
+  {{ form.excluded_tags|add_class:"form-input"|attr:"autocomplete:off"|attr:"autocapitalize:off" }}
+  <div class="form-input-hint">
+    None of these tags must be present in a bookmark to match.
+  </div>
+</div>
+
+<div class="form-footer d-flex mt-4">
+  <input type="submit" name="save" value="Save" class="btn btn-primary btn-wide">
+  <a href="{% url 'linkding:bundles.index' %}" class="btn btn-wide ml-auto">Cancel</a>
+  <a href="{% url 'linkding:bundles.preview' %}" data-turbo-frame="preview" class="d-none" id="preview-link"></a>
+</div>
+
+<script>
+  (function init() {
+    const bundleForm = document.getElementById('bundle-form');
+    const previewLink = document.getElementById('preview-link');
+
+    let pendingUpdate;
+
+    function scheduleUpdate() {
+      if (pendingUpdate) {
+        clearTimeout(pendingUpdate);
+      }
+      pendingUpdate = setTimeout(() => {
+        // Ignore if link has been removed (e.g. form submit or navigation)
+        if (!previewLink.isConnected) {
+          return;
+        }
+
+        const baseUrl = previewLink.href.split('?')[0];
+        const params = new URLSearchParams();
+        const inputs = bundleForm.querySelectorAll('input[type="text"]:not([name="csrfmiddlewaretoken"]), textarea, select');
+
+        inputs.forEach(input => {
+          if (input.name && input.value.trim()) {
+            params.set(input.name, input.value.trim());
+          }
+        });
+
+        previewLink.href = params.toString() ? `${baseUrl}?${params.toString()}` : baseUrl;
+        previewLink.click();
+      }, 500)
+    }
+
+    bundleForm.addEventListener('input', scheduleUpdate);
+    bundleForm.addEventListener('change', scheduleUpdate);
+  })();
+</script>
--- a/bookmarks/templates/bundles/index.html
+++ b/bookmarks/templates/bundles/index.html
@@ -0,0 +1,124 @@
+{% extends "bookmarks/layout.html" %}
+
+{% block head %}
+  {% with page_title="Bundles - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}
+
+{% block content %}
+  <main class="bundles-page" aria-labelledby="main-heading">
+    <h1 id="main-heading">Bundles</h1>
+
+    {% include 'shared/messages.html' %}
+
+    {% if bundles %}
+      <form action="{% url 'linkding:bundles.action' %}" method="post">
+        {% csrf_token %}
+        <div class="item-list bundles">
+          {% for bundle in bundles %}
+            <div class="list-item" data-bundle-id="{{ bundle.id }}" draggable="true">
+              <div class="list-item-icon text-secondary">
+                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none"
+                     stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                  <path stroke="none" d="M0 0h24v24H0z" fill="none"/>
+                  <path d="M9 5m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0"/>
+                  <path d="M9 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0"/>
+                  <path d="M9 19m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0"/>
+                  <path d="M15 5m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0"/>
+                  <path d="M15 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0"/>
+                  <path d="M15 19m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0"/>
+                </svg>
+              </div>
+              <div class="list-item-text">
+                <span class="truncate">{{ bundle.name }}</span>
+              </div>
+              <div class="list-item-actions">
+                <a class="btn btn-link" href="{% url 'linkding:bundles.edit' bundle.id %}">Edit</a>
+                <button ld-confirm-button type="submit" name="remove_bundle" value="{{ bundle.id }}"
+                        class="btn btn-link">Remove
+                </button>
+              </div>
+            </div>
+          {% endfor %}
+        </div>
+        <input type="submit" name="move_bundle" value="" class="d-none">
+        <input type="hidden" name="move_position" value="">
+      </form>
+    {% else %}
+      <div class="empty">
+        <p class="empty-title h5">You have no bundles yet</p>
+        <p class="empty-subtitle">Create your first bundle to get started</p>
+      </div>
+    {% endif %}
+
+    <div class="mt-4">
+      <a href="{% url 'linkding:bundles.new' %}" class="btn btn-primary">Add new bundle</a>
+    </div>
+  </main>
+
+  <script>
+    (function init() {
+      const bundlesList = document.querySelector(".item-list.bundles");
+      if (!bundlesList) return;
+
+      let draggedElement = null;
+
+      const listItems = bundlesList.querySelectorAll('.list-item');
+      listItems.forEach((item) => {
+        item.addEventListener('dragstart', handleDragStart);
+        item.addEventListener('dragend', handleDragEnd);
+        item.addEventListener('dragover', handleDragOver);
+        item.addEventListener('dragenter', handleDragEnter);
+      });
+
+      function handleDragStart(e) {
+        draggedElement = this;
+
+        e.dataTransfer.effectAllowed = 'move';
+        e.dataTransfer.dropEffect = 'move';
+
+        this.classList.add('drag-start');
+        setTimeout(() => {
+          this.classList.remove('drag-start');
+          this.classList.add('dragging');
+        }, 0);
+      }
+
+      function handleDragEnd() {
+        this.classList.remove('dragging');
+
+        const moveBundleInput = document.querySelector('input[name="move_bundle"]');
+        const movePositionInput = document.querySelector('input[name="move_position"]');
+        moveBundleInput.value = draggedElement.getAttribute('data-bundle-id');
+        movePositionInput.value = Array.from(bundlesList.children).indexOf(draggedElement);
+
+        const form = this.closest('form');
+        form.requestSubmit(moveBundleInput);
+
+        draggedElement = null;
+      }
+
+      function handleDragOver(e) {
+        if (e.preventDefault) {
+          e.preventDefault();
+        }
+        return false;
+      }
+
+      function handleDragEnter() {
+        if (this !== draggedElement) {
+          const listItems = Array.from(bundlesList.children);
+          const draggedIndex = listItems.indexOf(draggedElement);
+          const currentIndex = listItems.indexOf(this);
+
+          if (draggedIndex < currentIndex) {
+            this.insertAdjacentElement('afterend', draggedElement);
+          } else {
+            this.insertAdjacentElement('beforebegin', draggedElement);
+          }
+        }
+      }
+    })();
+  </script>
+{% endblock %}
--- a/bookmarks/templates/bundles/new.html
+++ b/bookmarks/templates/bundles/new.html
@@ -0,0 +1,33 @@
+{% extends 'bookmarks/layout.html' %}
+{% load widget_tweaks %}
+
+{% block head %}
+  {% with page_title="New bundle - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}
+
+{% block content %}
+  <div class="bundles-editor-page grid columns-md-1">
+    <main aria-labelledby="main-heading">
+      <div class="section-header">
+        <h1 id="main-heading">New bundle</h1>
+      </div>
+
+      {% include 'shared/messages.html' %}
+
+      <form id="bundle-form" action="{% url 'linkding:bundles.new' %}" method="post" novalidate>
+        {% csrf_token %}
+        {% include 'bundles/form.html' %}
+      </form>
+    </main>
+
+    <aside class="col-2" aria-labelledby="preview-heading">
+      <div class="section-header">
+        <h2 id="preview-heading">Preview</h2>
+      </div>
+
+      {% include 'bundles/preview.html' %}
+    </aside>
+  </div>
+{% endblock %}
--- a/bookmarks/templates/bundles/preview.html
+++ b/bookmarks/templates/bundles/preview.html
@@ -0,0 +1,12 @@
+<turbo-frame id="preview">
+  {% if bookmark_list.is_empty %}
+    <div>
+      No bookmarks match the current bundle.
+    </div>
+  {% else %}
+    <div class="mb-4">
+      Found {{ bookmark_list.bookmarks_total }} bookmarks matching this bundle.
+    </div>
+    {% include 'bookmarks/bookmark_list.html' %}
+  {% endif %}
+</turbo-frame>
--- a/bookmarks/templates/django_registration/registration_complete.html
+++ b/bookmarks/templates/django_registration/registration_complete.html
@@ -1,8 +1,19 @@
 {% extends 'bookmarks/layout.html' %}
 {% load widget_tweaks %}

-{% block title %}Registration complete{% endblock %}
+{% block head %}
+  {% with page_title="Registration complete - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}

 {% block content %}
-  <p>Registration complete. You can now use the application.</p>
+  <main class="mx-auto width-50 width-md-100" aria-labelledby="main-heading">
+    <div class="section-header">
+      <h1 id="main-heading">Registration complete</h1>
+    </div>
+    <p class="text-success">
+      You can now use the application.
+    </p>
+  </main>
 {% endblock %}
--- a/bookmarks/templates/django_registration/registration_form.html
+++ b/bookmarks/templates/django_registration/registration_form.html
@@ -1,12 +1,16 @@
 {% extends 'bookmarks/layout.html' %}
 {% load widget_tweaks %}

-{% block title %}Registration{% endblock %}
+{% block head %}
+  {% with page_title="Registration - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}

 {% block content %}
-  <section class="content-area mx-auto width-50 width-md-100">
-    <div class="content-area-header">
-      <h2>Register</h2>
+  <main class="mx-auto width-50 width-md-100" aria-labelledby="main-heading">
+    <div class="section-header">
+      <h1 id="main-heading">Register</h1>
    </div>
    <form method="post" action="{% url 'django_registration_register' %}" novalidate>
      {% csrf_token %}
@@ -34,5 +38,5 @@
      <input type="submit" value="Register" class="btn btn-primary btn-wide">
      <input type="hidden" name="next" value="{{ next }}">
    </form>
-  </section>
+  </main>
 {% endblock %}
--- a/bookmarks/templates/opensearch.xml
+++ b/bookmarks/templates/opensearch.xml
@@ -0,0 +1,7 @@
+<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" xmlns:moz="http://www.mozilla.org/2006/browser/search/">
+    <ShortName>Linkding</ShortName>
+    <Description>Linkding</Description>
+    <InputEncoding>UTF-8</InputEncoding>
+    <Image width="16" height="16" type="image/x-icon">{{base_url}}static/favicon.ico</Image>
+    <Url type="text/html" template="{{ bookmarks_url }}?client=opensearch&amp;q={searchTerms}"/>
+</OpenSearchDescription>
--- a/bookmarks/templates/registration/login.html
+++ b/bookmarks/templates/registration/login.html
@@ -1,12 +1,16 @@
 {% extends 'bookmarks/layout.html' %}
 {% load widget_tweaks %}

-{% block title %}Login{% endblock %}
+{% block head %}
+  {% with page_title="Login - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}

 {% block content %}
-  <section class="content-area mx-auto width-50 width-md-100">
-    <div class="content-area-header">
-      <h2>Login</h2>
+  <main class="mx-auto width-50 width-md-100" aria-labelledby="main-heading">
+    <div class="section-header">
+      <h1 id="main-heading">Login</h1>
    </div>
    <form method="post" action="{% url 'login' %}">
      {% csrf_token %}
@@ -29,12 +33,12 @@
        <input type="submit" value="Login" class="btn btn-primary btn-wide"/>
        <input type="hidden" name="next" value="{{ next }}"/>
        {% if enable_oidc %}
-          <a class="btn btn-link" href="{% url 'oidc_authentication_init' %}">Login with OIDC</a>
+          <a class="btn btn-link" href="{% url 'oidc_authentication_init' %}" data-turbo="false">Login with OIDC</a>
        {% endif %}
        {% if allow_registration %}
          <a href="{% url 'django_registration_register' %}" class="btn btn-link">Register</a>
        {% endif %}
      </div>
    </form>
-  </section>
+  </main>
 {% endblock %}
--- a/bookmarks/templates/registration/password_change_done.html
+++ b/bookmarks/templates/registration/password_change_done.html
@@ -1,15 +1,19 @@
 {% extends 'bookmarks/layout.html' %}
 {% load widget_tweaks %}

-{% block title %}Password changed{% endblock %}
+{% block head %}
+  {% with page_title="Password changed - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}

 {% block content %}
-  <section class="content-area mx-auto width-50 width-md-100">
-    <div class="content-area-header">
-      <h2>Password Changed</h2>
+  <main class="mx-auto width-50 width-md-100" aria-labelledby="main-heading">
+    <div class="section-header">
+      <h1 id="main-heading">Password Changed</h1>
    </div>
    <p class="text-success">
      Your password was changed successfully.
    </p>
-  </section>
+  </main>
 {% endblock %}
--- a/bookmarks/templates/registration/password_change_form.html
+++ b/bookmarks/templates/registration/password_change_form.html
@@ -1,12 +1,16 @@
 {% extends 'bookmarks/layout.html' %}
 {% load widget_tweaks %}

-{% block title %}Change Password{% endblock %}
+{% block head %}
+  {% with page_title="Change password - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}

 {% block content %}
-  <section class="content-area mx-auto width-50 width-md-100">
-    <div class="content-area-header">
-      <h2>Change Password</h2>
+  <main class="mx-auto width-50 width-md-100" aria-labelledby="main-heading">
+    <div class="section-header">
+      <h1 id="main-heading">Change Password</h1>
    </div>
    <form method="post" action="{% url 'change_password' %}">
      {% csrf_token %}
@@ -41,5 +45,5 @@
      <br/>
      <input type="submit" value="Change Password" class="btn btn-primary btn-wide">
    </form>
-  </section>
+  </main>
 {% endblock %}
--- a/bookmarks/templates/settings/general.html
+++ b/bookmarks/templates/settings/general.html
@@ -1,10 +1,15 @@
 {% extends "bookmarks/layout.html" %}
 {% load widget_tweaks %}

-{% block content %}
-  <div class="settings-page">
+{% block head %}
+  {% with page_title="Settings - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}

-    {% include 'settings/nav.html' %}
+{% block content %}
+  <main class="settings-page" aria-labelledby="main-heading">
+    <h1 id="main-heading">Settings</h1>

    {# Profile section #}
    {% if success_message %}
@@ -14,12 +19,12 @@
      <div class="toast toast-error mb-4">{{ error_message }}</div>
    {% endif %}

-    <section class="content-area">
-      <h2>Profile</h2>
+    <section aria-labelledby="profile-heading">
+      <h2 id="profile-heading">Profile</h2>
      <p>
        <a href="{% url 'change_password' %}">Change password</a>
      </p>
-      <form action="{% url 'bookmarks:settings.update' %}" method="post" novalidate data-turbo="false">
+      <form action="{% url 'linkding:settings.update' %}" method="post" novalidate data-turbo="false">
        {% csrf_token %}
        <div class="form-group">
          <label for="{{ form.theme.id_for_label }}" class="form-label">Theme</label>
@@ -124,6 +129,25 @@
            visible without having to scroll to the end of the page first.
          </div>
        </div>
+        <div class="form-group">
+          <label for="{{ form.collapse_side_panel.id_for_label }}" class="form-checkbox">
+            {{ form.collapse_side_panel }}
+            <i class="form-icon"></i> Collapse side panel
+          </label>
+          <div class="form-input-hint">
+            When enabled, the tags side panel will be collapsed by default to give more space to the bookmark list.
+            Instead, the tags are shown in an expandable drawer.
+          </div>
+        </div>
+        <div class="form-group">
+          <label for="{{ form.hide_bundles.id_for_label }}" class="form-checkbox">
+            {{ form.hide_bundles }}
+            <i class="form-icon"></i> Hide bundles
+          </label>
+          <div class="form-input-hint">
+            Allows to hide the bundles in the side panel if you don't intend to use them.
+          </div>
+        </div>
        <div class="form-group">
          <label for="{{ form.tag_search.id_for_label }}" class="form-label">Tag search</label>
          {{ form.tag_search|add_class:"form-select width-25 width-sm-100" }}
@@ -219,7 +243,7 @@ reddit.com/r/Music music reddit</pre>
          <div class="form-input-hint">
            Makes shared bookmarks publicly accessible, without requiring a login.
            That means that anyone with a link to this instance can view shared bookmarks via the <a
-              href="{% url 'bookmarks:shared' %}">shared bookmarks page</a>.
+              href="{% url 'linkding:bookmarks.shared' %}">shared bookmarks page</a>.
          </div>
        </div>
        {% if has_snapshot_support %}
@@ -268,9 +292,9 @@ reddit.com/r/Music music reddit</pre>

    {# Global settings section #}
    {% if global_settings_form %}
-      <section class="content-area">
-        <h2>Global settings</h2>
-        <form action="{% url 'bookmarks:settings.update' %}" method="post" novalidate data-turbo="false">
+      <section aria-labelledby="global-settings-heading">
+        <h2 id="global-settings-heading">Global settings</h2>
+        <form action="{% url 'linkding:settings.update' %}" method="post" novalidate data-turbo="false">
          {% csrf_token %}
          <div class="form-group">
            <label for="{{ global_settings_form.landing_page.id_for_label }}" class="form-label">Landing page</label>
@@ -308,11 +332,11 @@ reddit.com/r/Music music reddit</pre>
    {% endif %}

    {# Import section #}
-    <section class="content-area">
-      <h2>Import</h2>
+    <section aria-labelledby="import-heading">
+      <h2 id="import-heading">Import</h2>
      <p>Import bookmarks and tags in the Netscape HTML format. This will execute a sync where new bookmarks are
        added and existing ones are updated.</p>
-      <form method="post" enctype="multipart/form-data" action="{% url 'bookmarks:settings.import' %}">
+      <form method="post" enctype="multipart/form-data" action="{% url 'linkding:settings.import' %}">
        {% csrf_token %}
        <div class="form-group">
          <label for="import_map_private_flag" class="form-checkbox">
@@ -336,10 +360,10 @@ reddit.com/r/Music music reddit</pre>
    </section>

    {# Export section #}
-    <section class="content-area">
-      <h2>Export</h2>
+    <section aria-labelledby="export-heading">
+      <h2 id="export-heading">Export</h2>
      <p>Export all bookmarks in Netscape HTML format.</p>
-      <a class="btn btn-primary" target="_blank" href="{% url 'bookmarks:settings.export' %}">Download (.html)</a>
+      <a class="btn btn-primary" target="_blank" href="{% url 'linkding:settings.export' %}">Download (.html)</a>
      {% if export_error %}
        <div class="has-error">
          <p class="form-input-hint">
@@ -350,8 +374,8 @@ reddit.com/r/Music music reddit</pre>
    </section>

    {# About section #}
-    <section class="content-area about">
-      <h2>About</h2>
+    <section class="about" aria-labelledby="about-heading">
+      <h2 id="about-heading">About</h2>
      <table class="table">
        <tbody>
        <tr>
@@ -374,7 +398,7 @@ reddit.com/r/Music music reddit</pre>
        </tbody>
      </table>
    </section>
-  </div>
+  </main>

  <script>
    (function init() {
--- a/bookmarks/templates/settings/integrations.html
+++ b/bookmarks/templates/settings/integrations.html
@@ -1,12 +1,17 @@
 {% extends "bookmarks/layout.html" %}

+{% block head %}
+  {% with page_title="Integrations - Linkding" %}
+    {{ block.super }}
+  {% endwith %}
+{% endblock %}
+
 {% block content %}
-  <div class="settings-page">
+  <main class="settings-page" aria-labelledby="main-heading">
+    <h1 id="main-heading">Integrations</h1>

-    {% include 'settings/nav.html' %}
-
-    <section class="content-area">
-      <h2>Browser Extension</h2>
+    <section aria-labelledby="browser-extension-heading">
+      <h2 id="browser-extension-heading">Browser Extension</h2>
      <p>The browser extension allows you to quickly add new bookmarks without leaving the page that you are on. The
        extension is available in the official extension stores for:</p>
      <ul>
@@ -31,8 +36,8 @@
         class="btn btn-primary">📎 Add bookmark</a>
    </section>

-    <section class="content-area">
-      <h2>REST API</h2>
+    <section aria-labelledby="rest-api-heading">
+      <h2 id="rest-api-heading">REST API</h2>
      <p>The following token can be used to authenticate 3rd-party applications against the REST API:</p>
      <div class="form-group">
        <div class="width-50 width-md-100">
@@ -48,8 +53,8 @@
      </p>
    </section>

-    <section class="content-area">
-      <h2>RSS Feeds</h2>
+    <section aria-labelledby="rss-feeds-heading">
+      <h2 id="rss-feeds-heading">RSS Feeds</h2>
      <p>The following URLs provide RSS feeds for your bookmarks:</p>
      <ul style="list-style-position: outside;">
        <li><a target="_blank" href="{{ all_feed_url }}">All bookmarks</a></li>
@@ -84,5 +89,5 @@
        After deleting the feed token, new URLs will be generated when you reload this settings page.
      </p>
    </section>
-  </div>
+  </main>
 {% endblock %}
--- a/bookmarks/templates/settings/nav.html
+++ b/bookmarks/templates/settings/nav.html
@@ -1,24 +0,0 @@
-{% url 'bookmarks:settings.index' as index_url %}
-{% url 'bookmarks:settings.general' as general_url %}
-{% url 'bookmarks:settings.integrations' as integrations_url %}
-
-<ul class="tab tab-block">
-    <li class="tab-item {% if request.get_full_path == index_url or request.get_full_path == general_url%}active{% endif %}">
-        <a href="{% url 'bookmarks:settings.general' %}">General</a>
-    </li>
-    <li class="tab-item {% if request.get_full_path == integrations_url %}active{% endif %}">
-        <a href="{% url 'bookmarks:settings.integrations' %}">Integrations</a>
-    </li>
-    {% if request.user.is_superuser %}
-    <li class="tab-item">
-        <a href="{% url 'admin:index' %}" target="_blank">
-            <span>Admin</span>
-            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" class="ml-1" style="width: 1.2em; height: 1.2em; vertical-align: -0.2em;">
-                <path d="M11 3a1 1 0 100 2h2.586l-6.293 6.293a1 1 0 101.414 1.414L15 6.414V9a1 1 0 102 0V4a1 1 0 00-1-1h-5z" />
-                <path d="M5 5a2 2 0 00-2 2v8a2 2 0 002 2h8a2 2 0 002-2v-3a1 1 0 10-2 0v3H5V7h3a1 1 0 000-2H5z" />
-            </svg>
-        </a>
-    </li>
-    {% endif %}
-</ul>
-<br>
--- a/bookmarks/templates/shared/error_list.html
+++ b/bookmarks/templates/shared/error_list.html
@@ -0,0 +1,6 @@
+{% load i18n %}
+
+{# Force rendering validation errors in English language to align with the rest of the app #}
+{% language 'en-us' %}
+{% if errors %}<ul class="{{ error_class }}"{% if errors.field_id %} id="{{ errors.field_id }}_error"{% endif %}>{% for error in errors %}<li>{{ error }}</li>{% endfor %}</ul>{% endif %}
+{% endlanguage %}
--- a/bookmarks/templates/shared/messages.html
+++ b/bookmarks/templates/shared/messages.html
@@ -0,0 +1,9 @@
+{% if messages %}
+  <div class="message-list">
+    {% for message in messages %}
+      <div class="toast toast-{{ message.tags }}" role="alert">
+        {{ message }}
+      </div>
+    {% endfor %}
+  </div>
+{% endif %}
--- a/bookmarks/templatetags/bookmarks.py
+++ b/bookmarks/templatetags/bookmarks.py
@@ -3,7 +3,6 @@ from typing import List
 from django import template

 from bookmarks.models import (
-    BookmarkForm,
    BookmarkSearch,
    BookmarkSearchForm,
    User,
@@ -12,23 +11,6 @@ from bookmarks.models import (
 register = template.Library()


-@register.inclusion_tag("bookmarks/form.html", name="bookmark_form", takes_context=True)
-def bookmark_form(
-    context,
-    form: BookmarkForm,
-    cancel_url: str,
-    bookmark_id: int = 0,
-    auto_close: bool = False,
-):
-    return {
-        "request": context["request"],
-        "form": form,
-        "auto_close": auto_close,
-        "bookmark_id": bookmark_id,
-        "cancel_url": cancel_url,
-    }
-
-
@register.inclusion_tag(
    "bookmarks/search.html", name="bookmark_search", takes_context=True
 )
--- a/bookmarks/templatetags/pagination.py
+++ b/bookmarks/templatetags/pagination.py
@@ -13,18 +13,21 @@ register = template.Library()
    "bookmarks/pagination.html", name="pagination", takes_context=True
 )
 def pagination(context, page: Page):
+    request = context["request"]
+    base_url = request.build_absolute_uri(request.path)
+
    # remove page number and details from query parameters
-    query_params = context["request"].GET.copy()
+    query_params = request.GET.copy()
    query_params.pop("page", None)
    query_params.pop("details", None)

    prev_link = (
-        _generate_link(query_params, page.previous_page_number())
+        _generate_link(base_url, query_params, page.previous_page_number())
        if page.has_previous()
        else None
    )
    next_link = (
-        _generate_link(query_params, page.next_page_number())
+        _generate_link(base_url, query_params, page.next_page_number())
        if page.has_next()
        else None
    )
@@ -37,7 +40,7 @@ def pagination(context, page: Page):
        if page_number == -1:
            page_links.append(None)
        else:
-            link = _generate_link(query_params, page_number)
+            link = _generate_link(base_url, query_params, page_number)
            page_links.append(
                {
                    "active": page_number == page.number,
@@ -92,6 +95,7 @@ def get_visible_page_numbers(current_page_number: int, num_pages: int) -> [int]:
    return reduce(append_page, visible_pages, [])


-def _generate_link(query_params: QueryDict, page_number: int) -> str:
+def _generate_link(base_url: str, query_params: QueryDict, page_number: int) -> str:
+    query_params = query_params.copy()
    query_params["page"] = page_number
-    return query_params.urlencode()
+    return f"{base_url}?{query_params.urlencode()}"
--- a/bookmarks/templatetags/shared.py
+++ b/bookmarks/templatetags/shared.py
@@ -142,5 +142,33 @@ def render_markdown(context, markdown_text):

    as_html = renderer.convert(markdown_text)
    sanitized_html = bleach.clean(as_html, markdown_tags, markdown_attrs)
+    linkified_html = bleach.linkify(sanitized_html)

-    return mark_safe(sanitized_html)
+    return mark_safe(linkified_html)
+
+
+def append_attr(widget, attr, value):
+    attrs = widget.attrs
+    if attrs.get(attr):
+        attrs[attr] += " " + value
+    else:
+        attrs[attr] = value
+
+
+@register.filter("form_field")
+def form_field(field, modifier_string):
+    modifiers = modifier_string.split(",")
+    has_errors = hasattr(field, "errors") and field.errors
+
+    if "validation" in modifiers and has_errors:
+        append_attr(field.field.widget, "aria-describedby", field.auto_id + "_error")
+    if "help" in modifiers:
+        append_attr(field.field.widget, "aria-describedby", field.auto_id + "_help")
+
+    # Some assistive technologies announce a field as invalid when it has the
+    # required attribute, even if the user has not interacted with the field
+    # yet. Set aria-invalid false to prevent this behavior.
+    if field.field.required and not has_errors:
+        append_attr(field.field.widget, "aria-invalid", "false")
+
+    return field
--- a/bookmarks/tests/helpers.py
+++ b/bookmarks/tests/helpers.py
@@ -1,22 +1,38 @@
-import random
+import gzip
 import logging
+import os
+import random
+import shutil
+import tempfile
 from datetime import datetime
 from typing import List
 from unittest import TestCase

 from bs4 import BeautifulSoup
-from django.contrib.auth.models import User
+from django.conf import settings
+from django.test import override_settings
 from django.utils import timezone
 from django.utils.crypto import get_random_string
 from rest_framework import status
+from rest_framework.authtoken.models import Token
 from rest_framework.test import APITestCase

-from bookmarks.models import Bookmark, BookmarkAsset, Tag
+from bookmarks.models import Bookmark, BookmarkAsset, BookmarkBundle, Tag, User


 class BookmarkFactoryMixin:
    user = None

+    def setup_temp_assets_dir(self):
+        self.assets_dir = tempfile.mkdtemp()
+        self.settings_override = override_settings(LD_ASSET_FOLDER=self.assets_dir)
+        self.settings_override.enable()
+        self.addCleanup(self.cleanup_temp_assets_dir)
+
+    def cleanup_temp_assets_dir(self):
+        shutil.rmtree(self.assets_dir)
+        self.settings_override.disable()
+
    def get_or_create_test_user(self):
        if self.user is None:
            self.user = User.objects.create_user(
@@ -150,6 +166,33 @@ class BookmarkFactoryMixin:
    def get_numbered_bookmark(self, title: str):
        return Bookmark.objects.get(title=title)

+    def setup_bundle(
+        self,
+        user: User = None,
+        name: str = None,
+        search: str = "",
+        any_tags: str = "",
+        all_tags: str = "",
+        excluded_tags: str = "",
+        order: int = 0,
+    ):
+        if user is None:
+            user = self.get_or_create_test_user()
+        if not name:
+            name = get_random_string(length=32)
+        bundle = BookmarkBundle(
+            name=name,
+            owner=user,
+            date_created=timezone.now(),
+            search=search,
+            any_tags=any_tags,
+            all_tags=all_tags,
+            excluded_tags=excluded_tags,
+            order=order,
+        )
+        bundle.save()
+        return bundle
+
    def setup_asset(
        self,
        bookmark: Bookmark,
@@ -182,6 +225,33 @@ class BookmarkFactoryMixin:
        asset.save()
        return asset

+    def setup_asset_file(self, asset: BookmarkAsset, file_content: str = "test"):
+        filepath = os.path.join(settings.LD_ASSET_FOLDER, asset.file)
+        if asset.gzip:
+            with gzip.open(filepath, "wb") as f:
+                f.write(file_content.encode())
+        else:
+            with open(filepath, "w") as f:
+                f.write(file_content)
+
+    def read_asset_file(self, asset: BookmarkAsset):
+        filepath = os.path.join(settings.LD_ASSET_FOLDER, asset.file)
+
+        if asset.gzip:
+            with gzip.open(filepath, "rb") as f:
+                return f.read()
+        else:
+            with open(filepath, "rb") as f:
+                return f.read()
+
+    def get_asset_filesize(self, asset: BookmarkAsset):
+        filepath = os.path.join(settings.LD_ASSET_FOLDER, asset.file)
+        return os.path.getsize(filepath) if os.path.exists(filepath) else 0
+
+    def has_asset_file(self, asset: BookmarkAsset):
+        filepath = os.path.join(settings.LD_ASSET_FOLDER, asset.file)
+        return os.path.exists(filepath)
+
    def setup_tag(self, user: User = None, name: str = ""):
        if user is None:
            user = self.get_or_create_test_user()
@@ -205,7 +275,7 @@ class BookmarkFactoryMixin:
        user.profile.save()
        return user

-    def get_tags_from_bookmarks(self, bookmarks: [Bookmark]):
+    def get_tags_from_bookmarks(self, bookmarks: list[Bookmark]):
        all_tags = []
        for bookmark in bookmarks:
            all_tags = all_tags + list(bookmark.tags.all())
@@ -290,6 +360,12 @@ class TagCloudTestMixin(TestCase, HtmlTestMixin):


 class LinkdingApiTestCase(APITestCase):
+    def authenticate(self):
+        self.api_token = Token.objects.get_or_create(
+            user=self.get_or_create_test_user()
+        )[0]
+        self.client.credentials(HTTP_AUTHORIZATION="Token " + self.api_token.key)
+
    def get(self, url, expected_status_code=status.HTTP_200_OK):
        response = self.client.get(url)
        self.assertEqual(response.status_code, expected_status_code)
--- a/bookmarks/tests/test_app_options.py
+++ b/bookmarks/tests/test_app_options.py
@@ -7,7 +7,7 @@ from django.test import TestCase

 class AppOptionsTestCase(TestCase):
    def setUp(self) -> None:
-        self.settings_module = importlib.import_module("siteroot.settings.base")
+        self.settings_module = importlib.import_module("bookmarks.settings.base")

    def test_empty_csrf_trusted_origins(self):
        module = importlib.reload(self.settings_module)
--- a/bookmarks/tests/test_assets_service.py
+++ b/bookmarks/tests/test_assets_service.py
@@ -0,0 +1,506 @@
+import datetime
+import gzip
+import os
+from datetime import timedelta
+from unittest import mock
+
+from django.core.files.uploadedfile import SimpleUploadedFile
+from django.test import TestCase
+from django.utils import timezone
+
+from bookmarks.models import BookmarkAsset
+from bookmarks.services import assets
+from bookmarks.tests.helpers import BookmarkFactoryMixin, disable_logging
+
+
+class AssetServiceTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        self.setup_temp_assets_dir()
+        self.get_or_create_test_user()
+
+        self.html_content = "<html><body><h1>Hello, World!</h1></body></html>"
+        self.mock_singlefile_create_snapshot_patcher = mock.patch(
+            "bookmarks.services.singlefile.create_snapshot",
+        )
+        self.mock_singlefile_create_snapshot = (
+            self.mock_singlefile_create_snapshot_patcher.start()
+        )
+        self.mock_singlefile_create_snapshot.side_effect = lambda url, filepath: (
+            open(filepath, "w").write(self.html_content)
+        )
+
+    def tearDown(self) -> None:
+        self.mock_singlefile_create_snapshot_patcher.stop()
+
+    def get_saved_snapshot_file(self):
+        # look up first file in the asset folder
+        files = os.listdir(self.assets_dir)
+        if files:
+            return files[0]
+
+    def test_create_snapshot_asset(self):
+        bookmark = self.setup_bookmark()
+
+        asset = assets.create_snapshot_asset(bookmark)
+
+        self.assertIsNotNone(asset)
+        self.assertEqual(asset.bookmark, bookmark)
+        self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_SNAPSHOT)
+        self.assertEqual(asset.content_type, BookmarkAsset.CONTENT_TYPE_HTML)
+        self.assertIn("HTML snapshot from", asset.display_name)
+        self.assertEqual(asset.status, BookmarkAsset.STATUS_PENDING)
+
+        # asset is not saved to the database
+        self.assertIsNone(asset.id)
+
+    def test_create_snapshot(self):
+        initial_modified = timezone.datetime(
+            2025, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+        )
+        bookmark = self.setup_bookmark(
+            url="https://example.com", modified=initial_modified
+        )
+        asset = assets.create_snapshot_asset(bookmark)
+        asset.save()
+        asset.date_created = timezone.datetime(
+            2023, 8, 11, 21, 45, 11, tzinfo=datetime.timezone.utc
+        )
+
+        assets.create_snapshot(asset)
+
+        expected_temp_filename = "snapshot_2023-08-11_214511_https___example.com.tmp"
+        expected_temp_filepath = os.path.join(self.assets_dir, expected_temp_filename)
+        expected_filename = "snapshot_2023-08-11_214511_https___example.com.html.gz"
+        expected_filepath = os.path.join(self.assets_dir, expected_filename)
+
+        # should call singlefile.create_snapshot with the correct arguments
+        self.mock_singlefile_create_snapshot.assert_called_once_with(
+            "https://example.com",
+            expected_temp_filepath,
+        )
+
+        # should create gzip file in asset folder
+        self.assertTrue(os.path.exists(expected_filepath))
+
+        # gzip file should contain the correct content
+        with gzip.open(expected_filepath, "rb") as gz_file:
+            self.assertEqual(gz_file.read().decode(), self.html_content)
+
+        # should remove temporary file
+        self.assertFalse(os.path.exists(expected_temp_filepath))
+
+        # should update asset status and file
+        asset.refresh_from_db()
+        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
+        self.assertEqual(asset.file, expected_filename)
+        self.assertTrue(asset.gzip)
+
+        # should update bookmark modified date
+        bookmark.refresh_from_db()
+
+    def test_create_snapshot_failure(self):
+        bookmark = self.setup_bookmark(url="https://example.com")
+        asset = assets.create_snapshot_asset(bookmark)
+        asset.save()
+
+        self.mock_singlefile_create_snapshot.side_effect = Exception
+
+        with self.assertRaises(Exception):
+            assets.create_snapshot(asset)
+
+        asset.refresh_from_db()
+        self.assertEqual(asset.status, BookmarkAsset.STATUS_FAILURE)
+
+    def test_create_snapshot_truncates_asset_file_name(self):
+        # Create a bookmark with a very long URL
+        long_url = "http://" + "a" * 300 + ".com"
+        bookmark = self.setup_bookmark(url=long_url)
+
+        asset = assets.create_snapshot_asset(bookmark)
+        asset.save()
+        assets.create_snapshot(asset)
+
+        saved_file = self.get_saved_snapshot_file()
+
+        self.assertEqual(192, len(saved_file))
+        self.assertTrue(saved_file.startswith("snapshot_"))
+        self.assertTrue(saved_file.endswith("aaaa.html.gz"))
+
+    def test_upload_snapshot(self):
+        initial_modified = timezone.datetime(
+            2025, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+        )
+        bookmark = self.setup_bookmark(
+            url="https://example.com", modified=initial_modified
+        )
+        asset = assets.upload_snapshot(bookmark, self.html_content.encode())
+
+        # should create gzip file in asset folder
+        saved_file_name = self.get_saved_snapshot_file()
+        self.assertIsNotNone(saved_file_name)
+
+        # verify file name
+        self.assertTrue(saved_file_name.startswith("snapshot_"))
+        self.assertTrue(saved_file_name.endswith("_https___example.com.html.gz"))
+
+        # gzip file should contain the correct content
+        with gzip.open(os.path.join(self.assets_dir, saved_file_name), "rb") as gz_file:
+            self.assertEqual(gz_file.read().decode(), self.html_content)
+
+        # should create asset
+        self.assertIsNotNone(asset.id)
+        self.assertEqual(asset.bookmark, bookmark)
+        self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_SNAPSHOT)
+        self.assertEqual(asset.content_type, BookmarkAsset.CONTENT_TYPE_HTML)
+        self.assertIn("HTML snapshot from", asset.display_name)
+        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
+        self.assertEqual(asset.file, saved_file_name)
+        self.assertTrue(asset.gzip)
+
+        # should update bookmark modified date
+        bookmark.refresh_from_db()
+        self.assertGreater(bookmark.date_modified, initial_modified)
+
+    def test_upload_snapshot_failure(self):
+        bookmark = self.setup_bookmark(url="https://example.com")
+
+        # make gzip.open raise an exception
+        with mock.patch("gzip.open") as mock_gzip_open:
+            mock_gzip_open.side_effect = Exception
+
+            with self.assertRaises(Exception):
+                assets.upload_snapshot(bookmark, b"invalid content")
+
+        # asset is not saved to the database
+        self.assertIsNone(BookmarkAsset.objects.first())
+
+    def test_upload_snapshot_truncates_asset_file_name(self):
+        # Create a bookmark with a very long URL
+        long_url = "http://" + "a" * 300 + ".com"
+        bookmark = self.setup_bookmark(url=long_url)
+
+        assets.upload_snapshot(bookmark, self.html_content.encode())
+
+        saved_file = self.get_saved_snapshot_file()
+
+        self.assertEqual(192, len(saved_file))
+        self.assertTrue(saved_file.startswith("snapshot_"))
+        self.assertTrue(saved_file.endswith("aaaa.html.gz"))
+
+    @disable_logging
+    def test_upload_asset(self):
+        initial_modified = timezone.datetime(
+            2025, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+        )
+        bookmark = self.setup_bookmark(modified=initial_modified)
+        file_content = b"test content"
+        upload_file = SimpleUploadedFile(
+            "test_file.txt", file_content, content_type="text/plain"
+        )
+
+        asset = assets.upload_asset(bookmark, upload_file)
+
+        # should create file in asset folder
+        saved_file_name = self.get_saved_snapshot_file()
+        self.assertIsNotNone(upload_file)
+
+        # verify file name
+        self.assertTrue(saved_file_name.startswith("upload_"))
+        self.assertTrue(saved_file_name.endswith("_test_file.txt.gz"))
+
+        # file should contain the correct content
+        self.assertEqual(self.read_asset_file(asset), file_content)
+
+        # should create asset
+        self.assertIsNotNone(asset.id)
+        self.assertEqual(asset.bookmark, bookmark)
+        self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_UPLOAD)
+        self.assertEqual(asset.content_type, upload_file.content_type)
+        self.assertEqual(asset.display_name, upload_file.name)
+        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
+        self.assertEqual(asset.file, saved_file_name)
+        self.assertEqual(asset.file_size, self.get_asset_filesize(asset))
+        self.assertTrue(asset.gzip)
+
+        # should update bookmark modified date
+        bookmark.refresh_from_db()
+        self.assertGreater(bookmark.date_modified, initial_modified)
+
+    @disable_logging
+    def test_upload_gzip_asset(self):
+        initial_modified = timezone.datetime(
+            2025, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+        )
+        bookmark = self.setup_bookmark(modified=initial_modified)
+        file_content = gzip.compress(b"<html>test content</html>")
+        upload_file = SimpleUploadedFile(
+            "test_file.html.gz", file_content, content_type="application/gzip"
+        )
+
+        asset = assets.upload_asset(bookmark, upload_file)
+
+        # should create file in asset folder
+        saved_file_name = self.get_saved_snapshot_file()
+        self.assertIsNotNone(upload_file)
+
+        # verify file name
+        self.assertTrue(saved_file_name.startswith("upload_"))
+        self.assertTrue(saved_file_name.endswith("_test_file.html.gz"))
+
+        # file should contain the correct content
+        self.assertEqual(self.read_asset_file(asset), file_content)
+
+        # should create asset
+        self.assertIsNotNone(asset.id)
+        self.assertEqual(asset.bookmark, bookmark)
+        self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_UPLOAD)
+        self.assertEqual(asset.content_type, "application/gzip")
+        self.assertEqual(asset.display_name, upload_file.name)
+        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
+        self.assertEqual(asset.file, saved_file_name)
+        self.assertEqual(asset.file_size, len(file_content))
+        self.assertFalse(asset.gzip)
+
+        # should update bookmark modified date
+        bookmark.refresh_from_db()
+        self.assertGreater(bookmark.date_modified, initial_modified)
+
+    @disable_logging
+    def test_upload_asset_truncates_asset_file_name(self):
+        # Create a bookmark with a very long URL
+        long_file_name = "a" * 300 + ".txt"
+        bookmark = self.setup_bookmark()
+
+        file_content = b"test content"
+        upload_file = SimpleUploadedFile(
+            long_file_name, file_content, content_type="text/plain"
+        )
+
+        assets.upload_asset(bookmark, upload_file)
+
+        saved_file = self.get_saved_snapshot_file()
+
+        self.assertEqual(192, len(saved_file))
+        self.assertTrue(saved_file.startswith("upload_"))
+        self.assertTrue(saved_file.endswith("aaaa.txt.gz"))
+
+    @disable_logging
+    def test_upload_asset_failure(self):
+        bookmark = self.setup_bookmark()
+        upload_file = SimpleUploadedFile("test_file.txt", b"test content")
+
+        # make open raise an exception
+        with mock.patch("builtins.open") as mock_open:
+            mock_open.side_effect = Exception
+
+            with self.assertRaises(Exception):
+                assets.upload_asset(bookmark, upload_file)
+
+        # asset is not saved to the database
+        self.assertIsNone(BookmarkAsset.objects.first())
+
+    def test_create_snapshot_updates_bookmark_latest_snapshot(self):
+        bookmark = self.setup_bookmark(url="https://example.com")
+        first_asset = assets.create_snapshot_asset(bookmark)
+        first_asset.save()
+
+        assets.create_snapshot(first_asset)
+        bookmark.refresh_from_db()
+
+        self.assertEqual(bookmark.latest_snapshot, first_asset)
+
+        second_asset = assets.create_snapshot_asset(bookmark)
+        second_asset.save()
+
+        assets.create_snapshot(second_asset)
+        bookmark.refresh_from_db()
+
+        self.assertEqual(bookmark.latest_snapshot, second_asset)
+
+    def test_upload_snapshot_updates_bookmark_latest_snapshot(self):
+        bookmark = self.setup_bookmark(url="https://example.com")
+
+        first_asset = assets.upload_snapshot(bookmark, self.html_content.encode())
+
+        bookmark.refresh_from_db()
+        self.assertEqual(bookmark.latest_snapshot, first_asset)
+
+        second_asset = assets.upload_snapshot(bookmark, self.html_content.encode())
+
+        bookmark.refresh_from_db()
+        self.assertEqual(bookmark.latest_snapshot, second_asset)
+        self.assertNotEqual(bookmark.latest_snapshot, first_asset)
+
+    def test_create_snapshot_failure_does_not_update_latest_snapshot(self):
+        # Create a bookmark with an existing latest_snapshot
+        bookmark = self.setup_bookmark(url="https://example.com")
+        initial_snapshot = assets.upload_snapshot(bookmark, self.html_content.encode())
+        bookmark.refresh_from_db()
+        self.assertEqual(bookmark.latest_snapshot, initial_snapshot)
+
+        # Create a new snapshot asset that will fail
+        failing_asset = assets.create_snapshot_asset(bookmark)
+        failing_asset.save()
+
+        # Make the snapshot creation fail
+        self.mock_singlefile_create_snapshot.side_effect = Exception(
+            "Snapshot creation failed"
+        )
+
+        # Attempt to create a snapshot (which will fail)
+        with self.assertRaises(Exception):
+            assets.create_snapshot(failing_asset)
+
+        # Verify that the bookmark's latest_snapshot is still the initial snapshot
+        bookmark.refresh_from_db()
+        self.assertEqual(bookmark.latest_snapshot, initial_snapshot)
+
+    def test_upload_snapshot_failure_does_not_update_latest_snapshot(self):
+        # Create a bookmark with an existing latest_snapshot
+        bookmark = self.setup_bookmark(url="https://example.com")
+        initial_snapshot = assets.upload_snapshot(bookmark, self.html_content.encode())
+        bookmark.refresh_from_db()
+        self.assertEqual(bookmark.latest_snapshot, initial_snapshot)
+
+        # Make the gzip.open function fail
+        with mock.patch("gzip.open") as mock_gzip_open:
+            mock_gzip_open.side_effect = Exception("Upload failed")
+
+            # Attempt to upload a snapshot (which will fail)
+            with self.assertRaises(Exception):
+                assets.upload_snapshot(bookmark, b"New content")
+
+        # Verify that the bookmark's latest_snapshot is still the initial snapshot
+        bookmark.refresh_from_db()
+        self.assertEqual(bookmark.latest_snapshot, initial_snapshot)
+
+    def test_remove_latest_snapshot_updates_bookmark(self):
+        # Create a bookmark with multiple snapshots
+        bookmark = self.setup_bookmark()
+
+        # Create base time (1 hour ago)
+        base_time = timezone.now() - timedelta(hours=1)
+
+        # Create three snapshots with explicitly different dates
+        old_asset = self.setup_asset(
+            bookmark=bookmark,
+            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
+            status=BookmarkAsset.STATUS_COMPLETE,
+            file="old_snapshot.html.gz",
+            date_created=base_time,
+        )
+        self.setup_asset_file(old_asset)
+
+        middle_asset = self.setup_asset(
+            bookmark=bookmark,
+            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
+            status=BookmarkAsset.STATUS_COMPLETE,
+            file="middle_snapshot.html.gz",
+            date_created=base_time + timedelta(minutes=30),
+        )
+        self.setup_asset_file(middle_asset)
+
+        latest_asset = self.setup_asset(
+            bookmark=bookmark,
+            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
+            status=BookmarkAsset.STATUS_COMPLETE,
+            file="latest_snapshot.html.gz",
+            date_created=base_time + timedelta(minutes=60),
+        )
+        self.setup_asset_file(latest_asset)
+
+        # Set the latest asset as the bookmark's latest_snapshot
+        bookmark.latest_snapshot = latest_asset
+        bookmark.save()
+
+        # Delete the latest snapshot
+        assets.remove_asset(latest_asset)
+        bookmark.refresh_from_db()
+
+        # Verify that middle_asset is now the latest_snapshot
+        self.assertEqual(bookmark.latest_snapshot, middle_asset)
+
+        # Delete the middle snapshot
+        assets.remove_asset(middle_asset)
+        bookmark.refresh_from_db()
+
+        # Verify that old_asset is now the latest_snapshot
+        self.assertEqual(bookmark.latest_snapshot, old_asset)
+
+        # Delete the last snapshot
+        assets.remove_asset(old_asset)
+        bookmark.refresh_from_db()
+
+        # Verify that latest_snapshot is now None
+        self.assertIsNone(bookmark.latest_snapshot)
+
+    def test_remove_non_latest_snapshot_does_not_affect_bookmark(self):
+        # Create a bookmark with multiple snapshots
+        bookmark = self.setup_bookmark()
+
+        # Create base time (1 hour ago)
+        base_time = timezone.now() - timedelta(hours=1)
+
+        # Create two snapshots with explicitly different dates
+        old_asset = self.setup_asset(
+            bookmark=bookmark,
+            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
+            status=BookmarkAsset.STATUS_COMPLETE,
+            file="old_snapshot.html.gz",
+            date_created=base_time,
+        )
+        self.setup_asset_file(old_asset)
+
+        latest_asset = self.setup_asset(
+            bookmark=bookmark,
+            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
+            status=BookmarkAsset.STATUS_COMPLETE,
+            file="latest_snapshot.html.gz",
+            date_created=base_time + timedelta(minutes=30),
+        )
+        self.setup_asset_file(latest_asset)
+
+        # Set the latest asset as the bookmark's latest_snapshot
+        bookmark.latest_snapshot = latest_asset
+        bookmark.save()
+
+        # Delete the old snapshot (not the latest)
+        assets.remove_asset(old_asset)
+        bookmark.refresh_from_db()
+
+        # Verify that latest_snapshot hasn't changed
+        self.assertEqual(bookmark.latest_snapshot, latest_asset)
+
+    @disable_logging
+    def test_remove_asset(self):
+        initial_modified = timezone.datetime(
+            2025, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+        )
+        bookmark = self.setup_bookmark(modified=initial_modified)
+        file_content = b"test content for removal"
+        upload_file = SimpleUploadedFile(
+            "test_remove_file.txt", file_content, content_type="text/plain"
+        )
+
+        asset = assets.upload_asset(bookmark, upload_file)
+        asset_filepath = os.path.join(self.assets_dir, asset.file)
+
+        # Verify asset and file exist
+        self.assertTrue(BookmarkAsset.objects.filter(id=asset.id).exists())
+        self.assertTrue(os.path.exists(asset_filepath))
+
+        bookmark.date_modified = initial_modified
+        bookmark.save()
+
+        # Remove the asset
+        assets.remove_asset(asset)
+
+        # Verify asset is removed from DB
+        self.assertFalse(BookmarkAsset.objects.filter(id=asset.id).exists())
+        # Verify file is removed from disk
+        self.assertFalse(os.path.exists(asset_filepath))
+
+        # Verify bookmark modified date is updated
+        bookmark.refresh_from_db()
+        self.assertGreater(bookmark.date_modified, initial_modified)
--- a/Show More
+++ b/Show More