Nope, not supported. hmm

Bumps the actions group with 4 updates: [actions/upload-artifact](https://github.com/actions/upload-artifact), [actions/cache](https://github.com/actions/cache), [actions/download-artifact](https://github.com/actions/download-artifact) and [dessant/lock-threads](https://github.com/dessant/lock-threads).


Updates `actions/upload-artifact` from 5 to 6
- [Release notes](https://github.com/actions/upload-artifact/releases)
- [Commits](https://github.com/actions/upload-artifact/compare/v5...v6)

Updates `actions/cache` from 4 to 5
- [Release notes](https://github.com/actions/cache/releases)
- [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md)
- [Commits](https://github.com/actions/cache/compare/v4...v5)

Updates `actions/download-artifact` from 6 to 7
- [Release notes](https://github.com/actions/download-artifact/releases)
- [Commits](https://github.com/actions/download-artifact/compare/v6...v7)

Updates `dessant/lock-threads` from 5 to 6
- [Release notes](https://github.com/dessant/lock-threads/releases)
- [Changelog](https://github.com/dessant/lock-threads/blob/main/CHANGELOG.md)
- [Commits](https://github.com/dessant/lock-threads/compare/v5...v6)

---
updated-dependencies:
- dependency-name: actions/upload-artifact
  dependency-version: '6'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: actions
- dependency-name: actions/cache
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: actions
- dependency-name: actions/download-artifact
  dependency-version: '7'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: actions
- dependency-name: dessant/lock-threads
  dependency-version: '6'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/ci-backend.yml

@@ -0,0 +1,104 @@
+name: Backend Tests
+on:
+  push:
+    branches-ignore:
+      - 'translations**'
+    paths:
+      - 'src/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      - 'docker/compose/docker-compose.ci-test.yml'
+      - '.github/workflows/ci-backend.yml'
+  pull_request:
+    branches-ignore:
+      - 'translations**'
+    paths:
+      - 'src/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      - 'docker/compose/docker-compose.ci-test.yml'
+      - '.github/workflows/ci-backend.yml'
+  workflow_dispatch:
+concurrency:
+  group: backend-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+env:
+  DEFAULT_UV_VERSION: "0.9.x"
+  NLTK_DATA: "/usr/share/nltk_data"
+jobs:
+  test:
+    name: "Python ${{ matrix.python-version }}"
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.11', '3.12']
+      fail-fast: false
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Start containers
+        run: |
+          docker compose --file docker/compose/docker-compose.ci-test.yml pull --quiet
+          docker compose --file docker/compose/docker-compose.ci-test.yml up --detach
+      - name: Set up Python
+        id: setup-python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "${{ matrix.python-version }}"
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: ${{ env.DEFAULT_UV_VERSION }}
+          enable-cache: true
+          python-version: ${{ steps.setup-python.outputs.python-version }}
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -qq --no-install-recommends \
+            unpaper tesseract-ocr imagemagick ghostscript libzbar0 poppler-utils
+      - name: Configure ImageMagick
+        run: |
+          sudo cp docker/rootfs/etc/ImageMagick-6/paperless-policy.xml /etc/ImageMagick-6/policy.xml
+      - name: Install Python dependencies
+        run: |
+          uv sync \
+            --python ${{ steps.setup-python.outputs.python-version }} \
+            --group testing \
+            --frozen
+      - name: List installed Python dependencies
+        run: |
+          uv pip list
+      - name: Install NLTK data
+        run: |
+          uv run python -m nltk.downloader punkt punkt_tab snowball_data stopwords -d ${{ env.NLTK_DATA }}
+      - name: Run tests
+        env:
+          NLTK_DATA: ${{ env.NLTK_DATA }}
+          PAPERLESS_CI_TEST: 1
+          PAPERLESS_MAIL_TEST_HOST: ${{ secrets.TEST_MAIL_HOST }}
+          PAPERLESS_MAIL_TEST_USER: ${{ secrets.TEST_MAIL_USER }}
+          PAPERLESS_MAIL_TEST_PASSWD: ${{ secrets.TEST_MAIL_PASSWD }}
+        run: |
+          uv run \
+            --python ${{ steps.setup-python.outputs.python-version }} \
+            --dev \
+            --frozen \
+            pytest
+      - name: Upload test results to Codecov
+        if: always()
+        uses: codecov/codecov-action@v5
+        with:
+          flags: backend-python-${{ matrix.python-version }}
+          files: junit.xml
+          report_type: test_results
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          flags: backend-python-${{ matrix.python-version }}
+          files: coverage.xml
+          report_type: coverage
+      - name: Stop containers
+        if: always()
+        run: |
+          docker compose --file docker/compose/docker-compose.ci-test.yml logs
+          docker compose --file docker/compose/docker-compose.ci-test.yml down

.github/workflows/ci-docker.yml

@@ -0,0 +1,233 @@
+name: Docker Build
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+      - 'v[0-9]+.[0-9]+.[0-9]+-beta.rc[0-9]+'
+    branches:
+      - dev
+      - beta
+  pull_request:
+    branches:
+      - dev
+      - main
+  workflow_dispatch:
+concurrency:
+  group: docker-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+env:
+  REGISTRY: ghcr.io
+jobs:
+  build-arch:
+    name: Build ${{ matrix.arch }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-24.04
+            arch: amd64
+            platform: linux/amd64
+          - runner: ubuntu-24.04-arm
+            arch: arm64
+            platform: linux/arm64
+    runs-on: ${{ matrix.runner }}
+    permissions:
+      contents: read
+      packages: write
+    outputs:
+      can-push: ${{ steps.check-push.outputs.can-push }}
+      push-external: ${{ steps.check-push.outputs.push-external }}
+      repository: ${{ steps.repo.outputs.name }}
+      ref-name: ${{ steps.ref.outputs.name }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6.0.1
+      - name: Determine ref name
+        id: ref
+        run: |
+          ref_name="${GITHUB_HEAD_REF:-$GITHUB_REF_NAME}"
+          # Sanitize by replacing / with - for cache keys
+          cache_ref="${ref_name//\//-}"
+
+          echo "ref_name=${ref_name}"
+          echo "cache_ref=${cache_ref}"
+
+          echo "name=${ref_name}" >> $GITHUB_OUTPUT
+          echo "cache-ref=${cache_ref}" >> $GITHUB_OUTPUT
+      - name: Check push permissions
+        id: check-push
+        env:
+          REF_NAME: ${{ steps.ref.outputs.name }}
+        run: |
+          # can-push: Can we push to GHCR?
+          # True for: pushes, or PRs from the same repo (not forks)
+          can_push=${{ github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository }}
+          echo "can-push=${can_push}"
+          echo "can-push=${can_push}" >> $GITHUB_OUTPUT
+
+          # push-external: Should we also push to Docker Hub and Quay.io?
+          # Only for main repo on dev/beta branches or version tags
+          push_external="false"
+          if [[ "${can_push}" == "true" && "${{ github.repository_owner }}" == "paperless-ngx" ]]; then
+            case "${REF_NAME}" in
+              dev|beta)
+                push_external="true"
+                ;;
+            esac
+            case "${{ github.ref }}" in
+              refs/tags/v*|*beta.rc*)
+                push_external="true"
+                ;;
+            esac
+          fi
+          echo "push-external=${push_external}"
+          echo "push-external=${push_external}" >> $GITHUB_OUTPUT
+      - name: Set repository name
+        id: repo
+        run: |
+          repo_name="${{ github.repository }}"
+          repo_name="${repo_name,,}"
+
+          echo "repository=${repo_name}"
+          echo "name=${repo_name}" >> $GITHUB_OUTPUT
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3.12.0
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3.6.0
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Docker metadata
+        id: docker-meta
+        uses: docker/metadata-action@v5.10.0
+        with:
+          images: |
+            ${{ env.REGISTRY }}/${{ steps.repo.outputs.name }}
+          tags: |
+            type=ref,event=branch
+            type=raw,value=${{ steps.ref.outputs.name }},enable=${{ github.event_name == 'pull_request' }}
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+      - name: Build and push by digest
+        id: build
+        uses: docker/build-push-action@v6.18.0
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: ${{ matrix.platform }}
+          labels: ${{ steps.docker-meta.outputs.labels }}
+          build-args: |
+            PNGX_TAG_VERSION=${{ steps.docker-meta.outputs.version }}
+          outputs: type=image,name=${{ env.REGISTRY }}/${{ steps.repo.outputs.name }},push-by-digest=true,name-canonical=true,push=${{ steps.check-push.outputs.can-push }}
+          cache-from: |
+            type=registry,ref=${{ env.REGISTRY }}/${{ steps.repo.outputs.name }}/cache/app:${{ steps.ref.outputs.cache-ref }}-${{ matrix.arch }}
+            type=registry,ref=${{ env.REGISTRY }}/${{ steps.repo.outputs.name }}/cache/app:dev-${{ matrix.arch }}
+          cache-to: ${{ steps.check-push.outputs.can-push == 'true' && format('type=registry,mode=max,ref={0}/{1}/cache/app:{2}-{3}', env.REGISTRY, steps.repo.outputs.name, steps.ref.outputs.cache-ref, matrix.arch) || '' }}
+      - name: Export digest
+        if: steps.check-push.outputs.can-push == 'true'
+        run: |
+          mkdir -p /tmp/digests
+          digest="${{ steps.build.outputs.digest }}"
+          echo "digest=${digest}"
+          touch "/tmp/digests/${digest#sha256:}"
+      - name: Upload digest
+        if: steps.check-push.outputs.can-push == 'true'
+        uses: actions/upload-artifact@v6.0.0
+        with:
+          name: digests-${{ matrix.arch }}
+          path: /tmp/digests/*
+          if-no-files-found: error
+          retention-days: 1
+  merge-and-push:
+    name: Merge and Push Manifest
+    runs-on: ubuntu-24.04
+    needs: build-arch
+    if: needs.build-arch.outputs.can-push == 'true'
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - name: Download digests
+        uses: actions/download-artifact@v7.0.0
+        with:
+          path: /tmp/digests
+          pattern: digests-*
+          merge-multiple: true
+      - name: List digests
+        run: |
+          echo "Downloaded digests:"
+          ls -la /tmp/digests/
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3.12.0
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3.6.0
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Login to Docker Hub
+        if: needs.build-arch.outputs.push-external == 'true'
+        uses: docker/login-action@v3.6.0
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Login to Quay.io
+        if: needs.build-arch.outputs.push-external == 'true'
+        uses: docker/login-action@v3.6.0
+        with:
+          registry: quay.io
+          username: ${{ secrets.QUAY_USERNAME }}
+          password: ${{ secrets.QUAY_ROBOT_TOKEN }}
+      - name: Docker metadata
+        id: docker-meta
+        uses: docker/metadata-action@v5.10.0
+        with:
+          images: |
+            ${{ env.REGISTRY }}/${{ needs.build-arch.outputs.repository }}
+          tags: |
+            type=ref,event=branch
+            type=raw,value=${{ needs.build-arch.outputs.ref-name }},enable=${{ github.event_name == 'pull_request' }}
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+      - name: Create manifest list and push
+        working-directory: /tmp/digests
+        env:
+          REPOSITORY: ${{ needs.build-arch.outputs.repository }}
+        run: |
+          tags=$(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "${DOCKER_METADATA_OUTPUT_JSON}")
+
+          digests=""
+          for digest in *; do
+            digests+="${{ env.REGISTRY }}/${REPOSITORY}@sha256:${digest} "
+          done
+
+          echo "Creating manifest with tags: ${tags}"
+          echo "From digests: ${digests}"
+
+          docker buildx imagetools create ${tags} ${digests}
+      - name: Inspect image
+        run: |
+          docker buildx imagetools inspect ${{ fromJSON(steps.docker-meta.outputs.json).tags[0] }}
+      - name: Copy to Docker Hub
+        if: needs.build-arch.outputs.push-external == 'true'
+        env:
+          TAGS: ${{ steps.docker-meta.outputs.tags }}
+          GHCR_REPO: ${{ env.REGISTRY }}/${{ needs.build-arch.outputs.repository }}
+        run: |
+          for tag in ${TAGS}; do
+            dockerhub_tag="${tag/${GHCR_REPO}/docker.io/paperlessngx/paperless-ngx}"
+            echo "Copying ${tag} to ${dockerhub_tag}"
+            skopeo copy --all "docker://${tag}" "docker://${dockerhub_tag}"
+          done
+      - name: Copy to Quay.io
+        if: needs.build-arch.outputs.push-external == 'true'
+        env:
+          TAGS: ${{ steps.docker-meta.outputs.tags }}
+          GHCR_REPO: ${{ env.REGISTRY }}/${{ needs.build-arch.outputs.repository }}
+        run: |
+          for tag in ${TAGS}; do
+            quay_tag="${tag/${GHCR_REPO}/quay.io/paperlessngx/paperless-ngx}"
+            echo "Copying ${tag} to ${quay_tag}"
+            skopeo copy --all "docker://${tag}" "docker://${quay_tag}"
+          done

.github/workflows/ci-docs.yml

@@ -0,0 +1,88 @@
+name: Documentation
+on:
+  push:
+    branches:
+      - main
+      - dev
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+      - '.github/workflows/ci-docs.yml'
+  pull_request:
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+      - '.github/workflows/ci-docs.yml'
+  workflow_dispatch:
+concurrency:
+  group: docs-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+env:
+  DEFAULT_UV_VERSION: "0.9.x"
+  DEFAULT_PYTHON_VERSION: "3.11"
+jobs:
+  build:
+    name: Build Documentation
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Set up Python
+        id: setup-python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: ${{ env.DEFAULT_UV_VERSION }}
+          enable-cache: true
+          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
+      - name: Install Python dependencies
+        run: |
+          uv sync --python ${{ steps.setup-python.outputs.python-version }} --dev --frozen
+      - name: Build documentation
+        run: |
+          uv run \
+            --python ${{ steps.setup-python.outputs.python-version }} \
+            --dev \
+            --frozen \
+            mkdocs build --config-file ./mkdocs.yml
+      - name: Upload artifact
+        uses: actions/upload-artifact@v6
+        with:
+          name: documentation
+          path: site/
+          retention-days: 7
+  deploy:
+    name: Deploy Documentation
+    needs: build
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Set up Python
+        id: setup-python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: ${{ env.DEFAULT_UV_VERSION }}
+          enable-cache: true
+          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
+      - name: Install Python dependencies
+        run: |
+          uv sync --python ${{ steps.setup-python.outputs.python-version }} --dev --frozen
+      - name: Deploy documentation
+        run: |
+          echo "docs.paperless-ngx.com" > "${{ github.workspace }}/docs/CNAME"
+          git config --global user.name "${{ github.actor }}"
+          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
+          uv run \
+            --python ${{ steps.setup-python.outputs.python-version }} \
+            --dev \
+            --frozen \
+            mkdocs gh-deploy --force --no-history

.github/workflows/ci-frontend.yml

@@ -0,0 +1,189 @@
+name: Frontend Tests
+on:
+  push:
+    branches-ignore:
+      - 'translations**'
+    paths:
+      - 'src-ui/**'
+      - '.github/workflows/ci-frontend.yml'
+  pull_request:
+    branches-ignore:
+      - 'translations**'
+    paths:
+      - 'src-ui/**'
+      - '.github/workflows/ci-frontend.yml'
+  workflow_dispatch:
+concurrency:
+  group: frontend-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+jobs:
+  install-dependencies:
+    name: Install Dependencies
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+      - name: Use Node.js 20
+        uses: actions/setup-node@v6
+        with:
+          node-version: 20.x
+          cache: 'pnpm'
+          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
+      - name: Cache frontend dependencies
+        id: cache-frontend-deps
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.pnpm-store
+            ~/.cache
+          key: ${{ runner.os }}-frontend-${{ hashFiles('src-ui/pnpm-lock.yaml') }}
+      - name: Install dependencies
+        run: cd src-ui && pnpm install
+  lint:
+    name: Lint
+    needs: install-dependencies
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+      - name: Use Node.js 20
+        uses: actions/setup-node@v6
+        with:
+          node-version: 20.x
+          cache: 'pnpm'
+          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
+      - name: Cache frontend dependencies
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.pnpm-store
+            ~/.cache
+          key: ${{ runner.os }}-frontend-${{ hashFiles('src-ui/pnpm-lock.yaml') }}
+      - name: Re-link Angular CLI
+        run: cd src-ui && pnpm link @angular/cli
+      - name: Run lint
+        run: cd src-ui && pnpm run lint
+  unit-tests:
+    name: "Unit Tests (${{ matrix.shard-index }}/${{ matrix.shard-count }})"
+    needs: install-dependencies
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [20.x]
+        shard-index: [1, 2, 3, 4]
+        shard-count: [4]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+      - name: Use Node.js 20
+        uses: actions/setup-node@v6
+        with:
+          node-version: 20.x
+          cache: 'pnpm'
+          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
+      - name: Cache frontend dependencies
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.pnpm-store
+            ~/.cache
+          key: ${{ runner.os }}-frontend-${{ hashFiles('src-ui/pnpm-lock.yaml') }}
+      - name: Re-link Angular CLI
+        run: cd src-ui && pnpm link @angular/cli
+      - name: Run Jest unit tests
+        run: cd src-ui && pnpm run test --max-workers=2 --shard=${{ matrix.shard-index }}/${{ matrix.shard-count }}
+      - name: Upload test results to Codecov
+        if: always()
+        uses: codecov/codecov-action@v5
+        with:
+          flags: frontend-node-${{ matrix.node-version }}
+          directory: src-ui/
+          report_type: test_results
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          flags: frontend-node-${{ matrix.node-version }}
+          directory: src-ui/coverage/
+  e2e-tests:
+    name: "E2E Tests (${{ matrix.shard-index }}/${{ matrix.shard-count }})"
+    needs: install-dependencies
+    runs-on: ubuntu-24.04
+    container: mcr.microsoft.com/playwright:v1.57.0-noble
+    env:
+      PLAYWRIGHT_BROWSERS_PATH: /ms-playwright
+      PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: 1
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [20.x]
+        shard-index: [1, 2]
+        shard-count: [2]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+      - name: Use Node.js 20
+        uses: actions/setup-node@v6
+        with:
+          node-version: 20.x
+          cache: 'pnpm'
+          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
+      - name: Cache frontend dependencies
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.pnpm-store
+            ~/.cache
+          key: ${{ runner.os }}-frontend-${{ hashFiles('src-ui/pnpm-lock.yaml') }}
+      - name: Re-link Angular CLI
+        run: cd src-ui && pnpm link @angular/cli
+      - name: Install dependencies
+        run: cd src-ui && pnpm install --no-frozen-lockfile
+      - name: Run Playwright E2E tests
+        run: cd src-ui && pnpm exec playwright test --shard ${{ matrix.shard-index }}/${{ matrix.shard-count }}
+  bundle-analysis:
+    name: Bundle Analysis
+    needs: [unit-tests, e2e-tests]
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+      - name: Use Node.js 20
+        uses: actions/setup-node@v6
+        with:
+          node-version: 20.x
+          cache: 'pnpm'
+          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
+      - name: Cache frontend dependencies
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.pnpm-store
+            ~/.cache
+          key: ${{ runner.os }}-frontend-${{ hashFiles('src-ui/pnpm-lock.yaml') }}
+      - name: Re-link Angular CLI
+        run: cd src-ui && pnpm link @angular/cli
+      - name: Build and analyze
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        run: cd src-ui && pnpm run build --configuration=production

.github/workflows/ci-lint.yml

@@ -0,0 +1,24 @@
+name: Lint
+on:
+  push:
+    branches-ignore:
+      - 'translations**'
+  pull_request:
+    branches-ignore:
+      - 'translations**'
+concurrency:
+  group: lint-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+jobs:
+  pre-commit:
+    name: Pre-commit Checks
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Install Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+      - name: Run pre-commit
+        uses: pre-commit/action@v3.0.1

.github/workflows/ci-release.yml

@@ -0,0 +1,237 @@
+name: Release
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+      - 'v[0-9]+.[0-9]+.[0-9]+-beta.rc[0-9]+'
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: false
+env:
+  DEFAULT_UV_VERSION: "0.9.x"
+  DEFAULT_PYTHON_VERSION: "3.11"
+jobs:
+  wait-for-docker:
+    name: Wait for Docker Build
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Wait for Docker build
+        uses: lewagon/wait-on-check-action@v1.4.1
+        with:
+          ref: ${{ github.sha }}
+          check-name: 'Build Docker Image'
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          wait-interval: 60
+  build-release:
+    name: Build Release
+    needs: wait-for-docker
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      # ---- Frontend Build ----
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+      - name: Use Node.js 20
+        uses: actions/setup-node@v6
+        with:
+          node-version: 20.x
+          cache: 'pnpm'
+          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
+      - name: Install frontend dependencies
+        run: cd src-ui && pnpm install
+      - name: Build frontend
+        run: cd src-ui && pnpm run build --configuration production
+      # ---- Backend Setup ----
+      - name: Set up Python
+        id: setup-python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: ${{ env.DEFAULT_UV_VERSION }}
+          enable-cache: true
+          python-version: ${{ steps.setup-python.outputs.python-version }}
+      - name: Install Python dependencies
+        run: |
+          uv sync --python ${{ steps.setup-python.outputs.python-version }} --dev --frozen
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -qq --no-install-recommends gettext liblept5
+      # ---- Build Documentation ----
+      - name: Build documentation
+        run: |
+          uv run \
+            --python ${{ steps.setup-python.outputs.python-version }} \
+            --dev \
+            --frozen \
+            mkdocs build --config-file ./mkdocs.yml
+      # ---- Prepare Release ----
+      - name: Generate requirements file
+        run: |
+          uv export --quiet --no-dev --all-extras --format requirements-txt --output-file requirements.txt
+      - name: Compile messages
+        run: |
+          cd src/
+          uv run \
+            --python ${{ steps.setup-python.outputs.python-version }} \
+            manage.py compilemessages
+      - name: Collect static files
+        run: |
+          cd src/
+          uv run \
+            --python ${{ steps.setup-python.outputs.python-version }} \
+            manage.py collectstatic --no-input --clear
+      - name: Assemble release package
+        run: |
+          mkdir -p dist/paperless-ngx/scripts
+
+          for file_name in .dockerignore \
+                          .env \
+                          Dockerfile \
+                          pyproject.toml \
+                          uv.lock \
+                          requirements.txt \
+                          LICENSE \
+                          README.md \
+                          paperless.conf.example
+          do
+            cp --verbose ${file_name} dist/paperless-ngx/
+          done
+          mv dist/paperless-ngx/paperless.conf.example dist/paperless-ngx/paperless.conf
+
+          cp --recursive docker/ dist/paperless-ngx/docker
+          cp scripts/*.service scripts/*.sh scripts/*.socket dist/paperless-ngx/scripts/
+          cp --recursive src/ dist/paperless-ngx/src
+          cp --recursive site/ dist/paperless-ngx/docs
+          mv static dist/paperless-ngx/
+
+          find dist/paperless-ngx -name "__pycache__" -type d -exec rm -rf {} +
+      - name: Create release archive
+        run: |
+          cd dist
+          sudo chown -R 1000:1000 paperless-ngx/
+          tar -cJf paperless-ngx.tar.xz paperless-ngx/
+      - name: Upload release artifact
+        uses: actions/upload-artifact@v6
+        with:
+          name: release
+          path: dist/paperless-ngx.tar.xz
+          retention-days: 7
+  publish-release:
+    name: Publish Release
+    needs: build-release
+    runs-on: ubuntu-24.04
+    outputs:
+      prerelease: ${{ steps.get-version.outputs.prerelease }}
+      changelog: ${{ steps.create-release.outputs.body }}
+      version: ${{ steps.get-version.outputs.version }}
+    steps:
+      - name: Download release artifact
+        uses: actions/download-artifact@v7
+        with:
+          name: release
+          path: ./
+      - name: Get version info
+        id: get-version
+        run: |
+          echo "version=${{ github.ref_name }}" >> $GITHUB_OUTPUT
+          if [[ "${{ github.ref_name }}" == *"-beta.rc"* ]]; then
+            echo "prerelease=true" >> $GITHUB_OUTPUT
+          else
+            echo "prerelease=false" >> $GITHUB_OUTPUT
+          fi
+      - name: Create release and changelog
+        id: create-release
+        uses: release-drafter/release-drafter@v6
+        with:
+          name: Paperless-ngx ${{ steps.get-version.outputs.version }}
+          tag: ${{ steps.get-version.outputs.version }}
+          version: ${{ steps.get-version.outputs.version }}
+          prerelease: ${{ steps.get-version.outputs.prerelease }}
+          publish: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Upload release archive
+        uses: shogo82148/actions-upload-release-asset@v1
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          upload_url: ${{ steps.create-release.outputs.upload_url }}
+          asset_path: ./paperless-ngx.tar.xz
+          asset_name: paperless-ngx-${{ steps.get-version.outputs.version }}.tar.xz
+          asset_content_type: application/x-xz
+  # ---------------------------------------------------------------------------
+  # Append changelog to docs (only on non-prerelease)
+  # ---------------------------------------------------------------------------
+  append-changelog:
+    name: Append Changelog
+    needs: publish-release
+    if: needs.publish-release.outputs.prerelease == 'false'
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          ref: main
+      - name: Set up Python
+        id: setup-python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: ${{ env.DEFAULT_UV_VERSION }}
+          enable-cache: true
+          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
+      - name: Update changelog
+        working-directory: docs
+        run: |
+          git branch ${{ needs.publish-release.outputs.version }}-changelog
+          git checkout ${{ needs.publish-release.outputs.version }}-changelog
+
+          echo -e "# Changelog\n\n${{ needs.publish-release.outputs.changelog }}\n" > changelog-new.md
+
+          echo "Manually linking usernames"
+          sed -i -r 's|@([a-zA-Z0-9_]+) \(\[#|[@\1](https://github.com/\1) ([#|g' changelog-new.md
+
+          echo "Removing unneeded comment tags"
+          sed -i -r 's|@<!---->|@|g' changelog-new.md
+
+          CURRENT_CHANGELOG=$(tail --lines +2 changelog.md)
+          echo -e "$CURRENT_CHANGELOG" >> changelog-new.md
+          mv changelog-new.md changelog.md
+
+          uv run \
+            --python ${{ steps.setup-python.outputs.python-version }} \
+            --dev \
+            pre-commit run --files changelog.md || true
+
+          git config --global user.name "github-actions"
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git commit -am "Changelog ${{ needs.publish-release.outputs.version }} - GHA"
+          git push origin ${{ needs.publish-release.outputs.version }}-changelog
+      - name: Create pull request
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const { repo, owner } = context.repo;
+            const result = await github.rest.pulls.create({
+              title: 'Documentation: Add ${{ needs.publish-release.outputs.version }} changelog',
+              owner,
+              repo,
+              head: '${{ needs.publish-release.outputs.version }}-changelog',
+              base: 'main',
+              body: 'This PR is auto-generated by CI.'
+            });
+            github.rest.issues.addLabels({
+              owner,
+              repo,
+              issue_number: result.data.number,
+              labels: ['documentation', 'skip-changelog']
+            });

.github/workflows/ci.yml

@@ -1,693 +0,0 @@
-name: ci
-on:
-  push:
-    tags:
-      # https://semver.org/#spec-item-2
-      - 'v[0-9]+.[0-9]+.[0-9]+'
-      # https://semver.org/#spec-item-9
-      - 'v[0-9]+.[0-9]+.[0-9]+-beta.rc[0-9]+'
-    branches-ignore:
-      - 'translations**'
-  pull_request:
-    branches-ignore:
-      - 'translations**'
-env:
-  DEFAULT_UV_VERSION: "0.9.x"
-  # This is the default version of Python to use in most steps which aren't specific
-  DEFAULT_PYTHON_VERSION: "3.11"
-  NLTK_DATA: "/usr/share/nltk_data"
-jobs:
-  detect-duplicate:
-    name: Detect Duplicate Run
-    runs-on: ubuntu-24.04
-    outputs:
-      should_run: ${{ steps.check.outputs.should_run }}
-    steps:
-      - name: Check if workflow should run
-        id: check
-        uses: actions/github-script@v8
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            if (context.eventName !== 'push') {
-              core.info('Not a push event; running workflow.');
-              core.setOutput('should_run', 'true');
-              return;
-            }
-
-            const ref = context.ref || '';
-            if (!ref.startsWith('refs/heads/')) {
-              core.info('Push is not to a branch; running workflow.');
-              core.setOutput('should_run', 'true');
-              return;
-            }
-
-            const branch = ref.substring('refs/heads/'.length);
-            const { owner, repo } = context.repo;
-            const prs = await github.paginate(github.rest.pulls.list, {
-              owner,
-              repo,
-              state: 'open',
-              head: `${owner}:${branch}`,
-              per_page: 100,
-            });
-
-            if (prs.length === 0) {
-              core.info(`No open PR found for ${branch}; running workflow.`);
-              core.setOutput('should_run', 'true');
-            } else {
-              core.info(`Found ${prs.length} open PR(s) for ${branch}; skipping duplicate push run.`);
-              core.setOutput('should_run', 'false');
-            }
-  pre-commit:
-    needs:
-      - detect-duplicate
-    if: needs.detect-duplicate.outputs.should_run == 'true'
-    name: Linting Checks
-    runs-on: ubuntu-24.04
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Install python
-        uses: actions/setup-python@v6
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
-      - name: Check files
-        uses: pre-commit/action@v3.0.1
-  documentation:
-    name: "Build & Deploy Documentation"
-    runs-on: ubuntu-24.04
-    needs:
-      - pre-commit
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-      - name: Set up Python
-        id: setup-python
-        uses: actions/setup-python@v6
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-        with:
-          version: ${{ env.DEFAULT_UV_VERSION }}
-          enable-cache: true
-          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
-      - name: Install Python dependencies
-        run: |
-          uv sync --python ${{ steps.setup-python.outputs.python-version }} --dev --frozen
-      - name: Make documentation
-        run: |
-          uv run \
-            --python ${{ steps.setup-python.outputs.python-version }} \
-            --dev \
-            --frozen \
-            mkdocs build --config-file ./mkdocs.yml
-      - name: Deploy documentation
-        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-        run: |
-          echo "docs.paperless-ngx.com" > "${{ github.workspace }}/docs/CNAME"
-          git config --global user.name "${{ github.actor }}"
-          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
-          uv run \
-            --python ${{ steps.setup-python.outputs.python-version }} \
-            --dev \
-            --frozen \
-            mkdocs gh-deploy --force --no-history
-      - name: Upload artifact
-        uses: actions/upload-artifact@v5
-        with:
-          name: documentation
-          path: site/
-          retention-days: 7
-  tests-backend:
-    name: "Backend Tests (Python ${{ matrix.python-version }})"
-    runs-on: ubuntu-24.04
-    needs:
-      - pre-commit
-    strategy:
-      matrix:
-        python-version: ['3.10', '3.11', '3.12']
-      fail-fast: false
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-      - name: Start containers
-        run: |
-          docker compose --file ${{ github.workspace }}/docker/compose/docker-compose.ci-test.yml pull --quiet
-          docker compose --file ${{ github.workspace }}/docker/compose/docker-compose.ci-test.yml up --detach
-      - name: Set up Python
-        id: setup-python
-        uses: actions/setup-python@v6
-        with:
-          python-version: "${{ matrix.python-version }}"
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-        with:
-          version: ${{ env.DEFAULT_UV_VERSION }}
-          enable-cache: true
-          python-version: ${{ steps.setup-python.outputs.python-version }}
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update -qq
-          sudo apt-get install -qq --no-install-recommends unpaper tesseract-ocr imagemagick ghostscript libzbar0 poppler-utils
-      - name: Configure ImageMagick
-        run: |
-          sudo cp docker/rootfs/etc/ImageMagick-6/paperless-policy.xml /etc/ImageMagick-6/policy.xml
-      - name: Install Python dependencies
-        run: |
-          uv sync \
-            --python ${{ steps.setup-python.outputs.python-version }} \
-            --group testing \
-            --frozen
-      - name: List installed Python dependencies
-        run: |
-          uv pip list
-      - name: Install or update NLTK dependencies
-        run: uv run python -m nltk.downloader punkt punkt_tab snowball_data stopwords -d ${{ env.NLTK_DATA }}
-      - name: Tests
-        env:
-          NLTK_DATA: ${{ env.NLTK_DATA }}
-          PAPERLESS_CI_TEST: 1
-          # Enable paperless_mail testing against real server
-          PAPERLESS_MAIL_TEST_HOST: ${{ secrets.TEST_MAIL_HOST }}
-          PAPERLESS_MAIL_TEST_USER: ${{ secrets.TEST_MAIL_USER }}
-          PAPERLESS_MAIL_TEST_PASSWD: ${{ secrets.TEST_MAIL_PASSWD }}
-        run: |
-          uv run \
-            --python ${{ steps.setup-python.outputs.python-version }} \
-            --dev \
-            --frozen \
-            pytest
-      - name: Upload backend test results to Codecov
-        if: always()
-        uses: codecov/codecov-action@v5
-        with:
-          flags: backend-python-${{ matrix.python-version }}
-          files: junit.xml
-          report_type: test_results
-      - name: Upload backend coverage to Codecov
-        uses: codecov/codecov-action@v5
-        with:
-          flags: backend-python-${{ matrix.python-version }}
-          files: coverage.xml
-      - name: Stop containers
-        if: always()
-        run: |
-          docker compose --file ${{ github.workspace }}/docker/compose/docker-compose.ci-test.yml logs
-          docker compose --file ${{ github.workspace }}/docker/compose/docker-compose.ci-test.yml down
-  install-frontend-dependencies:
-    name: "Install Frontend Dependencies"
-    runs-on: ubuntu-24.04
-    needs:
-      - pre-commit
-    steps:
-      - uses: actions/checkout@v6
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 10
-      - name: Use Node.js 20
-        uses: actions/setup-node@v6
-        with:
-          node-version: 20.x
-          cache: 'pnpm'
-          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
-      - name: Cache frontend dependencies
-        id: cache-frontend-deps
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.pnpm-store
-            ~/.cache
-          key: ${{ runner.os }}-frontenddeps-${{ hashFiles('src-ui/pnpm-lock.yaml') }}
-      - name: Install dependencies
-        run: cd src-ui && pnpm install
-  tests-frontend:
-    name: "Frontend Unit Tests (Node ${{ matrix.node-version }} - ${{ matrix.shard-index }}/${{ matrix.shard-count }})"
-    runs-on: ubuntu-24.04
-    needs:
-      - install-frontend-dependencies
-    strategy:
-      fail-fast: false
-      matrix:
-        node-version: [20.x]
-        shard-index: [1, 2, 3, 4]
-        shard-count: [4]
-    steps:
-      - uses: actions/checkout@v6
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 10
-      - name: Use Node.js 20
-        uses: actions/setup-node@v6
-        with:
-          node-version: 20.x
-          cache: 'pnpm'
-          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
-      - name: Cache frontend dependencies
-        id: cache-frontend-deps
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.pnpm-store
-            ~/.cache
-          key: ${{ runner.os }}-frontenddeps-${{ hashFiles('src-ui/pnpm-lock.yaml') }}
-      - name: Re-link Angular cli
-        run: cd src-ui && pnpm link @angular/cli
-      - name: Linting checks
-        run: cd src-ui && pnpm run lint
-      - name: Run Jest unit tests
-        run: cd src-ui && pnpm run test --max-workers=2 --shard=${{ matrix.shard-index }}/${{ matrix.shard-count }}
-      - name: Upload frontend test results to Codecov
-        if: always()
-        uses: codecov/codecov-action@v5
-        with:
-          flags: frontend-node-${{ matrix.node-version }}
-          directory: src-ui/
-          report_type: test_results
-      - name: Upload frontend coverage to Codecov
-        uses: codecov/codecov-action@v5
-        with:
-          flags: frontend-node-${{ matrix.node-version }}
-          directory: src-ui/coverage/
-  tests-frontend-e2e:
-    name: "Frontend E2E Tests (Node ${{ matrix.node-version }} - ${{ matrix.shard-index }}/${{ matrix.shard-count }})"
-    runs-on: ubuntu-24.04
-    container: mcr.microsoft.com/playwright:v1.57.0-noble
-    needs:
-      - install-frontend-dependencies
-    env:
-      PLAYWRIGHT_BROWSERS_PATH: /ms-playwright
-      PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: 1
-    strategy:
-      fail-fast: false
-      matrix:
-        node-version: [20.x]
-        shard-index: [1, 2]
-        shard-count: [2]
-    steps:
-      - uses: actions/checkout@v6
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 10
-      - name: Use Node.js 20
-        uses: actions/setup-node@v6
-        with:
-          node-version: 20.x
-          cache: 'pnpm'
-          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
-      - name: Cache frontend dependencies
-        id: cache-frontend-deps
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.pnpm-store
-            ~/.cache
-          key: ${{ runner.os }}-frontenddeps-${{ hashFiles('src-ui/pnpm-lock.yaml') }}
-      - name: Re-link Angular cli
-        run: cd src-ui && pnpm link @angular/cli
-      - name: Install dependencies
-        run: cd src-ui && pnpm install --no-frozen-lockfile
-      - name: Run Playwright e2e tests
-        run: cd src-ui && pnpm exec playwright test --shard ${{ matrix.shard-index }}/${{ matrix.shard-count }}
-  frontend-bundle-analysis:
-    name: "Frontend Bundle Analysis"
-    runs-on: ubuntu-24.04
-    needs:
-      - tests-frontend
-      - tests-frontend-e2e
-    steps:
-      - uses: actions/checkout@v6
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 10
-      - name: Use Node.js 20
-        uses: actions/setup-node@v6
-        with:
-          node-version: 20.x
-          cache: 'pnpm'
-          cache-dependency-path: 'src-ui/pnpm-lock.yaml'
-      - name: Cache frontend dependencies
-        id: cache-frontend-deps
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.pnpm-store
-            ~/.cache
-          key: ${{ runner.os }}-frontenddeps-${{ hashFiles('src-ui/package-lock.json') }}
-      - name: Re-link Angular cli
-        run: cd src-ui && pnpm link @angular/cli
-      - name: Build frontend and upload analysis
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-        run: cd src-ui && pnpm run build --configuration=production
-  build-docker-image:
-    name: Build Docker image for ${{ github.event_name == 'pull_request' && github.head_ref || github.ref_name }}
-    runs-on: ubuntu-24.04
-    if: (github.event_name == 'push' && (startsWith(github.ref, 'refs/heads/feature-') || startsWith(github.ref, 'refs/heads/fix-') || github.ref == 'refs/heads/dev' || github.ref == 'refs/heads/beta' || contains(github.ref, 'beta.rc') || startsWith(github.ref, 'refs/tags/v') || startsWith(github.ref, 'refs/heads/l10n_'))) || (github.event_name == 'pull_request' && (startsWith(github.head_ref, 'feature-') || startsWith(github.head_ref, 'fix-') || github.head_ref == 'dev' || github.head_ref == 'beta' || contains(github.head_ref, 'beta.rc') || startsWith(github.head_ref, 'l10n_')))
-    concurrency:
-      group: ${{ github.workflow }}-build-docker-image-${{ github.ref_name }}
-      cancel-in-progress: true
-    needs:
-      - tests-backend
-      - tests-frontend
-      - tests-frontend-e2e
-    steps:
-      - name: Prepare build variables
-        id: build-vars
-        uses: actions/github-script@v8
-        with:
-          result-encoding: string
-          script: |
-            const isPR = context.eventName === 'pull_request';
-            const defaultRefName = context.ref.replace('refs/heads/', '');
-            const headRef = isPR ? context.payload.pull_request.head.ref : defaultRefName;
-            const buildRef = isPR ? `refs/heads/${headRef}` : context.ref;
-            const buildCacheKey = headRef.split('/').join('-');
-            const canPush = context.eventName === 'push' || (isPR && context.payload.pull_request.head.repo.full_name === `${context.repo.owner}/${context.repo.repo}`);
-
-            core.setOutput('build-ref', buildRef);
-            core.setOutput('build-ref-name', headRef);
-            core.setOutput('build-cache-key', buildCacheKey);
-            core.setOutput('can-push', canPush ? 'true' : 'false');
-      - name: Check pushing to Docker Hub
-        id: push-other-places
-        # Only push to Dockerhub from the main repo AND the ref is either:
-        #  main
-        #  dev
-        #  beta
-        #  a tag
-        # Otherwise forks would require a Docker Hub account and secrets setup
-        env:
-          BUILD_REF: ${{ steps.build-vars.outputs.build-ref }}
-          BUILD_REF_NAME: ${{ steps.build-vars.outputs.build-ref-name }}
-        run: |
-          if [[ ${{ github.repository_owner }} == "paperless-ngx" && ( "$BUILD_REF_NAME" == "dev" || "$BUILD_REF_NAME" == "beta" || $BUILD_REF == refs/tags/v* || $BUILD_REF == *beta.rc* ) ]] ; then
-            echo "Enabling DockerHub image push"
-            echo "enable=true" >> $GITHUB_OUTPUT
-          else
-            echo "Not pushing to DockerHub"
-            echo "enable=false" >> $GITHUB_OUTPUT
-          fi
-      - name: Set ghcr repository name
-        id: set-ghcr-repository
-        run: |
-          ghcr_name=$(echo "${{ github.repository }}" | awk '{ print tolower($0) }')
-          echo "Name is ${ghcr_name}"
-          echo "ghcr-repository=${ghcr_name}" >> $GITHUB_OUTPUT
-      - name: Gather Docker metadata
-        id: docker-meta
-        uses: docker/metadata-action@v5
-        with:
-          images: |
-            ghcr.io/${{ steps.set-ghcr-repository.outputs.ghcr-repository }}
-            name=paperlessngx/paperless-ngx,enable=${{ steps.push-other-places.outputs.enable }}
-            name=quay.io/paperlessngx/paperless-ngx,enable=${{ steps.push-other-places.outputs.enable }}
-          tags: |
-            # Tag branches with branch name
-            type=ref,event=branch
-            # Pull requests need a sanitized branch tag for pushing images
-            type=raw,value=${{ steps.build-vars.outputs.build-cache-key }},enable=${{ github.event_name == 'pull_request' }}
-            # Process semver tags
-            # For a tag x.y.z or vX.Y.Z, output an x.y.z and x.y image tag
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-      - name: Checkout
-        uses: actions/checkout@v6
-      # If https://github.com/docker/buildx/issues/1044 is resolved,
-      # the append input with a native arm64 arch could be used to
-      # significantly speed up building
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: arm64
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        # Don't attempt to login if not pushing to Docker Hub
-        if: steps.push-other-places.outputs.enable == 'true'
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Login to Quay.io
-        uses: docker/login-action@v3
-        # Don't attempt to login if not pushing to Quay.io
-        if: steps.push-other-places.outputs.enable == 'true'
-        with:
-          registry: quay.io
-          username: ${{ secrets.QUAY_USERNAME }}
-          password: ${{ secrets.QUAY_ROBOT_TOKEN }}
-      - name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./Dockerfile
-          platforms: linux/amd64,linux/arm64
-          push: ${{ steps.build-vars.outputs.can-push == 'true' }}
-          tags: ${{ steps.docker-meta.outputs.tags }}
-          labels: ${{ steps.docker-meta.outputs.labels }}
-          build-args: |
-            PNGX_TAG_VERSION=${{ steps.docker-meta.outputs.version }}
-          # Get cache layers from this branch, then dev
-          # This allows new branches to get at least some cache benefits, generally from dev
-          cache-from: |
-            type=registry,ref=ghcr.io/${{ steps.set-ghcr-repository.outputs.ghcr-repository }}/builder/cache/app:${{ steps.build-vars.outputs.build-cache-key }}
-            type=registry,ref=ghcr.io/${{ steps.set-ghcr-repository.outputs.ghcr-repository }}/builder/cache/app:dev
-          cache-to: ${{ steps.build-vars.outputs.can-push == 'true' && format('type=registry,mode=max,ref=ghcr.io/{0}/builder/cache/app:{1}', steps.set-ghcr-repository.outputs.ghcr-repository, steps.build-vars.outputs.build-cache-key) || '' }}
-      - name: Inspect image
-        if: steps.build-vars.outputs.can-push == 'true'
-        run: |
-          docker buildx imagetools inspect ${{ fromJSON(steps.docker-meta.outputs.json).tags[0] }}
-      - name: Export frontend artifact from docker
-        if: steps.build-vars.outputs.can-push == 'true'
-        run: |
-          docker create --name frontend-extract ${{ fromJSON(steps.docker-meta.outputs.json).tags[0] }}
-          docker cp frontend-extract:/usr/src/paperless/src/documents/static/frontend src/documents/static/frontend/
-      - name: Upload frontend artifact
-        if: steps.build-vars.outputs.can-push == 'true'
-        uses: actions/upload-artifact@v5
-        with:
-          name: frontend-compiled
-          path: src/documents/static/frontend/
-          retention-days: 7
-  build-release:
-    name: "Build Release"
-    needs:
-      - build-docker-image
-      - documentation
-    if: github.event_name == 'push'
-    runs-on: ubuntu-24.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-      - name: Set up Python
-        id: setup-python
-        uses: actions/setup-python@v6
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-        with:
-          version: ${{ env.DEFAULT_UV_VERSION }}
-          enable-cache: true
-          python-version: ${{ steps.setup-python.outputs.python-version }}
-      - name: Install Python dependencies
-        run: |
-          uv sync --python ${{ steps.setup-python.outputs.python-version }} --dev --frozen
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update -qq
-          sudo apt-get install -qq --no-install-recommends gettext liblept5
-      - name: Download frontend artifact
-        uses: actions/download-artifact@v6
-        with:
-          name: frontend-compiled
-          path: src/documents/static/frontend/
-      - name: Download documentation artifact
-        uses: actions/download-artifact@v6
-        with:
-          name: documentation
-          path: docs/_build/html/
-      - name: Generate requirements file
-        run: |
-          uv export --quiet --no-dev --all-extras --format requirements-txt --output-file requirements.txt
-      - name: Compile messages
-        run: |
-          cd src/
-          uv run \
-            --python ${{ steps.setup-python.outputs.python-version }} \
-            manage.py compilemessages
-      - name: Collect static files
-        run: |
-          cd src/
-          uv run \
-            --python ${{ steps.setup-python.outputs.python-version }} \
-            manage.py collectstatic --no-input
-      - name: Move files
-        run: |
-          echo "Making dist folders"
-          for directory in dist \
-                          dist/paperless-ngx \
-                          dist/paperless-ngx/scripts;
-          do
-            mkdir --verbose --parents ${directory}
-          done
-
-          echo "Copying basic files"
-          for file_name in .dockerignore \
-                          .env \
-                          Dockerfile \
-                          pyproject.toml \
-                          uv.lock \
-                          requirements.txt \
-                          LICENSE \
-                          README.md \
-                          paperless.conf.example
-          do
-            cp --verbose ${file_name} dist/paperless-ngx/
-          done
-          mv --verbose dist/paperless-ngx/paperless.conf.example dist/paperless-ngx/paperless.conf
-
-          echo "Copying Docker related files"
-          cp --recursive docker/ dist/paperless-ngx/docker
-
-          echo "Copying startup scripts"
-          cp --verbose scripts/*.service scripts/*.sh scripts/*.socket dist/paperless-ngx/scripts/
-
-          echo "Copying source files"
-          cp --recursive src/ dist/paperless-ngx/src
-          echo "Copying documentation"
-          cp --recursive docs/_build/html/ dist/paperless-ngx/docs
-
-          mv --verbose static dist/paperless-ngx
-      - name: Make release package
-        run: |
-          echo "Creating release archive"
-          cd dist
-          sudo chown -R 1000:1000 paperless-ngx/
-          tar -cJf paperless-ngx.tar.xz paperless-ngx/
-      - name: Upload release artifact
-        uses: actions/upload-artifact@v5
-        with:
-          name: release
-          path: dist/paperless-ngx.tar.xz
-          retention-days: 7
-  publish-release:
-    name: "Publish Release"
-    runs-on: ubuntu-24.04
-    outputs:
-      prerelease: ${{ steps.get_version.outputs.prerelease }}
-      changelog: ${{ steps.create-release.outputs.body }}
-      version: ${{ steps.get_version.outputs.version }}
-    needs:
-      - build-release
-    if: github.ref_type == 'tag' && (startsWith(github.ref_name, 'v') || contains(github.ref_name, '-beta.rc'))
-    steps:
-      - name: Download release artifact
-        uses: actions/download-artifact@v6
-        with:
-          name: release
-          path: ./
-      - name: Get version
-        id: get_version
-        run: |
-          echo "version=${{ github.ref_name }}" >> $GITHUB_OUTPUT
-          if [[ ${{ contains(github.ref_name, '-beta.rc') }} == 'true' ]]; then
-            echo "prerelease=true" >> $GITHUB_OUTPUT
-          else
-            echo "prerelease=false" >> $GITHUB_OUTPUT
-          fi
-      - name: Create Release and Changelog
-        id: create-release
-        uses: release-drafter/release-drafter@v6
-        with:
-          name: Paperless-ngx ${{ steps.get_version.outputs.version }}
-          tag: ${{ steps.get_version.outputs.version }}
-          version: ${{ steps.get_version.outputs.version }}
-          prerelease: ${{ steps.get_version.outputs.prerelease }}
-          publish: true # ensures release is not marked as draft
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      - name: Upload release archive
-        id: upload-release-asset
-        uses: shogo82148/actions-upload-release-asset@v1
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          upload_url: ${{ steps.create-release.outputs.upload_url }}
-          asset_path: ./paperless-ngx.tar.xz
-          asset_name: paperless-ngx-${{ steps.get_version.outputs.version }}.tar.xz
-          asset_content_type: application/x-xz
-  append-changelog:
-    name: "Append Changelog"
-    runs-on: ubuntu-24.04
-    needs:
-      - publish-release
-    if: needs.publish-release.outputs.prerelease == 'false'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          ref: main
-      - name: Set up Python
-        id: setup-python
-        uses: actions/setup-python@v6
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-        with:
-          version: ${{ env.DEFAULT_UV_VERSION }}
-          enable-cache: true
-          python-version: ${{ env.DEFAULT_PYTHON_VERSION }}
-      - name: Append Changelog to docs
-        id: append-Changelog
-        working-directory: docs
-        run: |
-          git branch ${{ needs.publish-release.outputs.version }}-changelog
-          git checkout ${{ needs.publish-release.outputs.version }}-changelog
-          echo -e "# Changelog\n\n${{ needs.publish-release.outputs.changelog }}\n" > changelog-new.md
-          echo "Manually linking usernames"
-          sed -i -r 's|@([a-zA-Z0-9_]+) \(\[#|[@\1](https://github.com/\1) ([#|g' changelog-new.md
-          echo "Removing unneeded comment tags"
-          sed -i -r 's|@<!---->|@|g' changelog-new.md
-          CURRENT_CHANGELOG=`tail --lines +2 changelog.md`
-          echo -e "$CURRENT_CHANGELOG" >> changelog-new.md
-          mv changelog-new.md changelog.md
-          uv run \
-            --python ${{ steps.setup-python.outputs.python-version }} \
-            --dev \
-            pre-commit run --files changelog.md || true
-          git config --global user.name "github-actions"
-          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git commit -am "Changelog ${{ needs.publish-release.outputs.version }} - GHA"
-          git push origin ${{ needs.publish-release.outputs.version }}-changelog
-      - name: Create Pull Request
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const { repo, owner } = context.repo;
-            const result = await github.rest.pulls.create({
-              title: 'Documentation: Add ${{ needs.publish-release.outputs.version }} changelog',
-              owner,
-              repo,
-              head: '${{ needs.publish-release.outputs.version }}-changelog',
-              base: 'main',
-              body: 'This PR is auto-generated by CI.'
-            });
-            github.rest.issues.addLabels({
-              owner,
-              repo,
-              issue_number: result.data.number,
-              labels: ['documentation', 'skip-changelog']
-            });

.github/workflows/repo-maintenance.yml

@@ -37,7 +37,7 @@ jobs:
     if: github.repository_owner == 'paperless-ngx'
     runs-on: ubuntu-24.04
     steps:
-      - uses: dessant/lock-threads@v5
+      - uses: dessant/lock-threads@v6
         with:
           issue-inactive-days: '30'
           pr-inactive-days: '30'

.github/workflows/translate-strings.yml

@@ -47,7 +47,7 @@ jobs:
           cache-dependency-path: 'src-ui/pnpm-lock.yaml'
       - name: Cache frontend dependencies
         id: cache-frontend-deps
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: |
             ~/.pnpm-store

Dockerfile

@@ -11,8 +11,6 @@ COPY ./src-ui /src/src-ui
 
 WORKDIR /src/src-ui
 RUN set -eux \
-  && npm update -g pnpm \
-  && npm install -g corepack@latest \
   && corepack enable \
   && pnpm install
 
@@ -110,8 +108,7 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONWARNINGS="ignore:::django.http.response:517" \
     PNGX_CONTAINERIZED=1 \
     # https://docs.astral.sh/uv/reference/settings/#link-mode
-    UV_LINK_MODE=copy \
-    UV_CACHE_DIR=/cache/uv/
+    UV_LINK_MODE=copy
 
 #
 # Begin installation and configuration
@@ -193,14 +190,13 @@ ARG BUILD_PACKAGES="\
   pkg-config"
 
 # hadolint ignore=DL3042
-RUN --mount=type=cache,target=${UV_CACHE_DIR},id=python-cache \
-  set -eux \
+RUN set -eux \
   && echo "Installing build system packages" \
     && apt-get update \
     && apt-get install --yes --quiet --no-install-recommends ${BUILD_PACKAGES} \
   && echo "Installing Python requirements" \
     && uv export --quiet --no-dev --all-extras --format requirements-txt --output-file requirements.txt \
-    && uv pip install --system --no-python-downloads --python-preference system --requirements requirements.txt \
+    && uv pip install --no-cache --system --no-python-downloads --python-preference system --requirements requirements.txt \
   && echo "Installing NLTK data" \
     && python3 -W ignore::RuntimeWarning -m nltk.downloader -d "/usr/share/nltk_data" snowball_data \
     && python3 -W ignore::RuntimeWarning -m nltk.downloader -d "/usr/share/nltk_data" stopwords \

docs/configuration.md

@@ -1603,16 +1603,6 @@ processing. This only has an effect if
 
     Defaults to `0 1 * * *`, once per day.
 
-## Share links
-
-#### [`PAPERLESS_SHARE_LINK_BUNDLE_CLEANUP_CRON=<cron expression>`](#PAPERLESS_SHARE_LINK_BUNDLE_CLEANUP_CRON) {#PAPERLESS_SHARE_LINK_BUNDLE_CLEANUP_CRON}
-
-: Controls how often Paperless-ngx removes expired share link bundles (and their generated ZIP archives).
-
-: If set to the string "disable", expired bundles are not cleaned up automatically.
-
-    Defaults to `0 2 * * *`, once per day at 02:00.
-
 ## Binaries
 
 There are a few external software packages that Paperless expects to

docs/usage.md

@@ -286,14 +286,12 @@ or using [email](#workflow-action-email) or [webhook](#workflow-action-webhook)
 
 ### Share Links
 
-"Share links" are public links to files (or an archive of files) and can be created and managed under the 'Send' button on the document detail screen or from the bulk editor.
+"Share links" are shareable public links to files and can be created and managed under the 'Send' button on the document detail screen.
 
--   Share links do not require a user to login and thus link directly to a file or bundled download.
+-   Share links do not require a user to login and thus link directly to a file.
 -   Links are unique and are of the form `{paperless-url}/share/{randomly-generated-slug}`.
 -   Links can optionally have an expiration time set.
 -   After a link expires or is deleted users will be redirected to the regular paperless-ngx login.
--   From the document detail screen you can create a share link for that single document.
--   From the bulk editor you can create a **share link bundle** for any selection. Paperless-ngx prepares a ZIP archive in the background and exposes a single share link. You can revisit the "Manage share link bundles" dialog to monitor progress, retry failed bundles, or delete links.
 
 !!! tip
 

src-ui/messages.xlf

@@ -328,23 +328,23 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.html</context>
-          <context context-type="linenumber">61</context>
+          <context context-type="linenumber">70</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">139</context>
+          <context context-type="linenumber">151</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">139</context>
+          <context context-type="linenumber">151</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">139</context>
+          <context context-type="linenumber">151</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">139</context>
+          <context context-type="linenumber">151</context>
         </context-group>
       </trans-unit>
       <trans-unit id="4930506384627295710" datatype="html">
@@ -2164,7 +2164,7 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.html</context>
-          <context context-type="linenumber">55</context>
+          <context context-type="linenumber">61</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/mail/mail.component.html</context>
@@ -2216,19 +2216,19 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">133</context>
+          <context context-type="linenumber">140</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">133</context>
+          <context context-type="linenumber">140</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">133</context>
+          <context context-type="linenumber">140</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">133</context>
+          <context context-type="linenumber">140</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.ts</context>
@@ -2300,7 +2300,7 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.ts</context>
-          <context context-type="linenumber">104</context>
+          <context context-type="linenumber">106</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/mail/mail.component.ts</context>
@@ -2483,7 +2483,7 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.html</context>
-          <context context-type="linenumber">52</context>
+          <context context-type="linenumber">58</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/mail/mail.component.html</context>
@@ -2519,19 +2519,19 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">130</context>
+          <context context-type="linenumber">137</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">130</context>
+          <context context-type="linenumber">137</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">130</context>
+          <context context-type="linenumber">137</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">130</context>
+          <context context-type="linenumber">137</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/workflows/workflows.component.html</context>
@@ -2627,7 +2627,7 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.ts</context>
-          <context context-type="linenumber">106</context>
+          <context context-type="linenumber">108</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/mail/mail.component.ts</context>
@@ -3340,7 +3340,7 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.ts</context>
-          <context context-type="linenumber">85</context>
+          <context context-type="linenumber">87</context>
         </context-group>
       </trans-unit>
       <trans-unit id="1841172489943868696" datatype="html">
@@ -3351,7 +3351,7 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.ts</context>
-          <context context-type="linenumber">94</context>
+          <context context-type="linenumber">96</context>
         </context-group>
       </trans-unit>
       <trans-unit id="6048892649018070225" datatype="html">
@@ -4361,7 +4361,7 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/storage-path-list/storage-path-list.component.ts</context>
-          <context context-type="linenumber">49</context>
+          <context context-type="linenumber">51</context>
         </context-group>
       </trans-unit>
       <trans-unit id="2816147949408898105" datatype="html">
@@ -4436,7 +4436,7 @@
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/tag-list/tag-list.component.ts</context>
-          <context context-type="linenumber">49</context>
+          <context context-type="linenumber">51</context>
         </context-group>
       </trans-unit>
       <trans-unit id="8621797738551294959" datatype="html">
@@ -8500,28 +8500,28 @@
         <source>correspondent</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/correspondent-list/correspondent-list.component.ts</context>
-          <context context-type="linenumber">47</context>
+          <context context-type="linenumber">49</context>
         </context-group>
       </trans-unit>
       <trans-unit id="1612355304340685070" datatype="html">
         <source>correspondents</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/correspondent-list/correspondent-list.component.ts</context>
-          <context context-type="linenumber">48</context>
+          <context context-type="linenumber">50</context>
         </context-group>
       </trans-unit>
       <trans-unit id="6360600151505327572" datatype="html">
         <source>Last used</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/correspondent-list/correspondent-list.component.ts</context>
-          <context context-type="linenumber">53</context>
+          <context context-type="linenumber">55</context>
         </context-group>
       </trans-unit>
       <trans-unit id="7427874343955308724" datatype="html">
         <source>Do you really want to delete the correspondent &quot;<x id="PH" equiv-text="object.name"/>&quot;?</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/correspondent-list/correspondent-list.component.ts</context>
-          <context context-type="linenumber">78</context>
+          <context context-type="linenumber">80</context>
         </context-group>
       </trans-unit>
       <trans-unit id="8384138406252790442" datatype="html">
@@ -8549,79 +8549,79 @@
         <source>Filter Documents (<x id="INTERPOLATION" equiv-text="{{ field.document_count }}"/>)</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.html</context>
-          <context context-type="linenumber">45</context>
+          <context context-type="linenumber">50</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">123</context>
+          <context context-type="linenumber">129</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">123</context>
+          <context context-type="linenumber">129</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">123</context>
+          <context context-type="linenumber">129</context>
         </context-group>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/management-list/management-list.component.html</context>
-          <context context-type="linenumber">123</context>
+          <context context-type="linenumber">129</context>
         </context-group>
       </trans-unit>
       <trans-unit id="651372623796033489" datatype="html">
         <source>No fields defined.</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.html</context>
-          <context context-type="linenumber">70</context>
+          <context context-type="linenumber">80</context>
         </context-group>
       </trans-unit>
       <trans-unit id="3032792139967609806" datatype="html">
         <source>Confirm delete field</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.ts</context>
-          <context context-type="linenumber">102</context>
+          <context context-type="linenumber">104</context>
         </context-group>
       </trans-unit>
       <trans-unit id="2939457975223185057" datatype="html">
         <source>This operation will permanently delete this field.</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.ts</context>
-          <context context-type="linenumber">103</context>
+          <context context-type="linenumber">105</context>
         </context-group>
       </trans-unit>
       <trans-unit id="4679555638382452936" datatype="html">
         <source>Deleted field &quot;<x id="PH" equiv-text="field.name"/>&quot;</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.ts</context>
-          <context context-type="linenumber">112</context>
+          <context context-type="linenumber">114</context>
         </context-group>
       </trans-unit>
       <trans-unit id="4704551499967874824" datatype="html">
         <source>Error deleting field &quot;<x id="PH" equiv-text="field.name"/>&quot;.</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/custom-fields/custom-fields.component.ts</context>
-          <context context-type="linenumber">121</context>
+          <context context-type="linenumber">123</context>
         </context-group>
       </trans-unit>
       <trans-unit id="8084492669582894778" datatype="html">
         <source>document type</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/document-type-list/document-type-list.component.ts</context>
-          <context context-type="linenumber">43</context>
+          <context context-type="linenumber">45</context>
         </context-group>
       </trans-unit>
       <trans-unit id="2992451138146293104" datatype="html">
         <source>document types</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/document-type-list/document-type-list.component.ts</context>
-          <context context-type="linenumber">44</context>
+          <context context-type="linenumber">46</context>
         </context-group>
       </trans-unit>
       <trans-unit id="4990731724078522539" datatype="html">
         <source>Do you really want to delete the document type &quot;<x id="PH" equiv-text="object.name"/>&quot;?</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/document-type-list/document-type-list.component.ts</context>
-          <context context-type="linenumber">49</context>
+          <context context-type="linenumber">51</context>
         </context-group>
       </trans-unit>
       <trans-unit id="8957855217409261143" datatype="html">
@@ -9161,42 +9161,42 @@
         <source>storage path</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/storage-path-list/storage-path-list.component.ts</context>
-          <context context-type="linenumber">43</context>
+          <context context-type="linenumber">45</context>
         </context-group>
       </trans-unit>
       <trans-unit id="22235115124223314" datatype="html">
         <source>storage paths</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/storage-path-list/storage-path-list.component.ts</context>
-          <context context-type="linenumber">44</context>
+          <context context-type="linenumber">46</context>
         </context-group>
       </trans-unit>
       <trans-unit id="1569070683025071137" datatype="html">
         <source>Do you really want to delete the storage path &quot;<x id="PH" equiv-text="object.name"/>&quot;?</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/storage-path-list/storage-path-list.component.ts</context>
-          <context context-type="linenumber">60</context>
+          <context context-type="linenumber">62</context>
         </context-group>
       </trans-unit>
       <trans-unit id="6402703264596649214" datatype="html">
         <source>tag</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/tag-list/tag-list.component.ts</context>
-          <context context-type="linenumber">43</context>
+          <context context-type="linenumber">45</context>
         </context-group>
       </trans-unit>
       <trans-unit id="4975748273657042999" datatype="html">
         <source>tags</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/tag-list/tag-list.component.ts</context>
-          <context context-type="linenumber">44</context>
+          <context context-type="linenumber">46</context>
         </context-group>
       </trans-unit>
       <trans-unit id="93754014749412887" datatype="html">
         <source>Do you really want to delete the tag &quot;<x id="PH" equiv-text="object.name"/>&quot;?</source>
         <context-group purpose="location">
           <context context-type="sourcefile">src/app/components/manage/tag-list/tag-list.component.ts</context>
-          <context context-type="linenumber">60</context>
+          <context context-type="linenumber">62</context>
         </context-group>
       </trans-unit>
       <trans-unit id="1229748338333965418" datatype="html">

src-ui/src/app/components/common/share-link-bundle-dialog/share-link-bundle-dialog.component.html

@@ -1,129 +0,0 @@
-<div class="modal-header">
-  <h4 class="modal-title">{{ title }}</h4>
-  <button type="button" class="btn-close" aria-label="Close" (click)="cancel()"></button>
-</div>
-<div class="modal-body">
-  @if (!createdBundle) {
-    <form [formGroup]="form" class="d-flex flex-column gap-3">
-      <div>
-        <p class="mb-1">
-          <ng-container i18n>Selected documents:</ng-container>
-          {{ selectionCount }}
-        </p>
-        @if (documentPreview.length > 0) {
-          <ul class="list-unstyled small mb-0">
-            @for (doc of documentPreview; track doc.id) {
-              <li>
-                <strong>{{ doc.title | documentTitle }}</strong>
-              </li>
-            }
-            @if (selectionCount > documentPreview.length) {
-              <li>
-                <ng-container i18n>+ {{ selectionCount - documentPreview.length }} more…</ng-container>
-              </li>
-            }
-          </ul>
-        }
-      </div>
-
-      <div class="d-flex align-items-center justify-content-between">
-        <div class="input-group">
-          <label class="input-group-text" for="expirationDays"><ng-container i18n>Expires</ng-container>:</label>
-          <select class="form-select" id="expirationDays" formControlName="expirationDays">
-            @for (option of expirationOptions; track option.value) {
-              <option [ngValue]="option.value">{{ option.label }}</option>
-            }
-          </select>
-        </div>
-        <div class="form-check form-switch w-100 ms-3">
-          <input
-            class="form-check-input"
-            type="checkbox"
-            role="switch"
-            id="shareArchiveSwitch"
-            formControlName="shareArchiveVersion"
-            aria-checked="{{ shareArchiveVersion }}"
-          />
-          <label class="form-check-label" for="shareArchiveSwitch" i18n>Share archive version (if available)</label>
-        </div>
-      </div>
-    </form>
-  } @else {
-    <div class="d-flex flex-column gap-3">
-      <div class="alert alert-success mb-0" role="status">
-        <h6 class="alert-heading mb-1" i18n>Share link bundle requested</h6>
-        <p class="mb-0 small" i18n>
-          You can copy the share link below or open the manager to monitor progress. The link will start working once the bundle is ready.
-        </p>
-      </div>
-      <dl class="row mb-0 small">
-        <dt class="col-sm-4" i18n>Status</dt>
-        <dd class="col-sm-8">
-          <span class="badge text-bg-secondary text-uppercase">{{ statusLabel(createdBundle.status) }}</span>
-        </dd>
-        <dt class="col-sm-4" i18n>Slug</dt>
-        <dd class="col-sm-8"><code>{{ createdBundle.slug }}</code></dd>
-        <dt class="col-sm-4" i18n>Link</dt>
-        <dd class="col-sm-8">
-          <div class="input-group input-group-sm">
-            <input class="form-control" type="text" [value]="getShareUrl(createdBundle)" readonly>
-            <button
-              class="btn btn-outline-primary"
-              type="button"
-              (click)="copy(createdBundle)"
-            >
-              @if (copied) {
-                <i-bs name="clipboard-check"></i-bs>
-              }
-              @if (!copied) {
-                <i-bs name="clipboard"></i-bs>
-              }
-              <span class="visually-hidden" i18n>Copy link</span>
-            </button>
-          </div>
-        </dd>
-        <dt class="col-sm-4" i18n>Documents</dt>
-        <dd class="col-sm-8">{{ createdBundle.document_count }}</dd>
-        <dt class="col-sm-4" i18n>Expires</dt>
-        <dd class="col-sm-8">
-          @if (createdBundle.expiration) {
-            {{ createdBundle.expiration | date: 'short' }}
-          }
-          @if (!createdBundle.expiration) {
-            <span i18n>Never</span>
-          }
-        </dd>
-        <dt class="col-sm-4" i18n>File version</dt>
-        <dd class="col-sm-8">{{ fileVersionLabel(createdBundle.file_version) }}</dd>
-        @if (createdBundle.size_bytes !== undefined && createdBundle.size_bytes !== null) {
-          <dt class="col-sm-4" i18n>Size</dt>
-          <dd class="col-sm-8">{{ createdBundle.size_bytes | fileSize }}</dd>
-        }
-      </dl>
-    </div>
-  }
-</div>
-<div class="modal-footer">
-  <div class="d-flex align-items-center gap-2 w-100">
-    <div class="text-light fst-italic small">
-      <ng-container i18n>A zip file containing the selected documents will be created for this share link bundle. This process happens in the background and may take some time, especially for large bundles.</ng-container>
-    </div>
-    <button type="button" class="btn btn-outline-secondary btn-sm ms-auto" (click)="cancel()">{{ cancelBtnCaption }}</button>
-    @if (createdBundle) {
-      <button type="button" class="btn btn-outline-secondary btn-sm text-nowrap" (click)="openManage()" i18n>Manage share link bundles</button>
-    }
-
-    @if (!createdBundle) {
-      <button
-        type="button"
-        class="btn btn-primary btn-sm d-inline-flex align-items-center gap-2 text-nowrap"
-        (click)="submit()"
-        [disabled]="loading || !buttonsEnabled">
-        @if (loading) {
-          <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span>
-        }
-        {{ btnCaption }}
-      </button>
-    }
-  </div>
-</div>

src-ui/src/app/components/common/share-link-bundle-dialog/share-link-bundle-dialog.component.spec.ts

@@ -1,161 +0,0 @@
-import { Clipboard } from '@angular/cdk/clipboard'
-import {
-  ComponentFixture,
-  TestBed,
-  fakeAsync,
-  tick,
-} from '@angular/core/testing'
-import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap'
-import { NgxBootstrapIconsModule, allIcons } from 'ngx-bootstrap-icons'
-import { FileVersion } from 'src/app/data/share-link'
-import {
-  ShareLinkBundleStatus,
-  ShareLinkBundleSummary,
-} from 'src/app/data/share-link-bundle'
-import { ToastService } from 'src/app/services/toast.service'
-import { environment } from 'src/environments/environment'
-import { ShareLinkBundleDialogComponent } from './share-link-bundle-dialog.component'
-
-class MockToastService {
-  showInfo = jest.fn()
-  showError = jest.fn()
-}
-
-describe('ShareLinkBundleDialogComponent', () => {
-  let component: ShareLinkBundleDialogComponent
-  let fixture: ComponentFixture<ShareLinkBundleDialogComponent>
-  let clipboard: Clipboard
-  let toastService: MockToastService
-  let activeModal: NgbActiveModal
-  let originalApiBaseUrl: string
-
-  beforeEach(() => {
-    originalApiBaseUrl = environment.apiBaseUrl
-    toastService = new MockToastService()
-
-    TestBed.configureTestingModule({
-      imports: [
-        ShareLinkBundleDialogComponent,
-        NgxBootstrapIconsModule.pick(allIcons),
-      ],
-      providers: [
-        NgbActiveModal,
-        { provide: ToastService, useValue: toastService },
-      ],
-    })
-
-    fixture = TestBed.createComponent(ShareLinkBundleDialogComponent)
-    component = fixture.componentInstance
-    clipboard = TestBed.inject(Clipboard)
-    activeModal = TestBed.inject(NgbActiveModal)
-    fixture.detectChanges()
-  })
-
-  afterEach(() => {
-    jest.clearAllTimers()
-    environment.apiBaseUrl = originalApiBaseUrl
-  })
-
-  it('builds payload and emits confirm on submit', () => {
-    const confirmSpy = jest.spyOn(component.confirmClicked, 'emit')
-    component.documents = [
-      { id: 1, title: 'Doc 1' } as any,
-      { id: 2, title: 'Doc 2' } as any,
-    ]
-    component.form.setValue({
-      shareArchiveVersion: false,
-      expirationDays: 3,
-    })
-
-    component.submit()
-
-    expect(component.payload).toEqual({
-      document_ids: [1, 2],
-      file_version: FileVersion.Original,
-      expiration_days: 3,
-    })
-    expect(component.buttonsEnabled).toBe(false)
-    expect(confirmSpy).toHaveBeenCalled()
-
-    component.form.setValue({
-      shareArchiveVersion: true,
-      expirationDays: 7,
-    })
-    component.submit()
-
-    expect(component.payload).toEqual({
-      document_ids: [1, 2],
-      file_version: FileVersion.Archive,
-      expiration_days: 7,
-    })
-  })
-
-  it('ignores submit when bundle already created', () => {
-    component.createdBundle = { id: 1 } as ShareLinkBundleSummary
-    const confirmSpy = jest.spyOn(component, 'confirm')
-    component.submit()
-    expect(confirmSpy).not.toHaveBeenCalled()
-  })
-
-  it('limits preview to ten documents', () => {
-    const docs = Array.from({ length: 12 }).map((_, index) => ({
-      id: index + 1,
-    }))
-    component.documents = docs as any
-
-    expect(component.selectionCount).toBe(12)
-    expect(component.documentPreview).toHaveLength(10)
-    expect(component.documentPreview[0].id).toBe(1)
-  })
-
-  it('copies share link and resets state after timeout', fakeAsync(() => {
-    const copySpy = jest.spyOn(clipboard, 'copy').mockReturnValue(true)
-    const bundle = {
-      slug: 'bundle-slug',
-      status: ShareLinkBundleStatus.Ready,
-    } as ShareLinkBundleSummary
-
-    component.copy(bundle)
-
-    expect(copySpy).toHaveBeenCalledWith(component.getShareUrl(bundle))
-    expect(component.copied).toBe(true)
-    expect(toastService.showInfo).toHaveBeenCalled()
-
-    tick(3000)
-    expect(component.copied).toBe(false)
-  }))
-
-  it('generates share URLs based on API base URL', () => {
-    environment.apiBaseUrl = 'https://example.com/api/'
-    expect(
-      component.getShareUrl({ slug: 'abc' } as ShareLinkBundleSummary)
-    ).toBe('https://example.com/share/abc')
-  })
-
-  it('opens manage dialog when callback provided', () => {
-    const manageSpy = jest.fn()
-    component.onOpenManage = manageSpy
-    component.openManage()
-    expect(manageSpy).toHaveBeenCalled()
-  })
-
-  it('falls back to cancel when manage callback missing', () => {
-    const cancelSpy = jest.spyOn(component, 'cancel')
-    component.onOpenManage = undefined
-    component.openManage()
-    expect(cancelSpy).toHaveBeenCalled()
-  })
-
-  it('maps status and file version labels', () => {
-    expect(component.statusLabel(ShareLinkBundleStatus.Processing)).toContain(
-      'Processing'
-    )
-    expect(component.fileVersionLabel(FileVersion.Archive)).toContain('Archive')
-  })
-
-  it('closes dialog when cancel invoked', () => {
-    const closeSpy = jest.spyOn(activeModal, 'close')
-    component.cancel()
-    expect(closeSpy).toHaveBeenCalled()
-  })
-})

src-ui/src/app/components/common/share-link-bundle-dialog/share-link-bundle-dialog.component.ts

@@ -1,118 +0,0 @@
-import { Clipboard } from '@angular/cdk/clipboard'
-import { CommonModule } from '@angular/common'
-import { Component, Input, inject } from '@angular/core'
-import { FormBuilder, FormGroup, ReactiveFormsModule } from '@angular/forms'
-import { NgxBootstrapIconsModule } from 'ngx-bootstrap-icons'
-import { Document } from 'src/app/data/document'
-import {
-  FileVersion,
-  SHARE_LINK_EXPIRATION_OPTIONS,
-} from 'src/app/data/share-link'
-import {
-  SHARE_LINK_BUNDLE_FILE_VERSION_LABELS,
-  SHARE_LINK_BUNDLE_STATUS_LABELS,
-  ShareLinkBundleCreatePayload,
-  ShareLinkBundleStatus,
-  ShareLinkBundleSummary,
-} from 'src/app/data/share-link-bundle'
-import { DocumentTitlePipe } from 'src/app/pipes/document-title.pipe'
-import { FileSizePipe } from 'src/app/pipes/file-size.pipe'
-import { ToastService } from 'src/app/services/toast.service'
-import { environment } from 'src/environments/environment'
-import { ConfirmDialogComponent } from '../confirm-dialog/confirm-dialog.component'
-
-@Component({
-  selector: 'pngx-share-link-bundle-dialog',
-  templateUrl: './share-link-bundle-dialog.component.html',
-  imports: [
-    CommonModule,
-    ReactiveFormsModule,
-    NgxBootstrapIconsModule,
-    FileSizePipe,
-    DocumentTitlePipe,
-  ],
-  providers: [],
-})
-export class ShareLinkBundleDialogComponent extends ConfirmDialogComponent {
-  private readonly formBuilder = inject(FormBuilder)
-  private readonly clipboard = inject(Clipboard)
-  private readonly toastService = inject(ToastService)
-
-  private _documents: Document[] = []
-
-  selectionCount = 0
-  documentPreview: Document[] = []
-  form: FormGroup = this.formBuilder.group({
-    shareArchiveVersion: true,
-    expirationDays: [7],
-  })
-  payload: ShareLinkBundleCreatePayload | null = null
-
-  readonly expirationOptions = SHARE_LINK_EXPIRATION_OPTIONS
-
-  createdBundle: ShareLinkBundleSummary | null = null
-  copied = false
-  onOpenManage?: () => void
-  readonly statuses = ShareLinkBundleStatus
-
-  constructor() {
-    super()
-    this.loading = false
-    this.title = $localize`Create share link bundle`
-    this.btnCaption = $localize`Create link`
-  }
-
-  @Input()
-  set documents(docs: Document[]) {
-    this._documents = docs.concat()
-    this.selectionCount = this._documents.length
-    this.documentPreview = this._documents.slice(0, 10)
-  }
-
-  submit() {
-    if (this.createdBundle) return
-    this.payload = {
-      document_ids: this._documents.map((doc) => doc.id),
-      file_version: this.form.value.shareArchiveVersion
-        ? FileVersion.Archive
-        : FileVersion.Original,
-      expiration_days: this.form.value.expirationDays,
-    }
-    this.buttonsEnabled = false
-    super.confirm()
-  }
-
-  getShareUrl(bundle: ShareLinkBundleSummary): string {
-    const apiURL = new URL(environment.apiBaseUrl)
-    return `${apiURL.origin}${apiURL.pathname.replace(/\/api\/$/, '/share/')}${
-      bundle.slug
-    }`
-  }
-
-  copy(bundle: ShareLinkBundleSummary): void {
-    const success = this.clipboard.copy(this.getShareUrl(bundle))
-    if (success) {
-      this.copied = true
-      this.toastService.showInfo($localize`Share link copied to clipboard.`)
-      setTimeout(() => {
-        this.copied = false
-      }, 3000)
-    }
-  }
-
-  openManage(): void {
-    if (this.onOpenManage) {
-      this.onOpenManage()
-    } else {
-      this.cancel()
-    }
-  }
-
-  statusLabel(status: ShareLinkBundleSummary['status']): string {
-    return SHARE_LINK_BUNDLE_STATUS_LABELS[status] ?? status
-  }
-
-  fileVersionLabel(version: FileVersion): string {
-    return SHARE_LINK_BUNDLE_FILE_VERSION_LABELS[version] ?? version
-  }
-}

src-ui/src/app/components/common/share-link-bundle-manage-dialog/share-link-bundle-manage-dialog.component.html

@@ -1,131 +0,0 @@
-<div class="modal-header">
-  <h4 class="modal-title">{{ title }}</h4>
-  <button type="button" class="btn-close" aria-label="Close" (click)="close()"></button>
-</div>
-
-<div class="modal-body">
-  @if (loading) {
-    <div class="d-flex align-items-center gap-2">
-      <div class="spinner-border spinner-border-sm" role="status"></div>
-      <span i18n>Loading share link bundles…</span>
-    </div>
-  }
-  @if (!loading && error) {
-    <div class="alert alert-danger mb-0" role="alert">
-      {{ error }}
-    </div>
-  }
-  @if (!loading && !error) {
-    <div class="d-flex justify-content-between align-items-center mb-2">
-      <p class="mb-0 text-muted small">
-        <ng-container i18n>Status updates every few seconds while bundles are being prepared.</ng-container>
-      </p>
-    </div>
-    @if (bundles.length === 0) {
-      <p class="mb-0 text-muted fst-italic" i18n>No share link bundles currently exist.</p>
-    }
-    @if (bundles.length > 0) {
-      <div class="table-responsive">
-        <table class="table table-sm align-middle mb-0">
-          <thead>
-            <tr>
-              <th scope="col" i18n>Created</th>
-              <th scope="col" i18n>Status</th>
-              <th scope="col" i18n>Size</th>
-              <th scope="col" i18n>Expires</th>
-              <th scope="col" i18n>Documents</th>
-              <th scope="col" i18n>File version</th>
-              <th scope="col" class="text-end" i18n>Actions</th>
-            </tr>
-          </thead>
-          <tbody>
-            @for (bundle of bundles; track bundle.id) {
-              <tr>
-                <td>
-                  <div>{{ bundle.created | date: 'short' }}</div>
-                  @if (bundle.built_at) {
-                    <div class="small text-muted">
-                      <ng-container i18n>Built:</ng-container> {{ bundle.built_at | date: 'short' }}
-                    </div>
-                  }
-                </td>
-                <td>
-                  <div class="d-flex align-items-center gap-2">
-                    @if (bundle.status === statuses.Processing || bundle.status === statuses.Pending) {
-                      <span class="spinner-border spinner-border-sm" role="status"></span>
-                    }
-                    <span class="badge text-bg-secondary text-uppercase">{{ statusLabel(bundle.status) }}</span>
-                  </div>
-                  @if (bundle.last_error && bundle.status === statuses.Failed) {
-                    <div class="small text-danger mt-1">{{ bundle.last_error }}</div>
-                  }
-                </td>
-                <td>
-                  @if (bundle.size_bytes !== undefined && bundle.size_bytes !== null) {
-                    {{ bundle.size_bytes | fileSize }}
-                  }
-                  @if (bundle.size_bytes === undefined || bundle.size_bytes === null) {
-                    <span class="text-muted">&mdash;</span>
-                  }
-                </td>
-                <td>
-                  @if (bundle.expiration) {
-                    {{ bundle.expiration | date: 'short' }}
-                  }
-                  @if (!bundle.expiration) {
-                    <span i18n>Never</span>
-                  }
-                </td>
-                <td>{{ bundle.document_count }}</td>
-                <td>{{ fileVersionLabel(bundle.file_version) }}</td>
-                <td class="text-end">
-                  <div class="btn-group btn-group-sm">
-                    <button
-                      type="button"
-                      class="btn btn-outline-primary"
-                      [disabled]="bundle.status !== statuses.Ready"
-                      (click)="copy(bundle)"
-                      title="Copy share link"
-                      i18n-title
-                    >
-                      @if (copiedSlug === bundle.slug) {
-                        <i-bs name="clipboard-check"></i-bs>
-                      }
-                      @if (copiedSlug !== bundle.slug) {
-                        <i-bs name="clipboard"></i-bs>
-                      }
-                      <span class="visually-hidden" i18n>Copy share link</span>
-                    </button>
-                    @if (bundle.status === statuses.Failed) {
-                      <button
-                        type="button"
-                        class="btn btn-outline-warning"
-                        [disabled]="loading"
-                        (click)="retry(bundle)"
-                      >
-                        <i-bs name="arrow-clockwise"></i-bs>
-                        <span class="visually-hidden" i18n>Retry</span>
-                      </button>
-                    }
-                    <pngx-confirm-button
-                      buttonClasses="btn btn-sm btn-outline-danger"
-                      [disabled]="loading"
-                      (confirm)="delete(bundle)"
-                      iconName="trash"
-                    >
-                      <span class="visually-hidden" i18n>Delete share link bundle</span>
-                    </pngx-confirm-button>
-                  </div>
-                </td>
-              </tr>
-            }
-          </tbody>
-        </table>
-      </div>
-    }
-  }
-</div>
-
-<div class="modal-footer">
-  <button type="button" class="btn btn-outline-secondary btn-sm" (click)="close()" i18n>Close</button>
-</div>

src-ui/src/app/components/common/share-link-bundle-manage-dialog/share-link-bundle-manage-dialog.component.spec.ts

@@ -1,250 +0,0 @@
-import { Clipboard } from '@angular/cdk/clipboard'
-import {
-  ComponentFixture,
-  TestBed,
-  fakeAsync,
-  tick,
-} from '@angular/core/testing'
-import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap'
-import { NgxBootstrapIconsModule, allIcons } from 'ngx-bootstrap-icons'
-import { of, throwError } from 'rxjs'
-import { FileVersion } from 'src/app/data/share-link'
-import {
-  ShareLinkBundleStatus,
-  ShareLinkBundleSummary,
-} from 'src/app/data/share-link-bundle'
-import { ShareLinkBundleService } from 'src/app/services/rest/share-link-bundle.service'
-import { ToastService } from 'src/app/services/toast.service'
-import { environment } from 'src/environments/environment'
-import { ShareLinkBundleManageDialogComponent } from './share-link-bundle-manage-dialog.component'
-
-class MockShareLinkBundleService {
-  listAllBundles = jest.fn()
-  delete = jest.fn()
-  rebuildBundle = jest.fn()
-}
-
-class MockToastService {
-  showInfo = jest.fn()
-  showError = jest.fn()
-}
-
-describe('ShareLinkBundleManageDialogComponent', () => {
-  let component: ShareLinkBundleManageDialogComponent
-  let fixture: ComponentFixture<ShareLinkBundleManageDialogComponent>
-  let service: MockShareLinkBundleService
-  let toastService: MockToastService
-  let clipboard: Clipboard
-  let activeModal: NgbActiveModal
-  let originalApiBaseUrl: string
-
-  beforeEach(() => {
-    service = new MockShareLinkBundleService()
-    toastService = new MockToastService()
-    originalApiBaseUrl = environment.apiBaseUrl
-
-    service.listAllBundles.mockReturnValue(of([]))
-    service.delete.mockReturnValue(of(true))
-    service.rebuildBundle.mockReturnValue(of(sampleBundle()))
-
-    TestBed.configureTestingModule({
-      imports: [
-        ShareLinkBundleManageDialogComponent,
-        NgxBootstrapIconsModule.pick(allIcons),
-      ],
-      providers: [
-        NgbActiveModal,
-        { provide: ShareLinkBundleService, useValue: service },
-        { provide: ToastService, useValue: toastService },
-      ],
-    })
-
-    fixture = TestBed.createComponent(ShareLinkBundleManageDialogComponent)
-    component = fixture.componentInstance
-    clipboard = TestBed.inject(Clipboard)
-    activeModal = TestBed.inject(NgbActiveModal)
-  })
-
-  afterEach(() => {
-    component.ngOnDestroy()
-    fixture.destroy()
-    environment.apiBaseUrl = originalApiBaseUrl
-    jest.clearAllMocks()
-  })
-
-  const sampleBundle = (overrides: Partial<ShareLinkBundleSummary> = {}) =>
-    ({
-      id: 1,
-      slug: 'bundle-slug',
-      created: new Date().toISOString(),
-      document_count: 1,
-      documents: [1],
-      status: ShareLinkBundleStatus.Pending,
-      file_version: FileVersion.Archive,
-      ...overrides,
-    }) as ShareLinkBundleSummary
-
-  it('loads bundles on init and polls periodically', fakeAsync(() => {
-    const bundles = [sampleBundle({ status: ShareLinkBundleStatus.Ready })]
-    service.listAllBundles.mockReset()
-    service.listAllBundles
-      .mockReturnValueOnce(of(bundles))
-      .mockReturnValue(of(bundles))
-
-    fixture.detectChanges()
-    tick()
-
-    expect(service.listAllBundles).toHaveBeenCalledTimes(1)
-    expect(component.bundles).toEqual(bundles)
-    expect(component.loading).toBe(false)
-    expect(component.error).toBeNull()
-
-    tick(5000)
-    expect(service.listAllBundles).toHaveBeenCalledTimes(2)
-  }))
-
-  it('handles errors when loading bundles', fakeAsync(() => {
-    service.listAllBundles.mockReset()
-    service.listAllBundles
-      .mockReturnValueOnce(throwError(() => new Error('load fail')))
-      .mockReturnValue(of([]))
-
-    fixture.detectChanges()
-    tick()
-
-    expect(component.error).toContain('Failed to load share link bundles.')
-    expect(toastService.showError).toHaveBeenCalled()
-    expect(component.loading).toBe(false)
-
-    tick(5000)
-    expect(service.listAllBundles).toHaveBeenCalledTimes(2)
-  }))
-
-  it('copies bundle links when ready', fakeAsync(() => {
-    jest.spyOn(clipboard, 'copy').mockReturnValue(true)
-    fixture.detectChanges()
-    tick()
-
-    const readyBundle = sampleBundle({
-      slug: 'ready-slug',
-      status: ShareLinkBundleStatus.Ready,
-    })
-    component.copy(readyBundle)
-
-    expect(clipboard.copy).toHaveBeenCalledWith(
-      component.getShareUrl(readyBundle)
-    )
-    expect(component.copiedSlug).toBe('ready-slug')
-    expect(toastService.showInfo).toHaveBeenCalled()
-
-    tick(3000)
-    expect(component.copiedSlug).toBeNull()
-  }))
-
-  it('ignores copy requests for non-ready bundles', fakeAsync(() => {
-    const copySpy = jest.spyOn(clipboard, 'copy')
-    fixture.detectChanges()
-    tick()
-    component.copy(sampleBundle({ status: ShareLinkBundleStatus.Pending }))
-    expect(copySpy).not.toHaveBeenCalled()
-  }))
-
-  it('deletes bundles and refreshes list', fakeAsync(() => {
-    service.listAllBundles.mockReturnValue(of([]))
-    service.delete.mockReturnValue(of(true))
-
-    fixture.detectChanges()
-    tick()
-
-    component.delete(sampleBundle())
-    tick()
-
-    expect(service.delete).toHaveBeenCalled()
-    expect(toastService.showInfo).toHaveBeenCalledWith(
-      expect.stringContaining('deleted.')
-    )
-    expect(service.listAllBundles).toHaveBeenCalledTimes(2)
-    expect(component.loading).toBe(false)
-  }))
-
-  it('handles delete errors gracefully', fakeAsync(() => {
-    service.listAllBundles.mockReturnValue(of([]))
-    service.delete.mockReturnValue(throwError(() => new Error('delete fail')))
-
-    fixture.detectChanges()
-    tick()
-
-    component.delete(sampleBundle())
-    tick()
-
-    expect(toastService.showError).toHaveBeenCalled()
-    expect(component.loading).toBe(false)
-  }))
-
-  it('retries bundle build and replaces existing entry', fakeAsync(() => {
-    service.listAllBundles.mockReturnValue(of([]))
-    const updated = sampleBundle({ status: ShareLinkBundleStatus.Ready })
-    service.rebuildBundle.mockReturnValue(of(updated))
-
-    fixture.detectChanges()
-    tick()
-
-    component.bundles = [sampleBundle()]
-    component.retry(component.bundles[0])
-    tick()
-
-    expect(service.rebuildBundle).toHaveBeenCalledWith(updated.id)
-    expect(component.bundles[0].status).toBe(ShareLinkBundleStatus.Ready)
-    expect(toastService.showInfo).toHaveBeenCalled()
-  }))
-
-  it('adds new bundle when retry returns unknown entry', fakeAsync(() => {
-    service.listAllBundles.mockReturnValue(of([]))
-    service.rebuildBundle.mockReturnValue(
-      of(sampleBundle({ id: 99, slug: 'new-slug' }))
-    )
-
-    fixture.detectChanges()
-    tick()
-
-    component.bundles = [sampleBundle()]
-    component.retry({ id: 99 } as ShareLinkBundleSummary)
-    tick()
-
-    expect(component.bundles.find((bundle) => bundle.id === 99)).toBeTruthy()
-  }))
-
-  it('handles retry errors', fakeAsync(() => {
-    service.listAllBundles.mockReturnValue(of([]))
-    service.rebuildBundle.mockReturnValue(throwError(() => new Error('fail')))
-
-    fixture.detectChanges()
-    tick()
-
-    component.retry(sampleBundle())
-    tick()
-
-    expect(toastService.showError).toHaveBeenCalled()
-  }))
-
-  it('maps helpers and closes dialog', fakeAsync(() => {
-    service.listAllBundles.mockReturnValue(of([]))
-    fixture.detectChanges()
-    tick()
-
-    expect(component.statusLabel(ShareLinkBundleStatus.Processing)).toContain(
-      'Processing'
-    )
-    expect(component.fileVersionLabel(FileVersion.Original)).toContain(
-      'Original'
-    )
-
-    environment.apiBaseUrl = 'https://example.com/api/'
-    const url = component.getShareUrl(sampleBundle({ slug: 'sluggy' }))
-    expect(url).toBe('https://example.com/share/sluggy')
-
-    const closeSpy = jest.spyOn(activeModal, 'close')
-    component.close()
-    expect(closeSpy).toHaveBeenCalled()
-  }))
-})

src-ui/src/app/components/common/share-link-bundle-manage-dialog/share-link-bundle-manage-dialog.component.ts

@@ -1,175 +0,0 @@
-import { Clipboard } from '@angular/cdk/clipboard'
-import { CommonModule } from '@angular/common'
-import { Component, OnDestroy, OnInit, inject } from '@angular/core'
-import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap'
-import { NgxBootstrapIconsModule } from 'ngx-bootstrap-icons'
-import { Subject, catchError, of, switchMap, takeUntil, timer } from 'rxjs'
-import { FileVersion } from 'src/app/data/share-link'
-import {
-  SHARE_LINK_BUNDLE_FILE_VERSION_LABELS,
-  SHARE_LINK_BUNDLE_STATUS_LABELS,
-  ShareLinkBundleStatus,
-  ShareLinkBundleSummary,
-} from 'src/app/data/share-link-bundle'
-import { FileSizePipe } from 'src/app/pipes/file-size.pipe'
-import { ShareLinkBundleService } from 'src/app/services/rest/share-link-bundle.service'
-import { ToastService } from 'src/app/services/toast.service'
-import { environment } from 'src/environments/environment'
-import { LoadingComponentWithPermissions } from '../../loading-component/loading.component'
-import { ConfirmButtonComponent } from '../confirm-button/confirm-button.component'
-
-@Component({
-  selector: 'pngx-share-link-bundle-manage-dialog',
-  templateUrl: './share-link-bundle-manage-dialog.component.html',
-  imports: [
-    ConfirmButtonComponent,
-    CommonModule,
-    NgxBootstrapIconsModule,
-    FileSizePipe,
-  ],
-})
-export class ShareLinkBundleManageDialogComponent
-  extends LoadingComponentWithPermissions
-  implements OnInit, OnDestroy
-{
-  private readonly activeModal = inject(NgbActiveModal)
-  private readonly shareLinkBundleService = inject(ShareLinkBundleService)
-  private readonly toastService = inject(ToastService)
-  private readonly clipboard = inject(Clipboard)
-
-  title = $localize`Share link bundles`
-
-  bundles: ShareLinkBundleSummary[] = []
-  error: string | null = null
-  copiedSlug: string | null = null
-
-  readonly statuses = ShareLinkBundleStatus
-  readonly fileVersions = FileVersion
-
-  private readonly refresh$ = new Subject<boolean>()
-
-  ngOnInit(): void {
-    this.refresh$
-      .pipe(
-        switchMap((silent) => {
-          if (!silent) {
-            this.loading = true
-          }
-          this.error = null
-          return this.shareLinkBundleService.listAllBundles().pipe(
-            catchError((error) => {
-              if (!silent) {
-                this.loading = false
-              }
-              this.error = $localize`Failed to load share link bundles.`
-              this.toastService.showError(
-                $localize`Error retrieving share link bundles.`,
-                error
-              )
-              return of(null)
-            })
-          )
-        }),
-        takeUntil(this.unsubscribeNotifier)
-      )
-      .subscribe((results) => {
-        if (results) {
-          this.bundles = results
-          this.copiedSlug = null
-        }
-        this.loading = false
-      })
-
-    this.triggerRefresh(false)
-    timer(5000, 5000)
-      .pipe(takeUntil(this.unsubscribeNotifier))
-      .subscribe(() => this.triggerRefresh(true))
-  }
-
-  ngOnDestroy(): void {
-    super.ngOnDestroy()
-  }
-
-  getShareUrl(bundle: ShareLinkBundleSummary): string {
-    const apiURL = new URL(environment.apiBaseUrl)
-    return `${apiURL.origin}${apiURL.pathname.replace(/\/api\/$/, '/share/')}${
-      bundle.slug
-    }`
-  }
-
-  copy(bundle: ShareLinkBundleSummary): void {
-    if (bundle.status !== ShareLinkBundleStatus.Ready) {
-      return
-    }
-    const success = this.clipboard.copy(this.getShareUrl(bundle))
-    if (success) {
-      this.copiedSlug = bundle.slug
-      setTimeout(() => {
-        this.copiedSlug = null
-      }, 3000)
-      this.toastService.showInfo($localize`Share link copied to clipboard.`)
-    }
-  }
-
-  delete(bundle: ShareLinkBundleSummary): void {
-    this.error = null
-    this.loading = true
-    this.shareLinkBundleService.delete(bundle).subscribe({
-      next: () => {
-        this.toastService.showInfo($localize`Share link bundle deleted.`)
-        this.triggerRefresh(false)
-      },
-      error: (e) => {
-        this.loading = false
-        this.toastService.showError(
-          $localize`Error deleting share link bundle.`,
-          e
-        )
-      },
-    })
-  }
-
-  retry(bundle: ShareLinkBundleSummary): void {
-    this.error = null
-    this.shareLinkBundleService.rebuildBundle(bundle.id).subscribe({
-      next: (updated) => {
-        this.toastService.showInfo(
-          $localize`Share link bundle rebuild requested.`
-        )
-        this.replaceBundle(updated)
-      },
-      error: (e) => {
-        this.toastService.showError($localize`Error requesting rebuild.`, e)
-      },
-    })
-  }
-
-  statusLabel(status: ShareLinkBundleStatus): string {
-    return SHARE_LINK_BUNDLE_STATUS_LABELS[status] ?? status
-  }
-
-  fileVersionLabel(version: FileVersion): string {
-    return SHARE_LINK_BUNDLE_FILE_VERSION_LABELS[version] ?? version
-  }
-
-  close(): void {
-    this.activeModal.close()
-  }
-
-  private replaceBundle(updated: ShareLinkBundleSummary): void {
-    const index = this.bundles.findIndex((bundle) => bundle.id === updated.id)
-    if (index >= 0) {
-      this.bundles = [
-        ...this.bundles.slice(0, index),
-        updated,
-        ...this.bundles.slice(index + 1),
-      ]
-    } else {
-      this.bundles = [updated, ...this.bundles]
-    }
-  }
-
-  private triggerRefresh(silent: boolean): void {
-    this.refresh$.next(silent)
-  }
-}

src-ui/src/app/components/common/share-links-dialog/share-links-dialog.component.html

@@ -51,7 +51,7 @@
   <div class="input-group w-100 mt-2">
     <label class="input-group-text" for="addLink"><ng-container i18n>Expires</ng-container>:</label>
     <select class="form-select fs-6" [(ngModel)]="expirationDays">
-      @for (option of expirationOptions; track option) {
+      @for (option of EXPIRATION_OPTIONS; track option) {
         <option [ngValue]="option.value">{{ option.label }}</option>
       }
     </select>

src-ui/src/app/components/common/share-links-dialog/share-links-dialog.component.ts

@@ -4,11 +4,7 @@ import { FormsModule, ReactiveFormsModule } from '@angular/forms'
 import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap'
 import { NgxBootstrapIconsModule } from 'ngx-bootstrap-icons'
 import { first } from 'rxjs'
-import {
-  FileVersion,
-  SHARE_LINK_EXPIRATION_OPTIONS,
-  ShareLink,
-} from 'src/app/data/share-link'
+import { FileVersion, ShareLink } from 'src/app/data/share-link'
 import { ShareLinkService } from 'src/app/services/rest/share-link.service'
 import { ToastService } from 'src/app/services/toast.service'
 import { environment } from 'src/environments/environment'
@@ -25,7 +21,12 @@ export class ShareLinksDialogComponent implements OnInit {
   private toastService = inject(ToastService)
   private clipboard = inject(Clipboard)
 
-  readonly expirationOptions = SHARE_LINK_EXPIRATION_OPTIONS
+  EXPIRATION_OPTIONS = [
+    { label: $localize`1 day`, value: 1 },
+    { label: $localize`7 days`, value: 7 },
+    { label: $localize`30 days`, value: 30 },
+    { label: $localize`Never`, value: null },
+  ]
 
   @Input()
   title = $localize`Share Links`

src-ui/src/app/components/document-list/bulk-editor/bulk-editor.component.html

@@ -96,36 +96,14 @@
           <button ngbDropdownItem (click)="mergeSelected()" [disabled]="!userCanAdd || list.selected.size < 2">
             <i-bs name="journals"></i-bs>&nbsp;<ng-container i18n>Merge</ng-container>
           </button>
+          @if (emailEnabled) {
+            <button ngbDropdownItem (click)="emailSelected()">
+              <i-bs name="envelope"></i-bs>&nbsp;<ng-container i18n>Email</ng-container>
+            </button>
+          }
         </div>
       </div>
     </div>
-    <div class="btn-toolbar" ngbDropdown>
-      <button
-        class="btn btn-sm btn-outline-primary"
-        id="dropdownSend"
-        ngbDropdownToggle
-        [disabled]="disabled || list.selected.size === 0"
-      >
-        <i-bs name="send"></i-bs>
-        <div class="d-none d-sm-inline">
-          &nbsp;<ng-container i18n>Send</ng-container>
-        </div>
-      </button>
-      <div ngbDropdownMenu aria-labelledby="dropdownSend" class="shadow">
-        <button ngbDropdownItem (click)="createShareLinkBundle()">
-          <i-bs name="link"></i-bs>&nbsp;<ng-container i18n>Create a share link bundle</ng-container>
-        </button>
-        <button ngbDropdownItem (click)="manageShareLinkBundles()">
-          <i-bs name="list-ul"></i-bs>&nbsp;<ng-container i18n>Manage share link bundles</ng-container>
-        </button>
-        <div class="dropdown-divider"></div>
-        @if (emailEnabled) {
-          <button ngbDropdownItem (click)="emailSelected()">
-            <i-bs name="envelope"></i-bs>&nbsp;<ng-container i18n>Email</ng-container>
-          </button>
-        }
-      </div>
-    </div>
     <div class="btn-group btn-group-sm">
       <button class="btn btn-sm btn-outline-primary" [disabled]="awaitingDownload" (click)="downloadSelected()">
         @if (!awaitingDownload) {

src-ui/src/app/components/document-list/bulk-editor/bulk-editor.component.spec.ts

@@ -3,7 +3,6 @@ import {
   HttpTestingController,
   provideHttpClientTesting,
 } from '@angular/common/http/testing'
-import { EventEmitter } from '@angular/core'
 import { ComponentFixture, TestBed } from '@angular/core/testing'
 import { By } from '@angular/platform-browser'
 import { NgbModal, NgbModalRef } from '@ng-bootstrap/ng-bootstrap'
@@ -26,7 +25,6 @@ import {
   SelectionData,
 } from 'src/app/services/rest/document.service'
 import { GroupService } from 'src/app/services/rest/group.service'
-import { ShareLinkBundleService } from 'src/app/services/rest/share-link-bundle.service'
 import { StoragePathService } from 'src/app/services/rest/storage-path.service'
 import { TagService } from 'src/app/services/rest/tag.service'
 import { UserService } from 'src/app/services/rest/user.service'
@@ -40,8 +38,6 @@ import { EditDialogMode } from '../../common/edit-dialog/edit-dialog.component'
 import { StoragePathEditDialogComponent } from '../../common/edit-dialog/storage-path-edit-dialog/storage-path-edit-dialog.component'
 import { TagEditDialogComponent } from '../../common/edit-dialog/tag-edit-dialog/tag-edit-dialog.component'
 import { FilterableDropdownComponent } from '../../common/filterable-dropdown/filterable-dropdown.component'
-import { ShareLinkBundleDialogComponent } from '../../common/share-link-bundle-dialog/share-link-bundle-dialog.component'
-import { ShareLinkBundleManageDialogComponent } from '../../common/share-link-bundle-manage-dialog/share-link-bundle-manage-dialog.component'
 import { BulkEditorComponent } from './bulk-editor.component'
 
 const selectionData: SelectionData = {
@@ -76,7 +72,6 @@ describe('BulkEditorComponent', () => {
   let storagePathService: StoragePathService
   let customFieldsService: CustomFieldsService
   let httpTestingController: HttpTestingController
-  let shareLinkBundleService: ShareLinkBundleService
 
   beforeEach(async () => {
     TestBed.configureTestingModule({
@@ -157,15 +152,6 @@ describe('BulkEditorComponent', () => {
               }),
           },
         },
-        {
-          provide: ShareLinkBundleService,
-          useValue: {
-            createBundle: jest.fn(),
-            listAllBundles: jest.fn(),
-            rebuildBundle: jest.fn(),
-            delete: jest.fn(),
-          },
-        },
         provideHttpClient(withInterceptorsFromDi()),
         provideHttpClientTesting(),
       ],
@@ -182,7 +168,6 @@ describe('BulkEditorComponent', () => {
     storagePathService = TestBed.inject(StoragePathService)
     customFieldsService = TestBed.inject(CustomFieldsService)
     httpTestingController = TestBed.inject(HttpTestingController)
-    shareLinkBundleService = TestBed.inject(ShareLinkBundleService)
 
     fixture = TestBed.createComponent(BulkEditorComponent)
     component = fixture.componentInstance
@@ -1469,130 +1454,4 @@ describe('BulkEditorComponent', () => {
       `${environment.apiBaseUrl}documents/?page=1&page_size=100000&fields=id`
     ) // listAllFilteredIds
   })
-
-  it('should create share link bundle and enable manage callback', () => {
-    jest.spyOn(permissionsService, 'currentUserCan').mockReturnValue(true)
-    jest
-      .spyOn(documentListViewService, 'documents', 'get')
-      .mockReturnValue([{ id: 5 }, { id: 7 }] as any)
-    jest
-      .spyOn(documentListViewService, 'selected', 'get')
-      .mockReturnValue(new Set([5, 7]))
-
-    const confirmClicked = new EventEmitter<void>()
-    const modalRef: Partial<NgbModalRef> = {
-      close: jest.fn(),
-      componentInstance: {
-        documents: [],
-        confirmClicked,
-        payload: {
-          document_ids: [5, 7],
-          file_version: 'archive',
-          expiration_days: 7,
-        },
-        loading: false,
-        buttonsEnabled: true,
-        copied: false,
-      },
-    }
-
-    const openSpy = jest.spyOn(modalService, 'open')
-    openSpy.mockReturnValueOnce(modalRef as NgbModalRef)
-    openSpy.mockReturnValueOnce({} as NgbModalRef)
-    ;(shareLinkBundleService.createBundle as jest.Mock).mockReturnValueOnce(
-      of({ id: 42 })
-    )
-    const toastInfoSpy = jest.spyOn(toastService, 'showInfo')
-
-    component.createShareLinkBundle()
-
-    expect(openSpy).toHaveBeenNthCalledWith(
-      1,
-      ShareLinkBundleDialogComponent,
-      expect.objectContaining({ backdrop: 'static', size: 'lg' })
-    )
-
-    const dialogInstance = modalRef.componentInstance as any
-    expect(dialogInstance.documents).toEqual([{ id: 5 }, { id: 7 }])
-
-    confirmClicked.emit()
-
-    expect(shareLinkBundleService.createBundle).toHaveBeenCalledWith({
-      document_ids: [5, 7],
-      file_version: 'archive',
-      expiration_days: 7,
-    })
-    expect(dialogInstance.loading).toBe(false)
-    expect(dialogInstance.buttonsEnabled).toBe(false)
-    expect(dialogInstance.createdBundle).toEqual({ id: 42 })
-    expect(typeof dialogInstance.onOpenManage).toBe('function')
-    expect(toastInfoSpy).toHaveBeenCalledWith(
-      $localize`Share link bundle creation requested.`
-    )
-
-    dialogInstance.onOpenManage()
-    expect(modalRef.close).toHaveBeenCalled()
-    expect(openSpy).toHaveBeenNthCalledWith(
-      2,
-      ShareLinkBundleManageDialogComponent,
-      expect.objectContaining({ backdrop: 'static', size: 'lg' })
-    )
-    openSpy.mockRestore()
-  })
-
-  it('should handle share link bundle creation errors', () => {
-    jest.spyOn(permissionsService, 'currentUserCan').mockReturnValue(true)
-    jest
-      .spyOn(documentListViewService, 'documents', 'get')
-      .mockReturnValue([{ id: 9 }] as any)
-    jest
-      .spyOn(documentListViewService, 'selected', 'get')
-      .mockReturnValue(new Set([9]))
-
-    const confirmClicked = new EventEmitter<void>()
-    const modalRef: Partial<NgbModalRef> = {
-      componentInstance: {
-        documents: [],
-        confirmClicked,
-        payload: {
-          document_ids: [9],
-          file_version: 'original',
-          expiration_days: null,
-        },
-        loading: false,
-        buttonsEnabled: true,
-      },
-    }
-
-    const openSpy = jest
-      .spyOn(modalService, 'open')
-      .mockReturnValue(modalRef as NgbModalRef)
-    ;(shareLinkBundleService.createBundle as jest.Mock).mockReturnValueOnce(
-      throwError(() => new Error('bundle failure'))
-    )
-    const toastErrorSpy = jest.spyOn(toastService, 'showError')
-
-    component.createShareLinkBundle()
-
-    const dialogInstance = modalRef.componentInstance as any
-    confirmClicked.emit()
-
-    expect(toastErrorSpy).toHaveBeenCalledWith(
-      $localize`Share link bundle creation is not available yet.`,
-      expect.any(Error)
-    )
-    expect(dialogInstance.loading).toBe(false)
-    expect(dialogInstance.buttonsEnabled).toBe(true)
-    openSpy.mockRestore()
-  })
-
-  it('should open share link bundle management dialog', () => {
-    const openSpy = jest.spyOn(modalService, 'open')
-    component.manageShareLinkBundles()
-    expect(openSpy).toHaveBeenCalledWith(
-      ShareLinkBundleManageDialogComponent,
-      expect.objectContaining({ backdrop: 'static', size: 'lg' })
-    )
-    openSpy.mockRestore()
-  })
 })

src-ui/src/app/components/document-list/bulk-editor/bulk-editor.component.ts

@@ -33,7 +33,6 @@ import {
   SelectionDataItem,
 } from 'src/app/services/rest/document.service'
 import { SavedViewService } from 'src/app/services/rest/saved-view.service'
-import { ShareLinkBundleService } from 'src/app/services/rest/share-link-bundle.service'
 import { StoragePathService } from 'src/app/services/rest/storage-path.service'
 import { TagService } from 'src/app/services/rest/tag.service'
 import { SettingsService } from 'src/app/services/settings.service'
@@ -55,8 +54,6 @@ import {
 } from '../../common/filterable-dropdown/filterable-dropdown.component'
 import { ToggleableItemState } from '../../common/filterable-dropdown/toggleable-dropdown-button/toggleable-dropdown-button.component'
 import { PermissionsDialogComponent } from '../../common/permissions-dialog/permissions-dialog.component'
-import { ShareLinkBundleDialogComponent } from '../../common/share-link-bundle-dialog/share-link-bundle-dialog.component'
-import { ShareLinkBundleManageDialogComponent } from '../../common/share-link-bundle-manage-dialog/share-link-bundle-manage-dialog.component'
 import { ComponentWithPermissions } from '../../with-permissions/with-permissions.component'
 import { CustomFieldsBulkEditDialogComponent } from './custom-fields-bulk-edit-dialog/custom-fields-bulk-edit-dialog.component'
 
@@ -90,7 +87,6 @@ export class BulkEditorComponent
   private customFieldService = inject(CustomFieldsService)
   private permissionService = inject(PermissionsService)
   private savedViewService = inject(SavedViewService)
-  private readonly shareLinkBundleService = inject(ShareLinkBundleService)
 
   tagSelectionModel = new FilterableDropdownSelectionModel(true)
   correspondentSelectionModel = new FilterableDropdownSelectionModel()
@@ -912,58 +908,6 @@ export class BulkEditorComponent
     return this.settings.get(SETTINGS_KEYS.EMAIL_ENABLED)
   }
 
-  createShareLinkBundle() {
-    const modal = this.modalService.open(ShareLinkBundleDialogComponent, {
-      backdrop: 'static',
-      size: 'lg',
-    })
-    const dialog = modal.componentInstance as ShareLinkBundleDialogComponent
-    const selectedDocuments = this.list.documents.filter((d) =>
-      this.list.selected.has(d.id)
-    )
-    dialog.documents = selectedDocuments
-    dialog.confirmClicked
-      .pipe(takeUntil(this.unsubscribeNotifier))
-      .subscribe(() => {
-        dialog.loading = true
-        dialog.buttonsEnabled = false
-        this.shareLinkBundleService
-          .createBundle(dialog.payload)
-          .pipe(first())
-          .subscribe({
-            next: (result) => {
-              dialog.loading = false
-              dialog.buttonsEnabled = false
-              dialog.createdBundle = result
-              dialog.copied = false
-              dialog.payload = null
-              dialog.onOpenManage = () => {
-                modal.close()
-                this.manageShareLinkBundles()
-              }
-              this.toastService.showInfo(
-                $localize`Share link bundle creation requested.`
-              )
-            },
-            error: (error) => {
-              dialog.loading = false
-              dialog.buttonsEnabled = true
-              this.toastService.showError(
-                $localize`Share link bundle creation is not available yet.`,
-                error
-              )
-            },
-          })
-      })
-  }
-
-  manageShareLinkBundles() {
-    this.modalService.open(ShareLinkBundleManageDialogComponent, {
-      backdrop: 'static',
-      size: 'lg',
-    })
-  }
-
   emailSelected() {
     const allHaveArchiveVersion = this.list.documents
       .filter((d) => this.list.selected.has(d.id))

src-ui/src/app/components/manage/correspondent-list/correspondent-list.component.ts

@@ -1,6 +1,7 @@
 import { NgClass, NgTemplateOutlet, TitleCasePipe } from '@angular/common'
 import { Component, inject } from '@angular/core'
 import { FormsModule, ReactiveFormsModule } from '@angular/forms'
+import { RouterModule } from '@angular/router'
 import {
   NgbDropdownModule,
   NgbPaginationModule,
@@ -29,6 +30,7 @@ import { ManagementListComponent } from '../management-list/management-list.comp
     TitleCasePipe,
     FormsModule,
     ReactiveFormsModule,
+    RouterModule,
     NgClass,
     NgTemplateOutlet,
     NgbDropdownModule,

src-ui/src/app/components/manage/custom-fields/custom-fields.component.html

@@ -42,7 +42,13 @@
                 <button (click)="editField(field)" *pngxIfPermissions="{ action: PermissionAction.Change, type: PermissionType.CustomField }" ngbDropdownItem i18n>Edit</button>
                 <button class="text-danger" (click)="deleteField(field)" *pngxIfPermissions="{ action: PermissionAction.Delete, type: PermissionType.CustomField }" ngbDropdownItem i18n>Delete</button>
                 @if (field.document_count > 0) {
-                  <button (click)="filterDocuments(field)" *pngxIfPermissions="{ action: PermissionAction.View, type: PermissionType.Document }" ngbDropdownItem i18n>Filter Documents ({{ field.document_count }})</button>
+                  <a
+                    *pngxIfPermissions="{ action: PermissionAction.View, type: PermissionType.Document }"
+                    ngbDropdownItem
+                    [routerLink]="getDocumentFilterUrl(field)"
+                    i18n
+                    >Filter Documents ({{ field.document_count }})</a
+                  >
                 }
               </div>
             </div>
@@ -57,9 +63,13 @@
           </div>
           @if (field.document_count > 0) {
             <div class="btn-group d-none d-sm-inline-block ms-2">
-              <button class="btn btn-sm btn-outline-secondary" type="button" (click)="filterDocuments(field)">
-                <i-bs width="1em" height="1em" name="filter"></i-bs>&nbsp;<ng-container i18n>Documents</ng-container><span class="badge bg-light text-secondary ms-2">{{ field.document_count }}</span>
-              </button>
+              <a
+                class="btn btn-sm btn-outline-secondary"
+                [routerLink]="getDocumentFilterUrl(field)"
+              >
+                <i-bs width="1em" height="1em" name="filter"></i-bs>&nbsp;<ng-container i18n>Documents</ng-container
+                ><span class="badge bg-light text-secondary ms-2">{{ field.document_count }}</span>
+              </a>
             </div>
           }
         </div>

src-ui/src/app/components/manage/custom-fields/custom-fields.component.spec.ts

@@ -4,6 +4,7 @@ import { provideHttpClient, withInterceptorsFromDi } from '@angular/common/http'
 import { provideHttpClientTesting } from '@angular/common/http/testing'
 import { FormsModule, ReactiveFormsModule } from '@angular/forms'
 import { By } from '@angular/platform-browser'
+import { RouterTestingModule } from '@angular/router/testing'
 import {
   NgbModal,
   NgbModalModule,
@@ -61,6 +62,7 @@ describe('CustomFieldsComponent', () => {
         NgbModalModule,
         NgbPopoverModule,
         NgxBootstrapIconsModule.pick(allIcons),
+        RouterTestingModule,
         CustomFieldsComponent,
         IfPermissionsDirective,
         PageHeaderComponent,
@@ -108,7 +110,9 @@ describe('CustomFieldsComponent', () => {
     const toastInfoSpy = jest.spyOn(toastService, 'showInfo')
     const reloadSpy = jest.spyOn(component, 'reload')
 
-    const createButton = fixture.debugElement.queryAll(By.css('button'))[1]
+    const createButton = fixture.debugElement
+      .queryAll(By.css('button'))
+      .find((btn) => btn.nativeElement.textContent.trim().includes('Add Field'))
     createButton.triggerEventHandler('click')
 
     expect(modal).not.toBeUndefined()
@@ -133,7 +137,11 @@ describe('CustomFieldsComponent', () => {
     const toastInfoSpy = jest.spyOn(toastService, 'showInfo')
     const reloadSpy = jest.spyOn(component, 'reload')
 
-    const editButton = fixture.debugElement.queryAll(By.css('button'))[2]
+    const editButton = fixture.debugElement
+      .queryAll(By.css('button'))
+      .find((btn) =>
+        btn.nativeElement.textContent.trim().includes(fields[0].name)
+      )
     editButton.triggerEventHandler('click')
 
     expect(modal).not.toBeUndefined()
@@ -158,7 +166,9 @@ describe('CustomFieldsComponent', () => {
     const deleteSpy = jest.spyOn(customFieldsService, 'delete')
     const reloadSpy = jest.spyOn(component, 'reload')
 
-    const deleteButton = fixture.debugElement.queryAll(By.css('button'))[5]
+    const deleteButton = fixture.debugElement
+      .queryAll(By.css('button'))
+      .find((btn) => btn.nativeElement.textContent.trim().includes('Delete'))
     deleteButton.triggerEventHandler('click')
 
     expect(modal).not.toBeUndefined()
@@ -176,10 +186,10 @@ describe('CustomFieldsComponent', () => {
     expect(reloadSpy).toHaveBeenCalled()
   })
 
-  it('should support filter documents', () => {
-    const filterSpy = jest.spyOn(listViewService, 'quickFilter')
-    component.filterDocuments(fields[0])
-    expect(filterSpy).toHaveBeenCalledWith([
+  it('should provide document filter url', () => {
+    const urlSpy = jest.spyOn(listViewService, 'getQuickFilterUrl')
+    component.getDocumentFilterUrl(fields[0])
+    expect(urlSpy).toHaveBeenCalledWith([
       {
         rule_type: FILTER_CUSTOM_FIELDS_QUERY,
         value: JSON.stringify([

src-ui/src/app/components/manage/custom-fields/custom-fields.component.ts

@@ -1,4 +1,5 @@
 import { Component, OnInit, inject } from '@angular/core'
+import { RouterModule } from '@angular/router'
 import {
   NgbDropdownModule,
   NgbModal,
@@ -36,6 +37,7 @@ import { LoadingComponentWithPermissions } from '../../loading-component/loading
     NgbDropdownModule,
     NgbPaginationModule,
     NgxBootstrapIconsModule,
+    RouterModule,
   ],
 })
 export class CustomFieldsComponent
@@ -130,8 +132,8 @@ export class CustomFieldsComponent
     return DATA_TYPE_LABELS.find((l) => l.id === field.data_type).name
   }
 
-  filterDocuments(field: CustomField) {
-    this.documentListViewService.quickFilter([
+  getDocumentFilterUrl(field: CustomField) {
+    return this.documentListViewService.getQuickFilterUrl([
       {
         rule_type: FILTER_CUSTOM_FIELDS_QUERY,
         value: JSON.stringify([

src-ui/src/app/components/manage/document-type-list/document-type-list.component.ts

@@ -1,6 +1,7 @@
 import { NgClass, NgTemplateOutlet, TitleCasePipe } from '@angular/common'
 import { Component, inject } from '@angular/core'
 import { FormsModule, ReactiveFormsModule } from '@angular/forms'
+import { RouterModule } from '@angular/router'
 import {
   NgbDropdownModule,
   NgbPaginationModule,
@@ -27,6 +28,7 @@ import { ManagementListComponent } from '../management-list/management-list.comp
     IfPermissionsDirective,
     FormsModule,
     ReactiveFormsModule,
+    RouterModule,
     NgClass,
     NgTemplateOutlet,
     NgbDropdownModule,

src-ui/src/app/components/manage/management-list/management-list.component.html

@@ -120,7 +120,14 @@
               <button (click)="openEditDialog(object)" *pngxIfPermissions="{ action: PermissionAction.Change, type: permissionType }" ngbDropdownItem i18n>Edit</button>
               <button class="text-danger" (click)="openDeleteDialog(object)" *pngxIfPermissions="{ action: PermissionAction.Delete, type: permissionType }" ngbDropdownItem i18n>Delete</button>
               @if (getDocumentCount(object) > 0) {
-                <button (click)="filterDocuments(object)" *pngxIfPermissions="{ action: PermissionAction.View, type: PermissionType.Document }" ngbDropdownItem i18n>Filter Documents ({{ getDocumentCount(object) }})</button>
+                  <a
+                    *pngxIfPermissions="{ action: PermissionAction.View, type: PermissionType.Document }"
+                    ngbDropdownItem
+                    [routerLink]="getDocumentFilterUrl(object)"
+                    (click)="$event?.stopPropagation()"
+                    i18n
+                    >Filter Documents ({{ getDocumentCount(object) }})</a
+                  >
               }
             </div>
           </div>
@@ -135,9 +142,15 @@
         </div>
         @if (getDocumentCount(object) > 0) {
           <div class="btn-group d-none d-sm-inline-block">
-            <button class="btn btn-sm btn-outline-secondary" (click)="filterDocuments(object); $event.stopPropagation();" *pngxIfPermissions="{ action: PermissionAction.View, type: PermissionType.Document }">
-              <i-bs width="1em" height="1em" name="filter"></i-bs>&nbsp;<ng-container i18n>Documents</ng-container><span class="badge bg-light text-secondary ms-2">{{ getDocumentCount(object) }}</span>
-            </button>
+            <a
+              class="btn btn-sm btn-outline-secondary"
+              *pngxIfPermissions="{ action: PermissionAction.View, type: PermissionType.Document }"
+              [routerLink]="getDocumentFilterUrl(object)"
+              (click)="$event?.stopPropagation()"
+            >
+              <i-bs width="1em" height="1em" name="filter"></i-bs>&nbsp;<ng-container i18n>Documents</ng-container
+              ><span class="badge bg-light text-secondary ms-2">{{ getDocumentCount(object) }}</span>
+            </a>
           </div>
         }
       </div>

src-ui/src/app/components/manage/management-list/management-list.component.spec.ts

@@ -13,6 +13,7 @@ import {
 } from '@angular/core/testing'
 import { FormsModule, ReactiveFormsModule } from '@angular/forms'
 import { By } from '@angular/platform-browser'
+import { RouterLinkWithHref } from '@angular/router'
 import { RouterTestingModule } from '@angular/router/testing'
 import {
   NgbModal,
@@ -230,12 +231,15 @@ describe('ManagementListComponent', () => {
   })
 
   it('should support quick filter for objects', () => {
-    const qfSpy = jest.spyOn(documentListViewService, 'quickFilter')
-    const filterButton = fixture.debugElement.queryAll(By.css('button'))[9]
-    filterButton.triggerEventHandler('click')
-    expect(qfSpy).toHaveBeenCalledWith([
+    const expectedUrl = documentListViewService.getQuickFilterUrl([
       { rule_type: FILTER_HAS_TAGS_ALL, value: tags[0].id.toString() },
-    ]) // subclasses set the filter rule type
+    ])
+    const filterLink = fixture.debugElement.query(
+      By.css('a.btn-outline-secondary')
+    )
+    expect(filterLink).toBeTruthy()
+    const routerLink = filterLink.injector.get(RouterLinkWithHref)
+    expect(routerLink.urlTree).toEqual(expectedUrl)
   })
 
   it('should reload on sort', () => {

src-ui/src/app/components/manage/management-list/management-list.component.ts

@@ -230,8 +230,8 @@ export abstract class ManagementListComponent<T extends MatchingModel>
 
   abstract getDeleteMessage(object: T)
 
-  filterDocuments(object: MatchingModel) {
-    this.documentListViewService.quickFilter([
+  getDocumentFilterUrl(object: MatchingModel) {
+    return this.documentListViewService.getQuickFilterUrl([
       { rule_type: this.filterRuleType, value: object.id.toString() },
     ])
   }

src-ui/src/app/components/manage/storage-path-list/storage-path-list.component.ts

@@ -1,6 +1,7 @@
 import { NgClass, NgTemplateOutlet, TitleCasePipe } from '@angular/common'
 import { Component, inject } from '@angular/core'
 import { FormsModule, ReactiveFormsModule } from '@angular/forms'
+import { RouterModule } from '@angular/router'
 import {
   NgbDropdownModule,
   NgbPaginationModule,
@@ -27,6 +28,7 @@ import { ManagementListComponent } from '../management-list/management-list.comp
     IfPermissionsDirective,
     FormsModule,
     ReactiveFormsModule,
+    RouterModule,
     NgClass,
     NgTemplateOutlet,
     NgbDropdownModule,

src-ui/src/app/components/manage/tag-list/tag-list.component.ts

@@ -1,6 +1,7 @@
 import { NgClass, NgTemplateOutlet, TitleCasePipe } from '@angular/common'
 import { Component, inject } from '@angular/core'
 import { FormsModule, ReactiveFormsModule } from '@angular/forms'
+import { RouterModule } from '@angular/router'
 import {
   NgbDropdownModule,
   NgbPaginationModule,
@@ -27,6 +28,7 @@ import { ManagementListComponent } from '../management-list/management-list.comp
     IfPermissionsDirective,
     FormsModule,
     ReactiveFormsModule,
+    RouterModule,
     NgClass,
     NgTemplateOutlet,
     NgbDropdownModule,

src-ui/src/app/data/share-link-bundle.ts

@@ -1,46 +0,0 @@
-import { FileVersion } from './share-link'
-
-export enum ShareLinkBundleStatus {
-  Pending = 'pending',
-  Processing = 'processing',
-  Ready = 'ready',
-  Failed = 'failed',
-}
-
-export interface ShareLinkBundleSummary {
-  id: number
-  slug: string
-  created: string // Date
-  expiration?: string // Date
-  documents: number[]
-  document_count: number
-  file_version: FileVersion
-  status: ShareLinkBundleStatus
-  built_at?: string
-  size_bytes?: number
-  last_error?: string
-}
-
-export interface ShareLinkBundleCreatePayload {
-  document_ids: number[]
-  file_version: FileVersion
-  expiration_days: number | null
-}
-
-export const SHARE_LINK_BUNDLE_STATUS_LABELS: Record<
-  ShareLinkBundleStatus,
-  string
-> = {
-  [ShareLinkBundleStatus.Pending]: $localize`Pending`,
-  [ShareLinkBundleStatus.Processing]: $localize`Processing`,
-  [ShareLinkBundleStatus.Ready]: $localize`Ready`,
-  [ShareLinkBundleStatus.Failed]: $localize`Failed`,
-}
-
-export const SHARE_LINK_BUNDLE_FILE_VERSION_LABELS: Record<
-  FileVersion,
-  string
-> = {
-  [FileVersion.Archive]: $localize`Archive`,
-  [FileVersion.Original]: $localize`Original`,
-}

src-ui/src/app/data/share-link.ts

@@ -5,18 +5,6 @@ export enum FileVersion {
   Original = 'original',
 }
 
-export interface ShareLinkExpirationOption {
-  label: string
-  value: number | null
-}
-
-export const SHARE_LINK_EXPIRATION_OPTIONS: ShareLinkExpirationOption[] = [
-  { label: $localize`1 day`, value: 1 },
-  { label: $localize`7 days`, value: 7 },
-  { label: $localize`30 days`, value: 30 },
-  { label: $localize`Never`, value: null },
-]
-
 export interface ShareLink extends ObjectWithPermissions {
   created: string // Date
 

src-ui/src/app/services/document-list-view.service.spec.ts

@@ -651,4 +651,25 @@ describe('DocumentListViewService', () => {
     documentListViewService.displayFields = customFields as any
     expect(documentListViewService.displayFields).toEqual(['custom_field_1'])
   })
+
+  it('should generate quick filter URL with filter rules', () => {
+    const routerSpy = jest.spyOn(router, 'createUrlTree')
+    const urlTree = documentListViewService.getQuickFilterUrl(filterRules)
+    expect(routerSpy).toHaveBeenCalledWith(['/documents'], {
+      queryParams: expect.objectContaining({
+        tags__id__all: tags__id__all,
+      }),
+    })
+    expect(urlTree).toBeDefined()
+  })
+
+  it('should generate quick filter URL preserving default state', () => {
+    documentListViewService.reload()
+    httpTestingController.expectOne(
+      `${environment.apiBaseUrl}documents/?page=1&page_size=50&ordering=-created&truncate_content=true`
+    )
+    const urlTree = documentListViewService.getQuickFilterUrl(filterRules)
+    expect(urlTree).toBeDefined()
+    expect(router.createUrlTree).toBeDefined()
+  })
 })

src-ui/src/app/services/document-list-view.service.ts

@@ -1,5 +1,5 @@
 import { Injectable, inject } from '@angular/core'
-import { ParamMap, Router } from '@angular/router'
+import { ParamMap, Router, UrlTree } from '@angular/router'
 import { Observable, Subject, first, takeUntil } from 'rxjs'
 import {
   DEFAULT_DISPLAY_FIELDS,
@@ -483,6 +483,18 @@ export class DocumentListViewService {
     this.router.navigate(['documents'])
   }
 
+  getQuickFilterUrl(filterRules: FilterRule[]): UrlTree {
+    const defaultState = {
+      ...this.defaultListViewState(),
+      ...this.listViewStates.get(null),
+      filterRules,
+    }
+    const params = paramsFromViewState(defaultState)
+    return this.router.createUrlTree(['/documents'], {
+      queryParams: params,
+    })
+  }
+
   getLastPage(): number {
     return Math.ceil(this.collectionSize / this.pageSize)
   }

src-ui/src/app/services/rest/share-link-bundle.service.spec.ts

@@ -1,60 +0,0 @@
-import { HttpTestingController } from '@angular/common/http/testing'
-import { TestBed } from '@angular/core/testing'
-import { Subscription } from 'rxjs'
-import { environment } from 'src/environments/environment'
-import { commonAbstractPaperlessServiceTests } from './abstract-paperless-service.spec'
-import { ShareLinkBundleService } from './share-link-bundle.service'
-
-const endpoint = 'share_link_bundles'
-
-commonAbstractPaperlessServiceTests(endpoint, ShareLinkBundleService)
-
-describe('ShareLinkBundleService', () => {
-  let httpTestingController: HttpTestingController
-  let service: ShareLinkBundleService
-  let subscription: Subscription | undefined
-
-  beforeEach(() => {
-    httpTestingController = TestBed.inject(HttpTestingController)
-    service = TestBed.inject(ShareLinkBundleService)
-  })
-
-  afterEach(() => {
-    subscription?.unsubscribe()
-    httpTestingController.verify()
-  })
-
-  it('creates bundled share links', () => {
-    const payload = {
-      document_ids: [1, 2],
-      file_version: 'archive',
-      expiration_days: 7,
-    }
-    subscription = service.createBundle(payload as any).subscribe()
-    const req = httpTestingController.expectOne(
-      `${environment.apiBaseUrl}${endpoint}/`
-    )
-    expect(req.request.method).toBe('POST')
-    expect(req.request.body).toEqual(payload)
-    req.flush({})
-  })
-
-  it('rebuilds bundles', () => {
-    subscription = service.rebuildBundle(12).subscribe()
-    const req = httpTestingController.expectOne(
-      `${environment.apiBaseUrl}${endpoint}/12/rebuild/`
-    )
-    expect(req.request.method).toBe('POST')
-    expect(req.request.body).toEqual({})
-    req.flush({})
-  })
-
-  it('lists bundles with expected parameters', () => {
-    subscription = service.listAllBundles().subscribe()
-    const req = httpTestingController.expectOne(
-      `${environment.apiBaseUrl}${endpoint}/?page=1&page_size=1000&ordering=-created`
-    )
-    expect(req.request.method).toBe('GET')
-    req.flush({ results: [] })
-  })
-})

src-ui/src/app/services/rest/share-link-bundle.service.ts

@@ -1,41 +0,0 @@
-import { Injectable } from '@angular/core'
-import { Observable } from 'rxjs'
-import { map } from 'rxjs/operators'
-import {
-  ShareLinkBundleCreatePayload,
-  ShareLinkBundleSummary,
-} from 'src/app/data/share-link-bundle'
-import { AbstractNameFilterService } from './abstract-name-filter-service'
-
-@Injectable({
-  providedIn: 'root',
-})
-export class ShareLinkBundleService extends AbstractNameFilterService<ShareLinkBundleSummary> {
-  constructor() {
-    super()
-    this.resourceName = 'share_link_bundles'
-  }
-
-  createBundle(
-    payload: ShareLinkBundleCreatePayload
-  ): Observable<ShareLinkBundleSummary> {
-    this.clearCache()
-    return this.http.post<ShareLinkBundleSummary>(
-      this.getResourceUrl(),
-      payload
-    )
-  }
-  rebuildBundle(bundleId: number): Observable<ShareLinkBundleSummary> {
-    this.clearCache()
-    return this.http.post<ShareLinkBundleSummary>(
-      this.getResourceUrl(bundleId, 'rebuild'),
-      {}
-    )
-  }
-
-  listAllBundles(): Observable<ShareLinkBundleSummary[]> {
-    return this.list(1, 1000, 'created', true).pipe(
-      map((response) => response.results)
-    )
-  }
-}

src/documents/admin.py

@@ -13,7 +13,6 @@ from documents.models import PaperlessTask
 from documents.models import SavedView
 from documents.models import SavedViewFilterRule
 from documents.models import ShareLink
-from documents.models import ShareLinkBundle
 from documents.models import StoragePath
 from documents.models import Tag
 from documents.tasks import update_document_parent_tags
@@ -186,22 +185,6 @@ class ShareLinksAdmin(GuardedModelAdmin):
         return super().get_queryset(request).select_related("document__correspondent")
 
 
-class ShareLinkBundleAdmin(GuardedModelAdmin):
-    list_display = ("created", "status", "expiration", "owner", "slug")
-    list_filter = ("status", "created", "expiration", "owner")
-    search_fields = ("slug",)
-
-    def get_queryset(self, request):  # pragma: no cover
-        return (
-            super()
-            .get_queryset(request)
-            .select_related("owner")
-            .prefetch_related(
-                "documents",
-            )
-        )
-
-
 class CustomFieldsAdmin(GuardedModelAdmin):
     fields = ("name", "created", "data_type")
     readonly_fields = ("created", "data_type")
@@ -233,7 +216,6 @@ admin.site.register(StoragePath, StoragePathAdmin)
 admin.site.register(PaperlessTask, TaskAdmin)
 admin.site.register(Note, NotesAdmin)
 admin.site.register(ShareLink, ShareLinksAdmin)
-admin.site.register(ShareLinkBundle, ShareLinkBundleAdmin)
 admin.site.register(CustomField, CustomFieldsAdmin)
 admin.site.register(CustomFieldInstance, CustomFieldInstancesAdmin)
 

src/documents/filters.py

@@ -39,7 +39,6 @@ from documents.models import Document
 from documents.models import DocumentType
 from documents.models import PaperlessTask
 from documents.models import ShareLink
-from documents.models import ShareLinkBundle
 from documents.models import StoragePath
 from documents.models import Tag
 
@@ -797,29 +796,6 @@ class ShareLinkFilterSet(FilterSet):
         }
 
 
-class ShareLinkBundleFilterSet(FilterSet):
-    documents = Filter(method="filter_documents")
-
-    class Meta:
-        model = ShareLinkBundle
-        fields = {
-            "created": DATETIME_KWARGS,
-            "expiration": DATETIME_KWARGS,
-            "status": ["exact"],
-        }
-
-    def filter_documents(self, queryset, name, value):
-        if not value:
-            return queryset
-        try:
-            ids = [int(item) for item in value.split(",") if item]
-        except ValueError:
-            return queryset.none()
-        if not ids:
-            return queryset
-        return queryset.filter(documents__in=ids).distinct()
-
-
 class PaperlessTaskFilterSet(FilterSet):
     acknowledged = BooleanFilter(
         label="Acknowledged",

src/documents/index.py

@@ -10,6 +10,7 @@ from datetime import time
 from datetime import timedelta
 from datetime import timezone
 from shutil import rmtree
+from time import sleep
 from typing import TYPE_CHECKING
 from typing import Literal
 
@@ -32,6 +33,7 @@ from whoosh.highlight import HtmlFormatter
 from whoosh.idsets import BitSet
 from whoosh.idsets import DocIdSet
 from whoosh.index import FileIndex
+from whoosh.index import LockError
 from whoosh.index import create_in
 from whoosh.index import exists_in
 from whoosh.index import open_dir
@@ -97,11 +99,33 @@ def get_schema() -> Schema:
 
 
 def open_index(*, recreate=False) -> FileIndex:
-    try:
-        if exists_in(settings.INDEX_DIR) and not recreate:
-            return open_dir(settings.INDEX_DIR, schema=get_schema())
-    except Exception:
-        logger.exception("Error while opening the index, recreating.")
+    transient_exceptions = (FileNotFoundError, LockError)
+    max_retries = 3
+    retry_delay = 0.1
+
+    for attempt in range(max_retries + 1):
+        try:
+            if exists_in(settings.INDEX_DIR) and not recreate:
+                return open_dir(settings.INDEX_DIR, schema=get_schema())
+            break
+        except transient_exceptions as exc:
+            is_last_attempt = attempt == max_retries or recreate
+            if is_last_attempt:
+                logger.exception(
+                    "Error while opening the index after retries, recreating.",
+                )
+                break
+
+            logger.warning(
+                "Transient error while opening the index (attempt %s/%s): %s. Retrying.",
+                attempt + 1,
+                max_retries + 1,
+                exc,
+            )
+            sleep(retry_delay)
+        except Exception:
+            logger.exception("Error while opening the index, recreating.")
+            break
 
     # create_in doesn't handle corrupted indexes very well, remove the directory entirely first
     if settings.INDEX_DIR.is_dir():

src/documents/migrations/1075_sharelinkbundle.py

@@ -1,187 +0,0 @@
-# Generated by Django 5.2.7 on 2025-11-04 18:34
-
-import django.db.models.deletion
-import django.utils.timezone
-from django.conf import settings
-from django.contrib.auth.management import create_permissions
-from django.contrib.auth.models import Group
-from django.contrib.auth.models import Permission
-from django.contrib.auth.models import User
-from django.db import migrations
-from django.db import models
-
-
-def grant_share_link_bundle_permissions(apps, schema_editor):
-    # Ensure newly introduced permissions are created for all apps
-    for app_config in apps.get_app_configs():
-        app_config.models_module = True
-        create_permissions(app_config, apps=apps, verbosity=0)
-        app_config.models_module = None
-
-    add_document_perm = Permission.objects.filter(codename="add_document").first()
-    share_bundle_permissions = Permission.objects.filter(
-        codename__contains="sharelinkbundle",
-    )
-
-    users = User.objects.filter(user_permissions=add_document_perm).distinct()
-    for user in users:
-        user.user_permissions.add(*share_bundle_permissions)
-
-    groups = Group.objects.filter(permissions=add_document_perm).distinct()
-    for group in groups:
-        group.permissions.add(*share_bundle_permissions)
-
-
-def revoke_share_link_bundle_permissions(apps, schema_editor):
-    share_bundle_permissions = Permission.objects.filter(
-        codename__contains="sharelinkbundle",
-    )
-    for user in User.objects.all():
-        user.user_permissions.remove(*share_bundle_permissions)
-    for group in Group.objects.all():
-        group.permissions.remove(*share_bundle_permissions)
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ("documents", "1074_workflowrun_deleted_at_workflowrun_restored_at_and_more"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="ShareLinkBundle",
-            fields=[
-                (
-                    "id",
-                    models.AutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                (
-                    "created",
-                    models.DateTimeField(
-                        blank=True,
-                        db_index=True,
-                        default=django.utils.timezone.now,
-                        editable=False,
-                        verbose_name="created",
-                    ),
-                ),
-                (
-                    "expiration",
-                    models.DateTimeField(
-                        blank=True,
-                        db_index=True,
-                        null=True,
-                        verbose_name="expiration",
-                    ),
-                ),
-                (
-                    "slug",
-                    models.SlugField(
-                        blank=True,
-                        editable=False,
-                        unique=True,
-                        verbose_name="slug",
-                    ),
-                ),
-                (
-                    "file_version",
-                    models.CharField(
-                        choices=[("archive", "Archive"), ("original", "Original")],
-                        default="archive",
-                        max_length=50,
-                    ),
-                ),
-                (
-                    "status",
-                    models.CharField(
-                        choices=[
-                            ("pending", "Pending"),
-                            ("processing", "Processing"),
-                            ("ready", "Ready"),
-                            ("failed", "Failed"),
-                        ],
-                        default="pending",
-                        max_length=50,
-                    ),
-                ),
-                (
-                    "size_bytes",
-                    models.BigIntegerField(
-                        blank=True,
-                        null=True,
-                        verbose_name="size (bytes)",
-                    ),
-                ),
-                (
-                    "last_error",
-                    models.TextField(
-                        blank=True,
-                        verbose_name="last error",
-                    ),
-                ),
-                (
-                    "file_path",
-                    models.CharField(
-                        blank=True,
-                        max_length=512,
-                        verbose_name="file path",
-                    ),
-                ),
-                (
-                    "built_at",
-                    models.DateTimeField(
-                        blank=True,
-                        null=True,
-                        verbose_name="built at",
-                    ),
-                ),
-                (
-                    "owner",
-                    models.ForeignKey(
-                        blank=True,
-                        null=True,
-                        on_delete=django.db.models.deletion.SET_NULL,
-                        related_name="share_link_bundles",
-                        to=settings.AUTH_USER_MODEL,
-                        verbose_name="owner",
-                    ),
-                ),
-                (
-                    "deleted_at",
-                    models.DateTimeField(blank=True, null=True),
-                ),
-                (
-                    "restored_at",
-                    models.DateTimeField(blank=True, null=True),
-                ),
-                (
-                    "transaction_id",
-                    models.UUIDField(blank=True, null=True),
-                ),
-            ],
-            options={
-                "ordering": ("-created",),
-                "verbose_name": "share link bundle",
-                "verbose_name_plural": "share link bundles",
-            },
-        ),
-        migrations.AddField(
-            model_name="sharelinkbundle",
-            name="documents",
-            field=models.ManyToManyField(
-                related_name="share_link_bundles",
-                to="documents.document",
-                verbose_name="documents",
-            ),
-        ),
-        migrations.RunPython(
-            grant_share_link_bundle_permissions,
-            reverse_code=revoke_share_link_bundle_permissions,
-        ),
-    ]

src/documents/models.py

@@ -777,120 +777,6 @@ class ShareLink(SoftDeleteModel):
         return f"Share Link for {self.document.title}"
 
 
-class ShareLinkBundle(SoftDeleteModel):
-    class Status(models.TextChoices):
-        PENDING = ("pending", _("Pending"))
-        PROCESSING = ("processing", _("Processing"))
-        READY = ("ready", _("Ready"))
-        FAILED = ("failed", _("Failed"))
-
-    class Meta:
-        ordering = ("-created",)
-        verbose_name = _("share link bundle")
-        verbose_name_plural = _("share link bundles")
-
-    created = models.DateTimeField(
-        _("created"),
-        default=timezone.now,
-        db_index=True,
-        blank=True,
-        editable=False,
-    )
-
-    expiration = models.DateTimeField(
-        _("expiration"),
-        blank=True,
-        null=True,
-        db_index=True,
-    )
-
-    slug = models.SlugField(
-        _("slug"),
-        db_index=True,
-        unique=True,
-        blank=True,
-        editable=False,
-    )
-
-    owner = models.ForeignKey(
-        User,
-        blank=True,
-        null=True,
-        related_name="share_link_bundles",
-        on_delete=models.SET_NULL,
-        verbose_name=_("owner"),
-    )
-
-    file_version = models.CharField(
-        max_length=50,
-        choices=ShareLink.FileVersion.choices,
-        default=ShareLink.FileVersion.ARCHIVE,
-    )
-
-    status = models.CharField(
-        max_length=50,
-        choices=Status.choices,
-        default=Status.PENDING,
-    )
-
-    size_bytes = models.BigIntegerField(
-        _("size (bytes)"),
-        blank=True,
-        null=True,
-    )
-
-    last_error = models.TextField(
-        _("last error"),
-        blank=True,
-    )
-
-    file_path = models.CharField(
-        _("file path"),
-        max_length=512,
-        blank=True,
-    )
-
-    built_at = models.DateTimeField(
-        _("built at"),
-        null=True,
-        blank=True,
-    )
-
-    documents = models.ManyToManyField(
-        "documents.Document",
-        related_name="share_link_bundles",
-        verbose_name=_("documents"),
-    )
-
-    def __str__(self):
-        return _("Share link bundle %(slug)s") % {"slug": self.slug}
-
-    @property
-    def absolute_file_path(self) -> Path | None:
-        if not self.file_path:
-            return None
-        file_path = Path(self.file_path)
-        if not file_path.is_absolute():
-            file_path = (settings.MEDIA_ROOT / file_path).resolve()
-        return file_path
-
-    def remove_file(self):
-        path = self.absolute_file_path
-        if path and path.exists():
-            try:
-                path.unlink()
-            except OSError:
-                pass
-
-    def delete(self, using=None, *, keep_parents=False):
-        self.remove_file()
-        return super().delete(using=using, keep_parents=keep_parents)
-
-    def hard_delete(self, using=None, *, keep_parents=False):
-        self.remove_file()
-        return super().hard_delete(using=using, keep_parents=keep_parents)
-
-
 class CustomField(models.Model):
     """
     Defines the name and type of a custom field

src/documents/serialisers.py

@@ -4,7 +4,6 @@ import logging
 import math
 import re
 from datetime import datetime
-from datetime import timedelta
 from decimal import Decimal
 from typing import TYPE_CHECKING
 from typing import Literal
@@ -25,7 +24,6 @@ from django.core.validators import RegexValidator
 from django.core.validators import integer_validator
 from django.db.models import Count
 from django.db.models.functions import Lower
-from django.utils import timezone
 from django.utils.crypto import get_random_string
 from django.utils.dateparse import parse_datetime
 from django.utils.text import slugify
@@ -63,7 +61,6 @@ from documents.models import PaperlessTask
 from documents.models import SavedView
 from documents.models import SavedViewFilterRule
 from documents.models import ShareLink
-from documents.models import ShareLinkBundle
 from documents.models import StoragePath
 from documents.models import Tag
 from documents.models import UiSettings
@@ -2160,109 +2157,6 @@ class ShareLinkSerializer(OwnedObjectSerializer):
         return super().create(validated_data)
 
 
-class ShareLinkBundleSerializer(OwnedObjectSerializer):
-    document_ids = serializers.ListField(
-        child=serializers.IntegerField(min_value=1),
-        allow_empty=False,
-        write_only=True,
-    )
-    expiration_days = serializers.IntegerField(
-        required=False,
-        allow_null=True,
-        min_value=1,
-        write_only=True,
-    )
-    documents = serializers.PrimaryKeyRelatedField(
-        many=True,
-        read_only=True,
-    )
-    document_count = SerializerMethodField()
-
-    class Meta:
-        model = ShareLinkBundle
-        fields = (
-            "id",
-            "created",
-            "expiration",
-            "expiration_days",
-            "slug",
-            "file_version",
-            "status",
-            "size_bytes",
-            "last_error",
-            "built_at",
-            "documents",
-            "document_ids",
-            "document_count",
-        )
-        read_only_fields = (
-            "id",
-            "created",
-            "expiration",
-            "slug",
-            "status",
-            "size_bytes",
-            "last_error",
-            "built_at",
-            "documents",
-            "document_count",
-        )
-
-    def validate_document_ids(self, value):
-        unique_ids = set(value)
-        if len(unique_ids) != len(value):
-            raise serializers.ValidationError(
-                _("Duplicate document identifiers are not allowed."),
-            )
-        return value
-
-    def create(self, validated_data):
-        document_ids = validated_data.pop("document_ids")
-        expiration_days = validated_data.pop("expiration_days", None)
-        documents = validated_data.pop("documents", None)
-        validated_data["slug"] = get_random_string(50)
-        if expiration_days:
-            validated_data["expiration"] = timezone.now() + timedelta(
-                days=expiration_days,
-            )
-        else:
-            validated_data["expiration"] = None
-
-        share_link_bundle = super().create(validated_data)
-
-        if documents is None:
-            documents = list(
-                Document.objects.filter(pk__in=document_ids).only(
-                    "pk",
-                ),
-            )
-        else:
-            documents = list(documents)
-
-        documents_by_id = {doc.pk: doc for doc in documents}
-        missing = [
-            str(doc_id) for doc_id in document_ids if doc_id not in documents_by_id
-        ]
-        if missing:
-            raise serializers.ValidationError(
-                {
-                    "document_ids": _(
-                        "Documents not found: %(ids)s",
-                    )
-                    % {"ids": ", ".join(missing)},
-                },
-            )
-
-        ordered_documents = [documents_by_id[doc_id] for doc_id in document_ids]
-        share_link_bundle.documents.set(ordered_documents)
-        share_link_bundle.document_total = len(ordered_documents)
-
-        return share_link_bundle
-
-    def get_document_count(self, obj: ShareLinkBundle) -> int:
-        return getattr(obj, "document_total") or obj.documents.count()
-
-
 class BulkEditObjectsSerializer(SerializerWithPerms, SetPermissionsMixin):
     objects = serializers.ListField(
         required=True,

src/documents/tasks.py

@@ -3,9 +3,7 @@ import hashlib
 import logging
 import shutil
 import uuid
-import zipfile
 from pathlib import Path
-from tempfile import NamedTemporaryFile
 from tempfile import TemporaryDirectory
 
 import tqdm
@@ -24,8 +22,6 @@ from whoosh.writing import AsyncWriter
 from documents import index
 from documents import sanity_checker
 from documents.barcodes import BarcodePlugin
-from documents.bulk_download import ArchiveOnlyStrategy
-from documents.bulk_download import OriginalsOnlyStrategy
 from documents.caching import clear_document_caches
 from documents.classifier import DocumentClassifier
 from documents.classifier import load_classifier
@@ -43,8 +39,6 @@ from documents.models import CustomFieldInstance
 from documents.models import Document
 from documents.models import DocumentType
 from documents.models import PaperlessTask
-from documents.models import ShareLink
-from documents.models import ShareLinkBundle
 from documents.models import StoragePath
 from documents.models import Tag
 from documents.models import WorkflowRun
@@ -499,7 +493,7 @@ def check_scheduled_workflows():
                             trigger.schedule_is_recurring
                             and workflow_runs.exists()
                             and (
-                                workflow_runs.last().run_at
+                                workflow_runs.first().run_at
                                 > now
                                 - datetime.timedelta(
                                     days=trigger.schedule_recurring_interval_days,
@@ -564,121 +558,3 @@ def update_document_parent_tags(tag: Tag, new_parent: Tag) -> None:
 
     if affected:
         bulk_update_documents.delay(document_ids=list(affected))
-
-
-@shared_task
-def build_share_link_bundle(bundle_id: int):
-    try:
-        bundle = (
-            ShareLinkBundle.objects.filter(pk=bundle_id)
-            .prefetch_related("documents")
-            .get()
-        )
-    except ShareLinkBundle.DoesNotExist:
-        logger.warning("Share link bundle %s no longer exists.", bundle_id)
-        return
-
-    bundle.remove_file()
-    bundle.status = ShareLinkBundle.Status.PROCESSING
-    bundle.last_error = ""
-    bundle.size_bytes = None
-    bundle.built_at = None
-    bundle.file_path = ""
-    bundle.save(
-        update_fields=[
-            "status",
-            "last_error",
-            "size_bytes",
-            "built_at",
-            "file_path",
-        ],
-    )
-
-    documents = list(bundle.documents.all().order_by("pk"))
-
-    with NamedTemporaryFile(
-        dir=settings.SCRATCH_DIR,
-        suffix=".zip",
-        delete=False,
-    ) as temp_zip:
-        temp_zip_path = Path(temp_zip.name)
-
-    try:
-        strategy_class = (
-            ArchiveOnlyStrategy
-            if bundle.file_version == ShareLink.FileVersion.ARCHIVE
-            else OriginalsOnlyStrategy
-        )
-        with zipfile.ZipFile(temp_zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
-            strategy = strategy_class(zipf)
-            for document in documents:
-                strategy.add_document(document)
-
-        output_dir = settings.SHARE_LINK_BUNDLE_DIR
-        output_dir.mkdir(parents=True, exist_ok=True)
-        final_path = (output_dir / f"{bundle.slug}.zip").resolve()
-        if final_path.exists():
-            final_path.unlink()
-        shutil.move(str(temp_zip_path), final_path)
-
-        try:
-            bundle.file_path = str(final_path.relative_to(settings.MEDIA_ROOT))
-        except ValueError:
-            bundle.file_path = str(final_path)
-        bundle.size_bytes = final_path.stat().st_size
-        bundle.status = ShareLinkBundle.Status.READY
-        bundle.built_at = timezone.now()
-        bundle.last_error = ""
-        bundle.save(
-            update_fields=[
-                "file_path",
-                "size_bytes",
-                "status",
-                "built_at",
-                "last_error",
-            ],
-        )
-        logger.info("Built share link bundle %s", bundle.pk)
-    except Exception as exc:
-        logger.exception(
-            "Failed to build share link bundle %s: %s",
-            bundle_id,
-            exc,
-        )
-        bundle.status = ShareLinkBundle.Status.FAILED
-        bundle.last_error = str(exc)
-        bundle.save(update_fields=["status", "last_error"])
-        try:
-            temp_zip_path.unlink()
-        except OSError:
-            pass
-        raise
-    finally:
-        if temp_zip_path.exists():
-            try:
-                temp_zip_path.unlink()
-            except OSError:
-                pass
-
-
-@shared_task
-def cleanup_expired_share_link_bundles():
-    now = timezone.now()
-    expired_qs = ShareLinkBundle.objects.filter(
-        deleted_at__isnull=True,
-        expiration__isnull=False,
-        expiration__lt=now,
-    )
-    count = 0
-    for bundle in expired_qs.iterator():
-        count += 1
-        try:
-            bundle.hard_delete()
-        except Exception as exc:
-            logger.warning(
-                "Failed to delete expired share link bundle %s: %s",
-                bundle.pk,
-                exc,
-            )
-    if count:
-        logger.info("Deleted %s expired share link bundle(s)", count)

src/documents/tests/test_index.py

@@ -1,6 +1,7 @@
 from datetime import datetime
 from unittest import mock
 
+from django.conf import settings
 from django.contrib.auth.models import User
 from django.test import SimpleTestCase
 from django.test import TestCase
@@ -251,3 +252,120 @@ class TestRewriteNaturalDateKeywords(SimpleTestCase):
         result = self._rewrite_with_now("added:today", fixed_now)
         # Should convert to UTC properly
         self.assertIn("added:[20250719", result)
+
+
+class TestIndexResilience(DirectoriesMixin, SimpleTestCase):
+    def _assert_recreate_called(self, mock_create_in):
+        mock_create_in.assert_called_once()
+        path_arg, schema_arg = mock_create_in.call_args.args
+        self.assertEqual(path_arg, settings.INDEX_DIR)
+        self.assertEqual(schema_arg.__class__.__name__, "Schema")
+
+    def test_transient_missing_segment_does_not_force_recreate(self):
+        """
+        GIVEN:
+            - Index directory exists
+        WHEN:
+            - open_index is called
+            - Opening the index raises FileNotFoundError once due to a
+              transient missing segment
+        THEN:
+            - Index is opened successfully on retry
+            - Index is not recreated
+        """
+        file_marker = settings.INDEX_DIR / "file_marker.txt"
+        file_marker.write_text("keep")
+        expected_index = object()
+
+        with (
+            mock.patch("documents.index.exists_in", return_value=True),
+            mock.patch(
+                "documents.index.open_dir",
+                side_effect=[FileNotFoundError("missing"), expected_index],
+            ) as mock_open_dir,
+            mock.patch(
+                "documents.index.create_in",
+            ) as mock_create_in,
+            mock.patch(
+                "documents.index.rmtree",
+            ) as mock_rmtree,
+        ):
+            ix = index.open_index()
+
+        self.assertIs(ix, expected_index)
+        self.assertGreaterEqual(mock_open_dir.call_count, 2)
+        mock_rmtree.assert_not_called()
+        mock_create_in.assert_not_called()
+        self.assertEqual(file_marker.read_text(), "keep")
+
+    def test_transient_errors_exhaust_retries_and_recreate(self):
+        """
+        GIVEN:
+            - Index directory exists
+        WHEN:
+            - open_index is called
+            - Opening the index raises FileNotFoundError multiple times due to
+              transient missing segments
+        THEN:
+            - Index is recreated after retries are exhausted
+        """
+        recreated_index = object()
+
+        with (
+            self.assertLogs("paperless.index", level="ERROR") as cm,
+            mock.patch("documents.index.exists_in", return_value=True),
+            mock.patch(
+                "documents.index.open_dir",
+                side_effect=FileNotFoundError("missing"),
+            ) as mock_open_dir,
+            mock.patch("documents.index.rmtree") as mock_rmtree,
+            mock.patch(
+                "documents.index.create_in",
+                return_value=recreated_index,
+            ) as mock_create_in,
+        ):
+            ix = index.open_index()
+
+        self.assertIs(ix, recreated_index)
+        self.assertEqual(mock_open_dir.call_count, 4)
+        mock_rmtree.assert_called_once_with(settings.INDEX_DIR)
+        self._assert_recreate_called(mock_create_in)
+        self.assertIn(
+            "Error while opening the index after retries, recreating.",
+            cm.output[0],
+        )
+
+    def test_non_transient_error_recreates_index(self):
+        """
+        GIVEN:
+            - Index directory exists
+        WHEN:
+            - open_index is called
+            - Opening the index raises a "non-transient" error
+        THEN:
+            - Index is recreated
+        """
+        recreated_index = object()
+
+        with (
+            self.assertLogs("paperless.index", level="ERROR") as cm,
+            mock.patch("documents.index.exists_in", return_value=True),
+            mock.patch(
+                "documents.index.open_dir",
+                side_effect=RuntimeError("boom"),
+            ),
+            mock.patch("documents.index.rmtree") as mock_rmtree,
+            mock.patch(
+                "documents.index.create_in",
+                return_value=recreated_index,
+            ) as mock_create_in,
+        ):
+            ix = index.open_index()
+
+        self.assertIs(ix, recreated_index)
+        mock_rmtree.assert_called_once_with(settings.INDEX_DIR)
+        self._assert_recreate_called(mock_create_in)
+        self.assertIn(
+            "Error while opening the index, recreating.",
+            cm.output[0],
+        )

src/documents/tests/test_migration_share_link_bundle.py

@@ -1,51 +0,0 @@
-from documents.tests.utils import TestMigrations
-
-
-class TestMigrateShareLinkBundlePermissions(TestMigrations):
-    migrate_from = "1074_workflowrun_deleted_at_workflowrun_restored_at_and_more"
-    migrate_to = "1075_sharelinkbundle"
-
-    def setUpBeforeMigration(self, apps):
-        User = apps.get_model("auth", "User")
-        Group = apps.get_model("auth", "Group")
-        self.Permission = apps.get_model("auth", "Permission")
-        self.user = User.objects.create(username="user1")
-        self.group = Group.objects.create(name="group1")
-        add_document = self.Permission.objects.get(codename="add_document")
-        self.user.user_permissions.add(add_document.id)
-        self.group.permissions.add(add_document.id)
-
-    def test_share_link_permissions_granted_to_add_document_holders(self):
-        share_perms = self.Permission.objects.filter(
-            codename__contains="sharelinkbundle",
-        )
-        self.assertTrue(self.user.user_permissions.filter(pk__in=share_perms).exists())
-        self.assertTrue(self.group.permissions.filter(pk__in=share_perms).exists())
-
-
-class TestReverseMigrateShareLinkBundlePermissions(TestMigrations):
-    migrate_from = "1075_sharelinkbundle"
-    migrate_to = "1074_workflowrun_deleted_at_workflowrun_restored_at_and_more"
-
-    def setUpBeforeMigration(self, apps):
-        User = apps.get_model("auth", "User")
-        Group = apps.get_model("auth", "Group")
-        self.Permission = apps.get_model("auth", "Permission")
-        self.user = User.objects.create(username="user1")
-        self.group = Group.objects.create(name="group1")
-        add_document = self.Permission.objects.get(codename="add_document")
-        share_perms = self.Permission.objects.filter(
-            codename__contains="sharelinkbundle",
-        )
-        self.share_perm_ids = list(share_perms.values_list("id", flat=True))
-
-        self.user.user_permissions.add(add_document.id, *self.share_perm_ids)
-        self.group.permissions.add(add_document.id, *self.share_perm_ids)
-
-    def test_share_link_permissions_revoked_on_reverse(self):
-        self.assertFalse(
-            self.user.user_permissions.filter(pk__in=self.share_perm_ids).exists(),
-        )
-        self.assertFalse(
-            self.group.permissions.filter(pk__in=self.share_perm_ids).exists(),
-        )

src/documents/tests/test_share_link_bundles.py

@@ -1,619 +0,0 @@
-from __future__ import annotations
-
-import zipfile
-from datetime import timedelta
-from pathlib import Path
-from unittest import mock
-
-from django.conf import settings
-from django.contrib.auth.models import User
-from django.utils import timezone
-from rest_framework import serializers
-from rest_framework import status
-from rest_framework.test import APITestCase
-
-from documents.filters import ShareLinkBundleFilterSet
-from documents.models import ShareLink
-from documents.models import ShareLinkBundle
-from documents.serialisers import ShareLinkBundleSerializer
-from documents.tasks import build_share_link_bundle
-from documents.tasks import cleanup_expired_share_link_bundles
-from documents.tests.factories import DocumentFactory
-from documents.tests.utils import DirectoriesMixin
-
-
-class ShareLinkBundleAPITests(DirectoriesMixin, APITestCase):
-    ENDPOINT = "/api/share_link_bundles/"
-
-    def setUp(self):
-        super().setUp()
-        self.user = User.objects.create_superuser(username="bundle_admin")
-        self.client.force_authenticate(self.user)
-        self.document = DocumentFactory.create()
-
-    @mock.patch("documents.views.build_share_link_bundle.delay")
-    def test_create_bundle_triggers_build_job(self, delay_mock):
-        payload = {
-            "document_ids": [self.document.pk],
-            "file_version": ShareLink.FileVersion.ARCHIVE,
-            "expiration_days": 7,
-        }
-
-        response = self.client.post(self.ENDPOINT, payload, format="json")
-
-        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
-        bundle = ShareLinkBundle.objects.get(pk=response.data["id"])
-        self.assertEqual(bundle.documents.count(), 1)
-        self.assertEqual(bundle.status, ShareLinkBundle.Status.PENDING)
-        delay_mock.assert_called_once_with(bundle.pk)
-
-    def test_create_bundle_rejects_missing_documents(self):
-        payload = {
-            "document_ids": [9999],
-            "file_version": ShareLink.FileVersion.ARCHIVE,
-            "expiration_days": 7,
-        }
-
-        response = self.client.post(self.ENDPOINT, payload, format="json")
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("document_ids", response.data)
-
-    @mock.patch("documents.views.has_perms_owner_aware", return_value=False)
-    def test_create_bundle_rejects_insufficient_permissions(self, perms_mock):
-        payload = {
-            "document_ids": [self.document.pk],
-            "file_version": ShareLink.FileVersion.ARCHIVE,
-            "expiration_days": 7,
-        }
-
-        response = self.client.post(self.ENDPOINT, payload, format="json")
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("document_ids", response.data)
-        perms_mock.assert_called()
-
-    @mock.patch("documents.views.build_share_link_bundle.delay")
-    def test_rebuild_bundle_resets_state(self, delay_mock):
-        bundle = ShareLinkBundle.objects.create(
-            slug="rebuild-slug",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-            status=ShareLinkBundle.Status.FAILED,
-        )
-        bundle.documents.set([self.document])
-        bundle.last_error = "Something went wrong"
-        bundle.size_bytes = 100
-        bundle.file_path = "path/to/file.zip"
-        bundle.save()
-
-        response = self.client.post(f"{self.ENDPOINT}{bundle.pk}/rebuild/")
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        bundle.refresh_from_db()
-        self.assertEqual(bundle.status, ShareLinkBundle.Status.PENDING)
-        self.assertEqual(bundle.last_error, "")
-        self.assertIsNone(bundle.size_bytes)
-        self.assertEqual(bundle.file_path, "")
-        delay_mock.assert_called_once_with(bundle.pk)
-
-    def test_rebuild_bundle_rejects_processing_status(self):
-        bundle = ShareLinkBundle.objects.create(
-            slug="processing-slug",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-            status=ShareLinkBundle.Status.PROCESSING,
-        )
-        bundle.documents.set([self.document])
-
-        response = self.client.post(f"{self.ENDPOINT}{bundle.pk}/rebuild/")
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("detail", response.data)
-
-    def test_create_bundle_rejects_duplicate_documents(self):
-        payload = {
-            "document_ids": [self.document.pk, self.document.pk],
-            "file_version": ShareLink.FileVersion.ARCHIVE,
-            "expiration_days": 7,
-        }
-
-        response = self.client.post(self.ENDPOINT, payload, format="json")
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("document_ids", response.data)
-
-    def test_download_ready_bundle_streams_file(self):
-        bundle_file = Path(self.dirs.media_dir) / "bundles" / "ready.zip"
-        bundle_file.parent.mkdir(parents=True, exist_ok=True)
-        bundle_file.write_bytes(b"binary-zip-content")
-
-        bundle = ShareLinkBundle.objects.create(
-            slug="readyslug",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-            status=ShareLinkBundle.Status.READY,
-            file_path=str(bundle_file),
-        )
-        bundle.documents.set([self.document])
-
-        self.client.logout()
-        response = self.client.get(f"/share/{bundle.slug}/")
-        content = b"".join(response.streaming_content)
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response["Content-Type"], "application/zip")
-        self.assertEqual(content, b"binary-zip-content")
-        self.assertIn("attachment;", response["Content-Disposition"])
-
-    def test_download_pending_bundle_returns_202(self):
-        bundle = ShareLinkBundle.objects.create(
-            slug="pendingslug",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-            status=ShareLinkBundle.Status.PENDING,
-        )
-        bundle.documents.set([self.document])
-
-        self.client.logout()
-        response = self.client.get(f"/share/{bundle.slug}/")
-
-        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
-
-    @mock.patch("documents.views.build_share_link_bundle.delay")
-    def test_download_failed_bundle_triggers_rebuild(self, delay_mock):
-        bundle_path = (
-            Path(settings.MEDIA_ROOT)
-            / "documents"
-            / "share_link_bundles"
-            / "failed.zip"
-        )
-        bundle_path.parent.mkdir(parents=True, exist_ok=True)
-        bundle_path.write_bytes(b"old-content")
-
-        bundle = ShareLinkBundle.objects.create(
-            slug="failedslug",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-            status=ShareLinkBundle.Status.FAILED,
-            file_path=str(bundle_path.relative_to(settings.MEDIA_ROOT)),
-            last_error="Boom",
-            size_bytes=10,
-        )
-        bundle.documents.set([self.document])
-
-        self.client.logout()
-        response = self.client.get(f"/share/{bundle.slug}/")
-
-        self.assertEqual(response.status_code, status.HTTP_503_SERVICE_UNAVAILABLE)
-        bundle.refresh_from_db()
-        self.assertEqual(bundle.status, ShareLinkBundle.Status.PENDING)
-        self.assertEqual(bundle.last_error, "")
-        self.assertIsNone(bundle.size_bytes)
-        self.assertEqual(bundle.file_path, "")
-        delay_mock.assert_called_once_with(bundle.pk)
-        self.assertFalse(bundle_path.exists())
-
-    @mock.patch("documents.views.build_share_link_bundle.delay")
-    def test_download_missing_file_triggers_rebuild(self, delay_mock):
-        bundle = ShareLinkBundle.objects.create(
-            slug="missingfileslug",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-            status=ShareLinkBundle.Status.READY,
-            file_path=str(Path(self.dirs.media_dir) / "does-not-exist.zip"),
-        )
-        bundle.documents.set([self.document])
-
-        self.client.logout()
-        response = self.client.get(f"/share/{bundle.slug}/")
-
-        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
-        bundle.refresh_from_db()
-        self.assertEqual(bundle.status, ShareLinkBundle.Status.PENDING)
-        delay_mock.assert_called_once_with(bundle.pk)
-
-    def test_expired_share_link_redirects(self):
-        share_link = ShareLink.objects.create(
-            slug="expiredlink",
-            document=self.document,
-            file_version=ShareLink.FileVersion.ORIGINAL,
-            expiration=timezone.now() - timedelta(hours=1),
-        )
-
-        self.client.logout()
-        response = self.client.get(f"/share/{share_link.slug}/")
-
-        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
-        self.assertIn("sharelink_expired=1", response["Location"])
-
-    def test_unknown_share_link_redirects(self):
-        self.client.logout()
-        response = self.client.get("/share/unknownsharelink/")
-
-        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
-        self.assertIn("sharelink_notfound=1", response["Location"])
-
-
-class ShareLinkBundleTaskTests(DirectoriesMixin, APITestCase):
-    def setUp(self):
-        super().setUp()
-        self.document = DocumentFactory.create()
-
-    def test_cleanup_expired_share_link_bundles(self):
-        expired_path = Path(self.dirs.media_dir) / "expired.zip"
-        expired_path.parent.mkdir(parents=True, exist_ok=True)
-        expired_path.write_bytes(b"expired")
-
-        active_path = Path(self.dirs.media_dir) / "active.zip"
-        active_path.write_bytes(b"active")
-
-        expired_bundle = ShareLinkBundle.objects.create(
-            slug="expired-bundle",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-            status=ShareLinkBundle.Status.READY,
-            expiration=timezone.now() - timedelta(days=1),
-            file_path=str(expired_path),
-        )
-        expired_bundle.documents.set([self.document])
-
-        active_bundle = ShareLinkBundle.objects.create(
-            slug="active-bundle",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-            status=ShareLinkBundle.Status.READY,
-            expiration=timezone.now() + timedelta(days=1),
-            file_path=str(active_path),
-        )
-        active_bundle.documents.set([self.document])
-
-        cleanup_expired_share_link_bundles()
-
-        self.assertFalse(ShareLinkBundle.objects.filter(pk=expired_bundle.pk).exists())
-        self.assertTrue(ShareLinkBundle.objects.filter(pk=active_bundle.pk).exists())
-        self.assertFalse(expired_path.exists())
-        self.assertTrue(active_path.exists())
-
-    def test_cleanup_expired_share_link_bundles_logs_on_failure(self):
-        expired_bundle = ShareLinkBundle.objects.create(
-            slug="expired-bundle",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-            status=ShareLinkBundle.Status.READY,
-            expiration=timezone.now() - timedelta(days=1),
-        )
-        expired_bundle.documents.set([self.document])
-
-        with mock.patch.object(
-            ShareLinkBundle,
-            "hard_delete",
-            side_effect=RuntimeError("fail"),
-        ):
-            with self.assertLogs("paperless.tasks", level="WARNING") as logs:
-                cleanup_expired_share_link_bundles()
-
-        self.assertTrue(
-            any(
-                "Failed to delete expired share link bundle" in msg
-                for msg in logs.output
-            ),
-        )
-
-
-class ShareLinkBundleBuildTaskTests(DirectoriesMixin, APITestCase):
-    def setUp(self):
-        super().setUp()
-        self.document = DocumentFactory.create(
-            mime_type="application/pdf",
-            checksum="123",
-        )
-        self.document.archive_checksum = ""
-        self.document.save()
-        self.addCleanup(
-            setattr,
-            settings,
-            "SHARE_LINK_BUNDLE_DIR",
-            settings.SHARE_LINK_BUNDLE_DIR,
-        )
-        settings.SHARE_LINK_BUNDLE_DIR = (
-            Path(settings.MEDIA_ROOT) / "documents" / "share_link_bundles"
-        )
-
-    def _write_document_file(self, *, archive: bool, content: bytes) -> Path:
-        if archive:
-            self.document.archive_filename = f"{self.document.pk:07}.pdf"
-            self.document.save()
-            path = self.document.archive_path
-        else:
-            path = self.document.source_path
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_bytes(content)
-        return path
-
-    def test_build_share_link_bundle_creates_zip_and_sets_metadata(self):
-        self._write_document_file(archive=False, content=b"source")
-        archive_path = self._write_document_file(archive=True, content=b"archive")
-        bundle = ShareLinkBundle.objects.create(
-            slug="build-archive",
-            file_version=ShareLink.FileVersion.ARCHIVE,
-        )
-        bundle.documents.set([self.document])
-
-        build_share_link_bundle(bundle.pk)
-
-        bundle.refresh_from_db()
-        self.assertEqual(bundle.status, ShareLinkBundle.Status.READY)
-        self.assertEqual(bundle.last_error, "")
-        self.assertIsNotNone(bundle.built_at)
-        self.assertGreater(bundle.size_bytes or 0, 0)
-        final_path = bundle.absolute_file_path
-        self.assertIsNotNone(final_path)
-        self.assertTrue(final_path.exists())
-        with zipfile.ZipFile(final_path) as zipf:
-            names = zipf.namelist()
-            self.assertEqual(len(names), 1)
-            self.assertEqual(zipf.read(names[0]), archive_path.read_bytes())
-
-    def test_build_share_link_bundle_overwrites_existing_file(self):
-        self._write_document_file(archive=False, content=b"source")
-        bundle = ShareLinkBundle.objects.create(
-            slug="overwrite",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-        )
-        bundle.documents.set([self.document])
-
-        existing = settings.SHARE_LINK_BUNDLE_DIR / "overwrite.zip"
-        existing.parent.mkdir(parents=True, exist_ok=True)
-        existing.write_bytes(b"old")
-
-        build_share_link_bundle(bundle.pk)
-
-        bundle.refresh_from_db()
-        final_path = bundle.absolute_file_path
-        self.assertIsNotNone(final_path)
-        self.assertTrue(final_path.exists())
-        self.assertNotEqual(final_path.read_bytes(), b"old")
-
-    def test_build_share_link_bundle_stores_absolute_path_outside_media_root(self):
-        settings.SHARE_LINK_BUNDLE_DIR = Path(settings.DATA_DIR) / "share_link_bundles"
-        self._write_document_file(archive=False, content=b"source")
-        bundle = ShareLinkBundle.objects.create(
-            slug="outside-media",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-        )
-        bundle.documents.set([self.document])
-
-        build_share_link_bundle(bundle.pk)
-
-        bundle.refresh_from_db()
-        self.assertTrue(Path(bundle.file_path).is_absolute())
-        self.assertEqual(bundle.status, ShareLinkBundle.Status.READY)
-
-    def test_build_share_link_bundle_failure_marks_failed(self):
-        self._write_document_file(archive=False, content=b"source")
-        bundle = ShareLinkBundle.objects.create(
-            slug="fail-bundle",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-        )
-        bundle.documents.set([self.document])
-
-        with (
-            mock.patch(
-                "documents.tasks.OriginalsOnlyStrategy.add_document",
-                side_effect=RuntimeError("zip failure"),
-            ),
-            mock.patch("pathlib.Path.unlink") as unlink_mock,
-        ):
-            unlink_mock.side_effect = [OSError("unlink"), OSError("unlink-finally")] + [
-                None,
-            ] * 5
-            with self.assertRaises(RuntimeError):
-                build_share_link_bundle(bundle.pk)
-
-        bundle.refresh_from_db()
-        self.assertEqual(bundle.status, ShareLinkBundle.Status.FAILED)
-        self.assertEqual(bundle.last_error, "zip failure")
-        scratch_zips = list(Path(settings.SCRATCH_DIR).glob("*.zip"))
-        self.assertTrue(scratch_zips)
-        for path in scratch_zips:
-            path.unlink(missing_ok=True)
-
-    def test_build_share_link_bundle_missing_bundle_noop(self):
-        # Should not raise when bundle does not exist
-        build_share_link_bundle(99999)
-
-
-class ShareLinkBundleFilterSetTests(DirectoriesMixin, APITestCase):
-    def setUp(self):
-        super().setUp()
-        self.document = DocumentFactory.create()
-        self.document.checksum = "doc1checksum"
-        self.document.save()
-        self.other_document = DocumentFactory.create()
-        self.other_document.checksum = "doc2checksum"
-        self.other_document.save()
-        self.bundle_one = ShareLinkBundle.objects.create(
-            slug="bundle-one",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-        )
-        self.bundle_one.documents.set([self.document])
-        self.bundle_two = ShareLinkBundle.objects.create(
-            slug="bundle-two",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-        )
-        self.bundle_two.documents.set([self.other_document])
-
-    def test_filter_documents_returns_all_for_empty_value(self):
-        filterset = ShareLinkBundleFilterSet(
-            data={"documents": ""},
-            queryset=ShareLinkBundle.objects.all(),
-        )
-
-        self.assertCountEqual(filterset.qs, [self.bundle_one, self.bundle_two])
-
-    def test_filter_documents_handles_invalid_input(self):
-        filterset = ShareLinkBundleFilterSet(
-            data={"documents": "invalid"},
-            queryset=ShareLinkBundle.objects.all(),
-        )
-
-        self.assertFalse(filterset.qs.exists())
-
-    def test_filter_documents_filters_by_multiple_ids(self):
-        filterset = ShareLinkBundleFilterSet(
-            data={"documents": f"{self.document.pk},{self.other_document.pk}"},
-            queryset=ShareLinkBundle.objects.all(),
-        )
-
-        self.assertCountEqual(filterset.qs, [self.bundle_one, self.bundle_two])
-
-    def test_filter_documents_returns_queryset_for_empty_ids(self):
-        filterset = ShareLinkBundleFilterSet(
-            data={"documents": ","},
-            queryset=ShareLinkBundle.objects.all(),
-        )
-
-        self.assertCountEqual(filterset.qs, [self.bundle_one, self.bundle_two])
-
-
-class ShareLinkBundleModelTests(DirectoriesMixin, APITestCase):
-    def test_absolute_file_path_handles_relative_and_absolute(self):
-        relative_path = Path("documents/share_link_bundles/relative.zip")
-        bundle = ShareLinkBundle.objects.create(
-            slug="relative-bundle",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-            file_path=str(relative_path),
-        )
-
-        self.assertEqual(
-            bundle.absolute_file_path,
-            (Path(settings.MEDIA_ROOT) / relative_path).resolve(),
-        )
-
-        absolute_path = Path(self.dirs.media_dir) / "absolute.zip"
-        bundle.file_path = str(absolute_path)
-
-        self.assertEqual(bundle.absolute_file_path.resolve(), absolute_path.resolve())
-
-    def test_str_returns_translated_slug(self):
-        bundle = ShareLinkBundle.objects.create(
-            slug="string-slug",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-        )
-
-        self.assertIn("string-slug", str(bundle))
-
-    def test_remove_file_deletes_existing_file(self):
-        bundle_path = (
-            Path(settings.MEDIA_ROOT)
-            / "documents"
-            / "share_link_bundles"
-            / "remove.zip"
-        )
-        bundle_path.parent.mkdir(parents=True, exist_ok=True)
-        bundle_path.write_bytes(b"remove-me")
-        bundle = ShareLinkBundle.objects.create(
-            slug="remove-bundle",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-            file_path=str(bundle_path.relative_to(settings.MEDIA_ROOT)),
-        )
-
-        bundle.remove_file()
-
-        self.assertFalse(bundle_path.exists())
-
-    def test_remove_file_handles_oserror(self):
-        bundle_path = (
-            Path(settings.MEDIA_ROOT)
-            / "documents"
-            / "share_link_bundles"
-            / "remove-error.zip"
-        )
-        bundle_path.parent.mkdir(parents=True, exist_ok=True)
-        bundle_path.write_bytes(b"remove-me")
-        bundle = ShareLinkBundle.objects.create(
-            slug="remove-error",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-            file_path=str(bundle_path.relative_to(settings.MEDIA_ROOT)),
-        )
-
-        with mock.patch("pathlib.Path.unlink", side_effect=OSError("fail")):
-            bundle.remove_file()
-
-        self.assertTrue(bundle_path.exists())
-
-    def test_delete_and_hard_delete_call_remove_file(self):
-        bundle_path = (
-            Path(settings.MEDIA_ROOT)
-            / "documents"
-            / "share_link_bundles"
-            / "delete.zip"
-        )
-        bundle_path.parent.mkdir(parents=True, exist_ok=True)
-        bundle_path.write_bytes(b"remove-me")
-        bundle = ShareLinkBundle.objects.create(
-            slug="delete-bundle",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-            file_path=str(bundle_path.relative_to(settings.MEDIA_ROOT)),
-        )
-
-        bundle.delete()
-        self.assertFalse(bundle_path.exists())
-
-        bundle2_path = (
-            Path(settings.MEDIA_ROOT)
-            / "documents"
-            / "share_link_bundles"
-            / "harddelete.zip"
-        )
-        bundle2_path.parent.mkdir(parents=True, exist_ok=True)
-        bundle2_path.write_bytes(b"remove-me")
-        bundle2 = ShareLinkBundle.objects.create(
-            slug="harddelete-bundle",
-            file_version=ShareLink.FileVersion.ORIGINAL,
-            file_path=str(bundle2_path.relative_to(settings.MEDIA_ROOT)),
-        )
-
-        bundle2.hard_delete()
-        self.assertFalse(bundle2_path.exists())
-
-
-class ShareLinkBundleSerializerTests(DirectoriesMixin, APITestCase):
-    def setUp(self):
-        super().setUp()
-        self.document = DocumentFactory.create()
-
-    def test_validate_document_ids_rejects_duplicates(self):
-        serializer = ShareLinkBundleSerializer(
-            data={
-                "document_ids": [self.document.pk, self.document.pk],
-                "file_version": ShareLink.FileVersion.ORIGINAL,
-            },
-        )
-
-        self.assertFalse(serializer.is_valid())
-        self.assertIn("document_ids", serializer.errors)
-
-    def test_create_assigns_documents_and_expiration(self):
-        serializer = ShareLinkBundleSerializer(
-            data={
-                "document_ids": [self.document.pk],
-                "file_version": ShareLink.FileVersion.ORIGINAL,
-                "expiration_days": 3,
-            },
-        )
-
-        self.assertTrue(serializer.is_valid(), serializer.errors)
-        bundle = serializer.save()
-
-        self.assertEqual(list(bundle.documents.all()), [self.document])
-        expected_expiration = timezone.now() + timedelta(days=3)
-        self.assertAlmostEqual(
-            bundle.expiration,
-            expected_expiration,
-            delta=timedelta(seconds=10),
-        )
-
-    def test_create_raises_when_missing_documents(self):
-        serializer = ShareLinkBundleSerializer(
-            data={
-                "document_ids": [self.document.pk, 9999],
-                "file_version": ShareLink.FileVersion.ORIGINAL,
-            },
-        )
-
-        self.assertTrue(serializer.is_valid(), serializer.errors)
-        with self.assertRaises(serializers.ValidationError):
-            serializer.save(documents=[self.document])

src/documents/tests/test_workflows.py

@@ -2094,6 +2094,68 @@ class TestWorkflows(
             doc.refresh_from_db()
             self.assertIsNone(doc.owner)
 
+    def test_workflow_scheduled_recurring_respects_latest_run(self):
+        """
+        GIVEN:
+            - Scheduled workflow marked as recurring with a 1-day interval
+            - Document that matches the trigger
+            - Two prior runs exist: one 2 days ago and one 1 hour ago
+        WHEN:
+            - Scheduled workflows are checked again
+        THEN:
+            - Workflow does not run because the most recent run is inside the interval
+        """
+        trigger = WorkflowTrigger.objects.create(
+            type=WorkflowTrigger.WorkflowTriggerType.SCHEDULED,
+            schedule_date_field=WorkflowTrigger.ScheduleDateField.CREATED,
+            schedule_is_recurring=True,
+            schedule_recurring_interval_days=1,
+        )
+        action = WorkflowAction.objects.create(
+            assign_title="Doc assign owner",
+            assign_owner=self.user2,
+        )
+        w = Workflow.objects.create(
+            name="Workflow 1",
+            order=0,
+        )
+        w.triggers.add(trigger)
+        w.actions.add(action)
+        w.save()
+
+        doc = Document.objects.create(
+            title="sample test",
+            correspondent=self.c,
+            original_filename="sample.pdf",
+            created=timezone.now().date() - timedelta(days=3),
+        )
+
+        WorkflowRun.objects.create(
+            workflow=w,
+            document=doc,
+            type=WorkflowTrigger.WorkflowTriggerType.SCHEDULED,
+            run_at=timezone.now() - timedelta(days=2),
+        )
+        WorkflowRun.objects.create(
+            workflow=w,
+            document=doc,
+            type=WorkflowTrigger.WorkflowTriggerType.SCHEDULED,
+            run_at=timezone.now() - timedelta(hours=1),
+        )
+
+        tasks.check_scheduled_workflows()
+
+        doc.refresh_from_db()
+        self.assertIsNone(doc.owner)
+        self.assertEqual(
+            WorkflowRun.objects.filter(
+                workflow=w,
+                document=doc,
+                type=WorkflowTrigger.WorkflowTriggerType.SCHEDULED,
+            ).count(),
+            2,
+        )
+
     def test_workflow_scheduled_trigger_negative_offset_customfield(self):
         """
         GIVEN:

src/documents/views.py

@@ -50,7 +50,6 @@ from django.utils import timezone
 from django.utils.decorators import method_decorator
 from django.utils.timezone import make_aware
 from django.utils.translation import get_language
-from django.utils.translation import gettext_lazy as _
 from django.views import View
 from django.views.decorators.cache import cache_control
 from django.views.decorators.http import condition
@@ -70,7 +69,6 @@ from packaging import version as packaging_version
 from redis import Redis
 from rest_framework import parsers
 from rest_framework import serializers
-from rest_framework import status
 from rest_framework.decorators import action
 from rest_framework.exceptions import NotFound
 from rest_framework.exceptions import ValidationError
@@ -119,7 +117,6 @@ from documents.filters import DocumentTypeFilterSet
 from documents.filters import ObjectOwnedOrGrantedPermissionsFilter
 from documents.filters import ObjectOwnedPermissionsFilter
 from documents.filters import PaperlessTaskFilterSet
-from documents.filters import ShareLinkBundleFilterSet
 from documents.filters import ShareLinkFilterSet
 from documents.filters import StoragePathFilterSet
 from documents.filters import TagFilterSet
@@ -137,7 +134,6 @@ from documents.models import Note
 from documents.models import PaperlessTask
 from documents.models import SavedView
 from documents.models import ShareLink
-from documents.models import ShareLinkBundle
 from documents.models import StoragePath
 from documents.models import Tag
 from documents.models import UiSettings
@@ -171,7 +167,6 @@ from documents.serialisers import PostDocumentSerializer
 from documents.serialisers import RunTaskViewSerializer
 from documents.serialisers import SavedViewSerializer
 from documents.serialisers import SearchResultSerializer
-from documents.serialisers import ShareLinkBundleSerializer
 from documents.serialisers import ShareLinkSerializer
 from documents.serialisers import StoragePathSerializer
 from documents.serialisers import StoragePathTestSerializer
@@ -184,7 +179,6 @@ from documents.serialisers import WorkflowActionSerializer
 from documents.serialisers import WorkflowSerializer
 from documents.serialisers import WorkflowTriggerSerializer
 from documents.signals import document_updated
-from documents.tasks import build_share_link_bundle
 from documents.tasks import consume_file
 from documents.tasks import empty_trash
 from documents.tasks import index_optimize
@@ -2275,7 +2269,7 @@ class BulkDownloadView(GenericAPIView):
         follow_filename_format = serializer.validated_data.get("follow_formatting")
 
         for document in documents:
-            if not has_perms_owner_aware(request.user, "change_document", document):
+            if not has_perms_owner_aware(request.user, "view_document", document):
                 return HttpResponseForbidden("Insufficient permissions")
 
         settings.SCRATCH_DIR.mkdir(parents=True, exist_ok=True)
@@ -2622,225 +2616,21 @@ class ShareLinkViewSet(ModelViewSet, PassUserMixin):
     ordering_fields = ("created", "expiration", "document")
 
 
-class ShareLinkBundleViewSet(ModelViewSet, PassUserMixin):
-    model = ShareLinkBundle
-
-    queryset = ShareLinkBundle.objects.all()
-
-    serializer_class = ShareLinkBundleSerializer
-    pagination_class = StandardPagination
-    permission_classes = (IsAuthenticated, PaperlessObjectPermissions)
-    filter_backends = (
-        DjangoFilterBackend,
-        OrderingFilter,
-        ObjectOwnedOrGrantedPermissionsFilter,
-    )
-    filterset_class = ShareLinkBundleFilterSet
-    ordering_fields = ("created", "expiration", "status")
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .prefetch_related("documents")
-            .annotate(document_total=Count("documents", distinct=True))
-        )
-
-    def create(self, request, *args, **kwargs):
-        serializer = self.get_serializer(data=request.data)
-        serializer.is_valid(raise_exception=True)
-        document_ids = serializer.validated_data["document_ids"]
-        documents_qs = Document.objects.filter(pk__in=document_ids).select_related(
-            "owner",
-        )
-        found_ids = set(documents_qs.values_list("pk", flat=True))
-        missing = sorted(set(document_ids) - found_ids)
-        if missing:
-            raise ValidationError(
-                {
-                    "document_ids": _(
-                        "Documents not found: %(ids)s",
-                    )
-                    % {"ids": ", ".join(str(item) for item in missing)},
-                },
-            )
-
-        documents = list(documents_qs)
-        for document in documents:
-            if not has_perms_owner_aware(request.user, "view_document", document):
-                raise ValidationError(
-                    {
-                        "document_ids": _(
-                            "Insufficient permissions to share document %(id)s.",
-                        )
-                        % {"id": document.pk},
-                    },
-                )
-
-        document_map = {document.pk: document for document in documents}
-        ordered_documents = [document_map[doc_id] for doc_id in document_ids]
-
-        bundle = serializer.save(
-            owner=request.user,
-            documents=ordered_documents,
-        )
-        bundle.remove_file()
-        bundle.status = ShareLinkBundle.Status.PENDING
-        bundle.last_error = ""
-        bundle.size_bytes = None
-        bundle.built_at = None
-        bundle.file_path = ""
-        bundle.save(
-            update_fields=[
-                "status",
-                "last_error",
-                "size_bytes",
-                "built_at",
-                "file_path",
-            ],
-        )
-        build_share_link_bundle.delay(bundle.pk)
-        bundle.document_total = len(ordered_documents)
-        response_serializer = self.get_serializer(bundle)
-        headers = self.get_success_headers(response_serializer.data)
-        return Response(
-            response_serializer.data,
-            status=status.HTTP_201_CREATED,
-            headers=headers,
-        )
-
-    @action(detail=True, methods=["post"])
-    def rebuild(self, request, pk=None):
-        bundle = self.get_object()
-        if bundle.status == ShareLinkBundle.Status.PROCESSING:
-            return Response(
-                {"detail": _("Bundle is already being processed.")},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        bundle.remove_file()
-        bundle.status = ShareLinkBundle.Status.PENDING
-        bundle.last_error = ""
-        bundle.size_bytes = None
-        bundle.built_at = None
-        bundle.file_path = ""
-        bundle.save(
-            update_fields=[
-                "status",
-                "last_error",
-                "size_bytes",
-                "built_at",
-                "file_path",
-            ],
-        )
-        build_share_link_bundle.delay(bundle.pk)
-        bundle.document_total = (
-            getattr(bundle, "document_total", None) or bundle.documents.count()
-        )
-        serializer = self.get_serializer(bundle)
-        return Response(serializer.data)
-
-
 class SharedLinkView(View):
     authentication_classes = []
     permission_classes = []
 
     def get(self, request, slug):
         share_link = ShareLink.objects.filter(slug=slug).first()
-        if share_link is not None:
-            if (
-                share_link.expiration is not None
-                and share_link.expiration < timezone.now()
-            ):
-                return HttpResponseRedirect("/accounts/login/?sharelink_expired=1")
-            return serve_file(
-                doc=share_link.document,
-                use_archive=share_link.file_version == "archive",
-                disposition="inline",
-            )
-
-        bundle = ShareLinkBundle.objects.filter(slug=slug).first()
-        if bundle is None:
+        if share_link is None:
             return HttpResponseRedirect("/accounts/login/?sharelink_notfound=1")
-
-        if bundle.expiration is not None and bundle.expiration < timezone.now():
+        if share_link.expiration is not None and share_link.expiration < timezone.now():
             return HttpResponseRedirect("/accounts/login/?sharelink_expired=1")
-
-        if bundle.status in {
-            ShareLinkBundle.Status.PENDING,
-            ShareLinkBundle.Status.PROCESSING,
-        }:
-            return HttpResponse(
-                _(
-                    "The share link bundle is still being prepared. Please try again later.",
-                ),
-                status=status.HTTP_202_ACCEPTED,
-            )
-
-        if bundle.status == ShareLinkBundle.Status.FAILED:
-            bundle.remove_file()
-            bundle.status = ShareLinkBundle.Status.PENDING
-            bundle.last_error = ""
-            bundle.size_bytes = None
-            bundle.built_at = None
-            bundle.file_path = ""
-            bundle.save(
-                update_fields=[
-                    "status",
-                    "last_error",
-                    "size_bytes",
-                    "built_at",
-                    "file_path",
-                ],
-            )
-            build_share_link_bundle.delay(bundle.pk)
-            return HttpResponse(
-                _(
-                    "The share link bundle is temporarily unavailable. A rebuild has been scheduled. Please try again later.",
-                ),
-                status=status.HTTP_503_SERVICE_UNAVAILABLE,
-            )
-
-        file_path = bundle.absolute_file_path
-        if file_path is None or not file_path.exists():
-            bundle.status = ShareLinkBundle.Status.PENDING
-            bundle.last_error = ""
-            bundle.size_bytes = None
-            bundle.built_at = None
-            bundle.file_path = ""
-            bundle.save(
-                update_fields=[
-                    "status",
-                    "last_error",
-                    "size_bytes",
-                    "built_at",
-                    "file_path",
-                ],
-            )
-            build_share_link_bundle.delay(bundle.pk)
-            return HttpResponse(
-                _(
-                    "The share link bundle is being prepared. Please try again later.",
-                ),
-                status=status.HTTP_202_ACCEPTED,
-            )
-
-        response = FileResponse(file_path.open("rb"), content_type="application/zip")
-        short_slug = bundle.slug[:12]
-        download_name = f"paperless-share-{short_slug}.zip"
-        filename_normalized = (
-            normalize("NFKD", download_name)
-            .encode(
-                "ascii",
-                "ignore",
-            )
-            .decode("ascii")
+        return serve_file(
+            doc=share_link.document,
+            use_archive=share_link.file_version == "archive",
+            disposition="inline",
         )
-        filename_encoded = quote(download_name)
-        response["Content-Disposition"] = (
-            f"attachment; filename='{filename_normalized}'; "
-            f"filename*=utf-8''{filename_encoded}"
-        )
-        return response
 
 
 def serve_file(*, doc: Document, use_archive: bool, disposition: str):

src/locale/en_US/LC_MESSAGES/django.po

@@ -2,7 +2,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: paperless-ngx\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-12-29 14:49+0000\n"
+"POT-Creation-Date: 2026-01-06 17:11+0000\n"
 "PO-Revision-Date: 2022-02-17 04:17\n"
 "Last-Translator: \n"
 "Language-Team: English\n"
@@ -1702,151 +1702,151 @@ msgstr ""
 msgid "paperless application settings"
 msgstr ""
 
-#: paperless/settings.py:773
+#: paperless/settings.py:767
 msgid "English (US)"
 msgstr ""
 
-#: paperless/settings.py:774
+#: paperless/settings.py:768
 msgid "Arabic"
 msgstr ""
 
-#: paperless/settings.py:775
+#: paperless/settings.py:769
 msgid "Afrikaans"
 msgstr ""
 
-#: paperless/settings.py:776
+#: paperless/settings.py:770
 msgid "Belarusian"
 msgstr ""
 
-#: paperless/settings.py:777
+#: paperless/settings.py:771
 msgid "Bulgarian"
 msgstr ""
 
-#: paperless/settings.py:778
+#: paperless/settings.py:772
 msgid "Catalan"
 msgstr ""
 
-#: paperless/settings.py:779
+#: paperless/settings.py:773
 msgid "Czech"
 msgstr ""
 
-#: paperless/settings.py:780
+#: paperless/settings.py:774
 msgid "Danish"
 msgstr ""
 
-#: paperless/settings.py:781
+#: paperless/settings.py:775
 msgid "German"
 msgstr ""
 
-#: paperless/settings.py:782
+#: paperless/settings.py:776
 msgid "Greek"
 msgstr ""
 
-#: paperless/settings.py:783
+#: paperless/settings.py:777
 msgid "English (GB)"
 msgstr ""
 
-#: paperless/settings.py:784
+#: paperless/settings.py:778
 msgid "Spanish"
 msgstr ""
 
-#: paperless/settings.py:785
+#: paperless/settings.py:779
 msgid "Persian"
 msgstr ""
 
-#: paperless/settings.py:786
+#: paperless/settings.py:780
 msgid "Finnish"
 msgstr ""
 
-#: paperless/settings.py:787
+#: paperless/settings.py:781
 msgid "French"
 msgstr ""
 
-#: paperless/settings.py:788
+#: paperless/settings.py:782
 msgid "Hungarian"
 msgstr ""
 
-#: paperless/settings.py:789
+#: paperless/settings.py:783
 msgid "Indonesian"
 msgstr ""
 
-#: paperless/settings.py:790
+#: paperless/settings.py:784
 msgid "Italian"
 msgstr ""
 
-#: paperless/settings.py:791
+#: paperless/settings.py:785
 msgid "Japanese"
 msgstr ""
 
-#: paperless/settings.py:792
+#: paperless/settings.py:786
 msgid "Korean"
 msgstr ""
 
-#: paperless/settings.py:793
+#: paperless/settings.py:787
 msgid "Luxembourgish"
 msgstr ""
 
-#: paperless/settings.py:794
+#: paperless/settings.py:788
 msgid "Norwegian"
 msgstr ""
 
-#: paperless/settings.py:795
+#: paperless/settings.py:789
 msgid "Dutch"
 msgstr ""
 
-#: paperless/settings.py:796
+#: paperless/settings.py:790
 msgid "Polish"
 msgstr ""
 
-#: paperless/settings.py:797
+#: paperless/settings.py:791
 msgid "Portuguese (Brazil)"
 msgstr ""
 
-#: paperless/settings.py:798
+#: paperless/settings.py:792
 msgid "Portuguese"
 msgstr ""
 
-#: paperless/settings.py:799
+#: paperless/settings.py:793
 msgid "Romanian"
 msgstr ""
 
-#: paperless/settings.py:800
+#: paperless/settings.py:794
 msgid "Russian"
 msgstr ""
 
-#: paperless/settings.py:801
+#: paperless/settings.py:795
 msgid "Slovak"
 msgstr ""
 
-#: paperless/settings.py:802
+#: paperless/settings.py:796
 msgid "Slovenian"
 msgstr ""
 
-#: paperless/settings.py:803
+#: paperless/settings.py:797
 msgid "Serbian"
 msgstr ""
 
-#: paperless/settings.py:804
+#: paperless/settings.py:798
 msgid "Swedish"
 msgstr ""
 
-#: paperless/settings.py:805
+#: paperless/settings.py:799
 msgid "Turkish"
 msgstr ""
 
-#: paperless/settings.py:806
+#: paperless/settings.py:800
 msgid "Ukrainian"
 msgstr ""
 
-#: paperless/settings.py:807
+#: paperless/settings.py:801
 msgid "Vietnamese"
 msgstr ""
 
-#: paperless/settings.py:808
+#: paperless/settings.py:802
 msgid "Chinese Simplified"
 msgstr ""
 
-#: paperless/settings.py:809
+#: paperless/settings.py:803
 msgid "Chinese Traditional"
 msgstr ""
 

src/paperless/settings.py

@@ -8,7 +8,6 @@ import os
 import tempfile
 from os import PathLike
 from pathlib import Path
-from platform import machine
 from typing import Final
 from urllib.parse import urlparse
 
@@ -230,17 +229,6 @@ def _parse_beat_schedule() -> dict:
                 "expires": 59.0 * 60.0,
             },
         },
-        {
-            "name": "Cleanup expired share link bundles",
-            "env_key": "PAPERLESS_SHARE_LINK_BUNDLE_CLEANUP_CRON",
-            # Default daily at 02:00
-            "env_default": "0 2 * * *",
-            "task": "documents.tasks.cleanup_expired_share_link_bundles",
-            "options": {
-                # 1 hour before default schedule sends again
-                "expires": 23.0 * 60.0 * 60.0,
-            },
-        },
     ]
     for task in tasks:
         # Either get the environment setting or use the default
@@ -279,7 +267,6 @@ MEDIA_ROOT = __get_path("PAPERLESS_MEDIA_ROOT", BASE_DIR.parent / "media")
 ORIGINALS_DIR = MEDIA_ROOT / "documents" / "originals"
 ARCHIVE_DIR = MEDIA_ROOT / "documents" / "archive"
 THUMBNAIL_DIR = MEDIA_ROOT / "documents" / "thumbnails"
-SHARE_LINK_BUNDLE_DIR = MEDIA_ROOT / "documents" / "share_link_bundles"
 
 DATA_DIR = __get_path("PAPERLESS_DATA_DIR", BASE_DIR.parent / "data")
 
@@ -435,14 +422,9 @@ ASGI_APPLICATION = "paperless.asgi.application"
 STATIC_URL = os.getenv("PAPERLESS_STATIC_URL", BASE_URL + "static/")
 WHITENOISE_STATIC_PREFIX = "/static/"
 
-if machine().lower() == "aarch64":  # pragma: no cover
-    _static_backend = "django.contrib.staticfiles.storage.StaticFilesStorage"
-else:
-    _static_backend = "whitenoise.storage.CompressedStaticFilesStorage"
-
 STORAGES = {
     "staticfiles": {
-        "BACKEND": _static_backend,
+        "BACKEND": "whitenoise.storage.CompressedStaticFilesStorage",
     },
     "default": {"BACKEND": "django.core.files.storage.FileSystemStorage"},
 }

src/paperless/tests/test_settings.py

@@ -160,7 +160,6 @@ class TestCeleryScheduleParsing(TestCase):
     SANITY_EXPIRE_TIME = ((7.0 * 24.0) - 1.0) * 60.0 * 60.0
     EMPTY_TRASH_EXPIRE_TIME = 23.0 * 60.0 * 60.0
     RUN_SCHEDULED_WORKFLOWS_EXPIRE_TIME = 59.0 * 60.0
-    CLEANUP_EXPIRED_SHARE_BUNDLES_EXPIRE_TIME = 23.0 * 60.0 * 60.0
 
     def test_schedule_configuration_default(self):
         """
@@ -205,13 +204,6 @@ class TestCeleryScheduleParsing(TestCase):
                     "schedule": crontab(minute="5", hour="*/1"),
                     "options": {"expires": self.RUN_SCHEDULED_WORKFLOWS_EXPIRE_TIME},
                 },
-                "Cleanup expired share link bundles": {
-                    "task": "documents.tasks.cleanup_expired_share_link_bundles",
-                    "schedule": crontab(minute=0, hour=2),
-                    "options": {
-                        "expires": self.CLEANUP_EXPIRED_SHARE_BUNDLES_EXPIRE_TIME,
-                    },
-                },
             },
             schedule,
         )
@@ -264,13 +256,6 @@ class TestCeleryScheduleParsing(TestCase):
                     "schedule": crontab(minute="5", hour="*/1"),
                     "options": {"expires": self.RUN_SCHEDULED_WORKFLOWS_EXPIRE_TIME},
                 },
-                "Cleanup expired share link bundles": {
-                    "task": "documents.tasks.cleanup_expired_share_link_bundles",
-                    "schedule": crontab(minute=0, hour=2),
-                    "options": {
-                        "expires": self.CLEANUP_EXPIRED_SHARE_BUNDLES_EXPIRE_TIME,
-                    },
-                },
             },
             schedule,
         )
@@ -315,13 +300,6 @@ class TestCeleryScheduleParsing(TestCase):
                     "schedule": crontab(minute="5", hour="*/1"),
                     "options": {"expires": self.RUN_SCHEDULED_WORKFLOWS_EXPIRE_TIME},
                 },
-                "Cleanup expired share link bundles": {
-                    "task": "documents.tasks.cleanup_expired_share_link_bundles",
-                    "schedule": crontab(minute=0, hour=2),
-                    "options": {
-                        "expires": self.CLEANUP_EXPIRED_SHARE_BUNDLES_EXPIRE_TIME,
-                    },
-                },
             },
             schedule,
         )
@@ -344,7 +322,6 @@ class TestCeleryScheduleParsing(TestCase):
                 "PAPERLESS_INDEX_TASK_CRON": "disable",
                 "PAPERLESS_EMPTY_TRASH_TASK_CRON": "disable",
                 "PAPERLESS_WORKFLOW_SCHEDULED_TASK_CRON": "disable",
-                "PAPERLESS_SHARE_LINK_BUNDLE_CLEANUP_CRON": "disable",
             },
         ):
             schedule = _parse_beat_schedule()

src/paperless/urls.py

@@ -30,7 +30,6 @@ from documents.views import SavedViewViewSet
 from documents.views import SearchAutoCompleteView
 from documents.views import SelectionDataView
 from documents.views import SharedLinkView
-from documents.views import ShareLinkBundleViewSet
 from documents.views import ShareLinkViewSet
 from documents.views import StatisticsView
 from documents.views import StoragePathViewSet
@@ -73,7 +72,6 @@ api_router.register(r"users", UserViewSet, basename="users")
 api_router.register(r"groups", GroupViewSet, basename="groups")
 api_router.register(r"mail_accounts", MailAccountViewSet)
 api_router.register(r"mail_rules", MailRuleViewSet)
-api_router.register(r"share_link_bundles", ShareLinkBundleViewSet)
 api_router.register(r"share_links", ShareLinkViewSet)
 api_router.register(r"workflow_triggers", WorkflowTriggerViewSet)
 api_router.register(r"workflow_actions", WorkflowActionViewSet)