chages

Resolved conflicts by:
- Kept invite link feature (inviteLinkExpiryHours in ApplicationProperties)
- Kept enhanced email invite validation (both SMTP and invites enabled check)
- Adopted V2's Posthog/Scarf tracking additions
- Adopted V2's password length validation (min 6 chars) on both backend and frontend
- Converted email templates to Java text blocks
- Kept success message functionality in Login flow
- Used @app path aliases consistently across frontend files
- Fixed remaining relative imports in Workbench, RestartConfirmationModal, useRestartServer, and InviteAccept
- Accepted deletion of refactored files (App.tsx, Landing.tsx, etc.)
- Kept InviteAccept.tsx for invite link feature

.dockerignore

@@ -1,74 +0,0 @@
-# Node modules and build artifacts
-node_modules
-frontend/node_modules
-frontend/dist
-frontend/build
-frontend/.vite
-frontend/.tauri
-
-# Gradle build artifacts
-.gradle
-build
-bin
-target
-out
-
-# Git
-.git
-.gitignore
-
-# IDE
-.vscode
-.idea
-*.iml
-*.iws
-*.ipr
-
-# Logs
-*.log
-logs
-
-# Environment files
-.env
-.env.*
-!.env.example
-
-# OS files
-.DS_Store
-Thumbs.db
-
-# Java compiled files
-*.class
-*.jar
-*.war
-*.ear
-
-# Test reports
-test-results
-coverage
-
-# Docker
-docker-compose.override.yml
-.dockerignore
-
-# Temporary files
-tmp
-temp
-*.tmp
-*.swp
-*~
-
-# Runtime database and config files (locked by running app)
-app/core/configs/**
-stirling/**
-stirling-pdf-DB*.mv.db
-stirling-pdf-DB*.trace.db
-
-# Documentation
-*.md
-!README.md
-docs
-
-# CI/CD
-.github
-.gitlab-ci.yml

.github/config/dependency-review-config.yml

@@ -1 +0,0 @@
-allow-ghsas: GHSA-wrw7-89jp-8q8g

.github/workflows/PR-Auto-Deploy-V2.yml

@@ -87,7 +87,7 @@ jobs:
               fi
             fi
           else
-            auth_users=("Frooodle" "sf298" "Ludy87" "LaserKaspar" "sbplat" "reecebrowne" "DarioGii" "ConnorYoh" "EthanHealy01" "jbrunton96" "balazs-szucs")
+            auth_users=("Frooodle" "sf298" "Ludy87" "LaserKaspar" "sbplat" "reecebrowne" "DarioGii" "ConnorYoh" "EthanHealy01" "jbrunton96")
             is_auth=false; for u in "${auth_users[@]}"; do [ "$u" = "$PR_AUTHOR" ] && is_auth=true && break; done
             if [ "$PR_BASE" = "V2" ] && [ "$is_auth" = true ]; then
               should=true
@@ -306,10 +306,8 @@ jobs:
                 - /stirling/V2-PR-${{ needs.check-pr.outputs.pr_number }}/config:/configs:rw
                 - /stirling/V2-PR-${{ needs.check-pr.outputs.pr_number }}/logs:/logs:rw
               environment:
-                DISABLE_ADDITIONAL_FEATURES: "false"
-                SECURITY_ENABLELOGIN: "true"
-                SECURITY_INITIALLOGIN_USERNAME: "${{ secrets.TEST_LOGIN_USERNAME }}"
-                SECURITY_INITIALLOGIN_PASSWORD: "${{ secrets.TEST_LOGIN_PASSWORD }}"
+                DISABLE_ADDITIONAL_FEATURES: "true"
+                SECURITY_ENABLELOGIN: "false"
                 SYSTEM_DEFAULTLOCALE: en-GB
                 UI_APPNAME: "Stirling-PDF V2 PR#${{ needs.check-pr.outputs.pr_number }}"
                 UI_HOMEDESCRIPTION: "V2 PR#${{ needs.check-pr.outputs.pr_number }} - Frontend/Backend Split Architecture"
@@ -500,4 +498,4 @@ jobs:
         if: always()
         run: |
           rm -f ../private.key
-        continue-on-error: true
+        continue-on-error: true

.github/workflows/dependency-review.yml

@@ -25,5 +25,3 @@ jobs:
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: "Dependency Review"
         uses: actions/dependency-review-action@56339e523c0409420f6c2c9a2f4292bbb3c07dd3 # v4.8.0
-        with:
-          config-file: './.github/config/dependency-review-config.yml'

.github/workflows/tauri-build.yml

@@ -1,643 +0,0 @@
-name: Build Tauri Applications
-
-on:
-  workflow_dispatch:
-    inputs:
-      platform:
-        description: "Platform to build (windows, macos, linux, or all)"
-        required: true
-        default: "all"
-        type: choice
-        options:
-          - all
-          - windows
-          - macos
-          - linux
-  pull_request:
-    branches: [main, V2, V2-tauri-windows]
-    paths:
-      - 'frontend/src-tauri/**'
-      - 'frontend/src/desktop/**'
-      - 'frontend/tsconfig.desktop.json'
-      - '.github/workflows/tauri-build.yml'
-  push:
-    branches: [main, V2]
-
-permissions:
-  contents: read
-
-jobs:
-  determine-matrix:
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      - name: Determine build matrix
-        id: set-matrix
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            case "${{ github.event.inputs.platform }}" in
-              "windows")
-                echo 'matrix={"include":[{"platform":"windows-latest","args":"--target x86_64-pc-windows-msvc","name":"windows-x86_64"}]}' >> $GITHUB_OUTPUT
-                ;;
-              "macos")
-                echo 'matrix={"include":[{"platform":"macos-15","args":"--target aarch64-apple-darwin","name":"macos-aarch64"},{"platform":"macos-15-intel","args":"--target x86_64-apple-darwin","name":"macos-x86_64"}]}' >> $GITHUB_OUTPUT
-                ;;
-              "linux")
-                echo 'matrix={"include":[{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64"}]}' >> $GITHUB_OUTPUT
-                ;;
-              *)
-                echo 'matrix={"include":[{"platform":"windows-latest","args":"--target x86_64-pc-windows-msvc","name":"windows-x86_64"},{"platform":"macos-15","args":"--target aarch64-apple-darwin","name":"macos-aarch64"},{"platform":"macos-15-intel","args":"--target x86_64-apple-darwin","name":"macos-x86_64"},{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64"}]}' >> $GITHUB_OUTPUT
-                ;;
-            esac
-          else
-            # For PR/push events, build all platforms
-            echo 'matrix={"include":[{"platform":"windows-latest","args":"--target x86_64-pc-windows-msvc","name":"windows-x86_64"},{"platform":"macos-15","args":"--target aarch64-apple-darwin","name":"macos-aarch64"},{"platform":"macos-15-intel","args":"--target x86_64-apple-darwin","name":"macos-x86_64"},{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64"}]}' >> $GITHUB_OUTPUT
-          fi
-
-  build:
-    needs: determine-matrix
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.determine-matrix.outputs.matrix) }}
-    runs-on: ${{ matrix.platform }}
-    env:
-      SM_API_KEY: ${{ secrets.SM_API_KEY }}
-      WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@002fdce3c6a235733a90a27c80493a3241e56863 # v2.12.1
-        with:
-          egress-policy: audit
-
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-
-      - name: Install dependencies (ubuntu only)
-        if: matrix.platform == 'ubuntu-22.04'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libjavascriptcoregtk-4.0-dev libsoup2.4-dev libjavascriptcoregtk-4.1-dev libsoup-3.0-dev
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: 'npm'
-          cache-dependency-path: frontend/package-lock.json
-
-      - name: Setup Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: stable
-          targets: ${{ (matrix.platform == 'macos-15' || matrix.platform == 'macos-15-intel') && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}
-
-      - name: Set up JDK 21
-        uses: actions/setup-java@c5195efecf7bdfc987ee8bae7a71cb8b11521c00 # v4.7.1
-        with:
-          java-version: "21"
-          distribution: "temurin"
-
-      - name: Build Java backend with JLink
-        working-directory: ./
-        shell: bash
-        run: |
-          chmod +x ./gradlew
-          echo "🔧 Building Stirling-PDF JAR..."
-          # STIRLING_PDF_DESKTOP_UI=false ./gradlew clean bootJar --no-daemon
-          ./gradlew clean build -x spotlessApply -x spotlessCheck -x test -x sonarqube
-
-          # Find the built JAR
-          STIRLING_JAR=$(ls app/core/build/libs/stirling-pdf-*.jar | head -n 1)
-          echo "✅ Built JAR: $STIRLING_JAR"
-          
-          # Create Tauri directories
-          mkdir -p ./frontend/src-tauri/libs
-          mkdir -p ./frontend/src-tauri/runtime
-          
-          # Copy JAR to Tauri libs
-          cp "$STIRLING_JAR" ./frontend/src-tauri/libs/
-          echo "✅ JAR copied to Tauri libs"
-          
-          # Analyze JAR dependencies for jlink modules
-          echo "🔍 Analyzing JAR dependencies..."
-          if command -v jdeps &> /dev/null; then
-            DETECTED_MODULES=$(jdeps --print-module-deps --ignore-missing-deps "$STIRLING_JAR" 2>/dev/null || echo "")
-            if [ -n "$DETECTED_MODULES" ]; then
-              echo "📋 jdeps detected modules: $DETECTED_MODULES"
-              MODULES="$DETECTED_MODULES,java.compiler,java.instrument,java.management,java.naming,java.net.http,java.prefs,java.rmi,java.scripting,java.security.jgss,java.security.sasl,java.sql,java.transaction.xa,java.xml.crypto,jdk.crypto.ec,jdk.crypto.cryptoki,jdk.unsupported"
-            else
-              echo "⚠️ jdeps analysis failed, using predefined modules"
-              MODULES="java.base,java.compiler,java.desktop,java.instrument,java.logging,java.management,java.naming,java.net.http,java.prefs,java.rmi,java.scripting,java.security.jgss,java.security.sasl,java.sql,java.transaction.xa,java.xml,java.xml.crypto,jdk.crypto.ec,jdk.crypto.cryptoki,jdk.unsupported"
-            fi
-          else
-            echo "⚠️ jdeps not available, using predefined modules"
-            MODULES="java.base,java.compiler,java.desktop,java.instrument,java.logging,java.management,java.naming,java.net.http,java.prefs,java.rmi,java.scripting,java.security.jgss,java.security.sasl,java.sql,java.transaction.xa,java.xml,java.xml.crypto,jdk.crypto.ec,jdk.crypto.cryptoki,jdk.unsupported"
-          fi
-          
-          # Create custom JRE with jlink (always rebuild)
-          echo "🔧 Creating custom JRE with jlink..."
-          echo "📋 Using modules: $MODULES"
-          
-          # Remove any existing JRE
-          rm -rf ./frontend/src-tauri/runtime/jre
-          
-          # Create the custom JRE
-          jlink \
-            --add-modules "$MODULES" \
-            --strip-debug \
-            --compress=2 \
-            --no-header-files \
-            --no-man-pages \
-            --output ./frontend/src-tauri/runtime/jre
-          
-          if [ ! -d "./frontend/src-tauri/runtime/jre" ]; then
-            echo "❌ Failed to create JLink runtime"
-            exit 1
-          fi
-          
-          # Test the bundled runtime
-          if [ -f "./frontend/src-tauri/runtime/jre/bin/java" ]; then
-            RUNTIME_VERSION=$(./frontend/src-tauri/runtime/jre/bin/java --version 2>&1 | head -n 1)
-            echo "✅ Custom JRE created successfully: $RUNTIME_VERSION"
-          else
-            echo "❌ Custom JRE executable not found"
-            exit 1
-          fi
-          
-          # Calculate runtime size
-          RUNTIME_SIZE=$(du -sh ./frontend/src-tauri/runtime/jre | cut -f1)
-          echo "📊 Custom JRE size: $RUNTIME_SIZE"
-        env:
-          DISABLE_ADDITIONAL_FEATURES: true
-
-      - name: Install frontend dependencies
-        working-directory: ./frontend
-        run: npm install
-
-      # DigiCert KeyLocker Setup (Cloud HSM)
-      - name: Setup DigiCert KeyLocker
-        id: digicert-setup
-        if: ${{ matrix.platform == 'windows-latest' && env.SM_API_KEY != '' && github.ref == 'refs/heads/main' }}
-        uses: digicert/ssm-code-signing@v1.1.0
-        env:
-          SM_API_KEY: ${{ secrets.SM_API_KEY }}
-          SM_CLIENT_CERT_FILE_B64: ${{ secrets.SM_CLIENT_CERT_FILE_B64 }}
-          SM_CLIENT_CERT_PASSWORD: ${{ secrets.SM_CLIENT_CERT_PASSWORD }}
-          SM_KEYPAIR_ALIAS: ${{ secrets.SM_KEYPAIR_ALIAS }}
-          SM_HOST: ${{ secrets.SM_HOST }}
-
-      - name: Setup DigiCert KeyLocker Certificate
-        if: ${{ matrix.platform == 'windows-latest' && env.SM_API_KEY != '' && github.ref == 'refs/heads/main' }}
-        shell: pwsh
-        run: |
-          Write-Host "Setting up DigiCert KeyLocker environment..."
-
-          # Decode client certificate
-          $certBytes = [Convert]::FromBase64String("${{ secrets.SM_CLIENT_CERT_FILE_B64 }}")
-          $certPath = "D:\Certificate_pkcs12.p12"
-          [IO.File]::WriteAllBytes($certPath, $certBytes)
-
-          # Set environment variables
-          echo "SM_CLIENT_CERT_FILE=D:\Certificate_pkcs12.p12" >> $env:GITHUB_ENV
-          echo "SM_HOST=${{ secrets.SM_HOST }}" >> $env:GITHUB_ENV
-          echo "SM_API_KEY=${{ secrets.SM_API_KEY }}" >> $env:GITHUB_ENV
-          echo "SM_CLIENT_CERT_PASSWORD=${{ secrets.SM_CLIENT_CERT_PASSWORD }}" >> $env:GITHUB_ENV
-          echo "SM_KEYPAIR_ALIAS=${{ secrets.SM_KEYPAIR_ALIAS }}" >> $env:GITHUB_ENV
-
-          # Get PKCS11 config path from DigiCert action
-          $pkcs11Config = $env:PKCS11_CONFIG
-          if ($pkcs11Config) {
-            Write-Host "Found PKCS11_CONFIG: $pkcs11Config"
-            echo "PKCS11_CONFIG=$pkcs11Config" >> $env:GITHUB_ENV
-          } else {
-            Write-Host "PKCS11_CONFIG not set by DigiCert action, using default path"
-            $defaultPath = "C:\Users\RUNNER~1\AppData\Local\Temp\smtools-windows-x64\pkcs11properties.cfg"
-            if (Test-Path $defaultPath) {
-              Write-Host "Found config at default path: $defaultPath"
-              echo "PKCS11_CONFIG=$defaultPath" >> $env:GITHUB_ENV
-            } else {
-              Write-Host "Warning: Could not find PKCS11 config file"
-            }
-          }
-
-      # Traditional PFX Certificate Import (fallback if KeyLocker not configured)
-      - name: Import Windows Code Signing Certificate
-        if: ${{ matrix.platform == 'windows-latest' && env.SM_API_KEY == '' && github.ref == 'refs/heads/main' }}
-        env:
-          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
-          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
-        shell: powershell
-        run: |
-          if ($env:WINDOWS_CERTIFICATE) {
-            Write-Host "Importing Windows Code Signing Certificate..."
-
-            # Decode base64 certificate and save to file
-            $certBytes = [Convert]::FromBase64String($env:WINDOWS_CERTIFICATE)
-            $certPath = Join-Path $env:RUNNER_TEMP "certificate.pfx"
-            [IO.File]::WriteAllBytes($certPath, $certBytes)
-
-            # Import certificate to CurrentUser\My store
-            $cert = Import-PfxCertificate -FilePath $certPath -CertStoreLocation Cert:\CurrentUser\My -Password (ConvertTo-SecureString -String $env:WINDOWS_CERTIFICATE_PASSWORD -AsPlainText -Force)
-
-            # Extract and set thumbprint as environment variable
-            $thumbprint = $cert.Thumbprint
-            Write-Host "Certificate imported with thumbprint: $thumbprint"
-            echo "WINDOWS_CERTIFICATE_THUMBPRINT=$thumbprint" >> $env:GITHUB_ENV
-
-            # Clean up certificate file
-            Remove-Item $certPath
-
-            Write-Host "Windows certificate import completed."
-          } else {
-            Write-Host "⚠️ WINDOWS_CERTIFICATE secret not set - building unsigned binary"
-          }
-
-      - name: Import Apple Developer Certificate
-        if: matrix.platform == 'macos-15' || matrix.platform == 'macos-15-intel'
-        env:
-          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-        run: |
-          echo "Importing Apple Developer Certificate..."
-          echo $APPLE_CERTIFICATE | base64 --decode > certificate.p12
-          # Create temporary keychain
-          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
-          KEYCHAIN_PASSWORD=$(openssl rand -base64 32)
-          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
-          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
-          security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
-          # Import certificate
-          security import certificate.p12 -P "$APPLE_CERTIFICATE_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
-          security list-keychain -d user -s $KEYCHAIN_PATH
-          security set-key-partition-list -S apple-tool:,apple: -k "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
-          # Clean up
-          rm certificate.p12
-
-      - name: Verify Certificate
-        if: matrix.platform == 'macos-15' || matrix.platform == 'macos-15-intel'
-        run: |
-          echo "Verifying Apple Developer Certificate..."
-          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
-          CERT_INFO=$(security find-identity -v -p codesigning $KEYCHAIN_PATH | grep "Developer ID Application")
-          echo "Certificate Info: $CERT_INFO"
-          CERT_ID=$(echo "$CERT_INFO" | awk -F'"' '{print $2}')
-          echo "Certificate ID: $CERT_ID"
-          echo "APPLE_SIGNING_IDENTITY=$CERT_ID" >> $GITHUB_ENV
-          echo "Certificate imported successfully."
-
-      - name: Check DMG creation dependencies (macOS only)
-        if: matrix.platform == 'macos-15' || matrix.platform == 'macos-15-intel'
-        run: |
-          echo "🔍 Checking DMG creation dependencies on ${{ matrix.platform }}..."
-          echo "hdiutil version: $(hdiutil --version || echo 'NOT FOUND')"
-          echo "create-dmg availability: $(which create-dmg || echo 'NOT FOUND')"
-          echo "Available disk space: $(df -h /tmp | tail -1)"
-          echo "macOS version: $(sw_vers -productVersion)"
-          echo "Available tools:"
-          ls -la /usr/bin/hd* || echo "No hd* tools found"
-
-      - name: Build Tauri app
-        uses: tauri-apps/tauri-action@v0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          APPLE_SIGNING_IDENTITY: ${{ env.APPLE_SIGNING_IDENTITY }}
-          APPLE_ID: ${{ secrets.APPLE_ID }}
-          APPLE_PASSWORD: ${{ secrets.APPLE_ID_PASSWORD }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-          APPIMAGETOOL_SIGN_PASSPHRASE: ${{ secrets.APPIMAGETOOL_SIGN_PASSPHRASE }}
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-          VITE_SUPABASE_PUBLISHABLE_DEFAULT_KEY: ${{ secrets.VITE_SUPABASE_PUBLISHABLE_DEFAULT_KEY }}
-          VITE_SAAS_SERVER_URL: ${{ secrets.VITE_SAAS_SERVER_URL }}
-          # Only enable Windows signing in Tauri when on main
-          SIGN: ${{ github.ref == 'refs/heads/main' && (env.SM_API_KEY == '' && env.WINDOWS_CERTIFICATE != '') && '1' || '0' }}
-          CI: true
-        with:
-          projectPath: ./frontend
-          tauriScript: npx tauri
-          args: ${{ matrix.args }}
-
-      # Sign with DigiCert KeyLocker (post-build)
-      - name: Sign Windows binaries with DigiCert KeyLocker
-        if: ${{ matrix.platform == 'windows-latest' && env.SM_API_KEY != '' && github.ref == 'refs/heads/main' }}
-        shell: pwsh
-        run: |
-          Write-Host "=== DigiCert KeyLocker Signing ==="
-
-          # Test smctl connectivity first
-          Write-Host "Testing smctl connection..."
-          $healthCheck = & smctl healthcheck 2>&1
-          if ($LASTEXITCODE -eq 0) {
-            Write-Host "[SUCCESS] Connected to DigiCert KeyLocker"
-          } else {
-            Write-Host "[ERROR] Failed to connect to DigiCert KeyLocker"
-            Write-Host $healthCheck
-            exit 1
-          }
-          Write-Host ""
-
-          # Sync certificates to Windows certificate store
-          Write-Host "Syncing certificates to Windows certificate store..."
-          $syncOutput = & smctl windows certsync 2>&1
-          Write-Host "Cert sync result: $syncOutput"
-          Write-Host ""
-
-          # List available certificates and check if they have certificates attached
-          Write-Host "Checking for available certificates..."
-          $certList = & smctl keypair ls 2>&1
-          Write-Host "Keypair list output:"
-          Write-Host $certList
-          Write-Host ""
-
-          # Parse the output to check certificate status
-          $lines = $certList -split "`n"
-          $foundKeypair = $false
-          $hasCertificate = $false
-
-          foreach ($line in $lines) {
-            if ($line -match "${{ secrets.SM_KEYPAIR_ALIAS }}") {
-              $foundKeypair = $true
-              Write-Host "[SUCCESS] Found keypair in list"
-
-              # Check if this line has certificate info (not just empty spaces after alias)
-              $parts = $line -split "\s+"
-              if ($parts.Count -gt 2 -and $parts[1] -ne "" -and $parts[1] -ne "CERTIFICATE") {
-                $hasCertificate = $true
-                Write-Host "[SUCCESS] Certificate is associated with keypair"
-              }
-            }
-          }
-
-          if (-not $foundKeypair) {
-            Write-Host "[ERROR] Keypair not found: ${{ secrets.SM_KEYPAIR_ALIAS }}"
-            Write-Host "Available keypairs are listed above"
-            Write-Host ""
-            Write-Host "Please verify:"
-            Write-Host "  1. Keypair alias is correct in GitHub secret"
-            Write-Host "  2. API key has access to this keypair"
-            exit 1
-          }
-
-          if (-not $hasCertificate) {
-            Write-Host "[ERROR] No certificate associated with keypair"
-            Write-Host "This usually means:"
-            Write-Host "  1. Certificate not yet synced to KeyLocker (run sync manually)"
-            Write-Host "  2. Certificate is pending approval"
-            Write-Host "  3. Certificate needs to be attached to the keypair"
-            Write-Host ""
-            Write-Host "Try running in DigiCert ONE portal:"
-            Write-Host "  smctl keypair sync"
-            exit 1
-          }
-
-          Write-Host "[SUCCESS] Certificate check passed"
-          Write-Host ""
-
-          # Find only the files we need to sign (not build scripts)
-          $filesToSign = @()
-
-          # Main application executable
-          $mainExe = Get-ChildItem -Path "./frontend/src-tauri/target/x86_64-pc-windows-msvc/release" -Filter "stirling-pdf.exe" -File -ErrorAction SilentlyContinue
-          if ($mainExe) { $filesToSign += $mainExe }
-
-          # MSI installer
-          $msiFiles = Get-ChildItem -Path "./frontend/src-tauri/target" -Filter "*.msi" -Recurse -File
-          $filesToSign += $msiFiles
-
-          if ($filesToSign.Count -eq 0) {
-            Write-Host "[ERROR] No files found to sign"
-            exit 1
-          }
-
-          Write-Host "Found $($filesToSign.Count) files to sign:"
-          foreach ($f in $filesToSign) { Write-Host "  - $($f.Name)" }
-          Write-Host ""
-
-          $signedCount = 0
-          foreach ($file in $filesToSign) {
-            Write-Host "Signing: $($file.Name)"
-
-            # Get PKCS11 config file path (set by DigiCert action)
-            $pkcs11Config = $env:PKCS11_CONFIG
-            if (-not $pkcs11Config) {
-              Write-Host "[ERROR] PKCS11_CONFIG environment variable not set"
-              Write-Host "DigiCert KeyLocker action may not have run correctly"
-              exit 1
-            }
-
-            Write-Host "Using PKCS11 config: $pkcs11Config"
-
-            # Try signing with certificate fingerprint first (if available)
-            $fingerprint = "${{ secrets.SM_CODE_SIGNING_CERT_SHA1_HASH }}"
-            if ($fingerprint -and $fingerprint -ne "") {
-              Write-Host "Attempting to sign with certificate fingerprint..."
-              $output = & smctl sign --fingerprint "$fingerprint" --input "$($file.FullName)" --config-file "$pkcs11Config" --verbose 2>&1
-              $exitCode = $LASTEXITCODE
-            } else {
-              Write-Host "No fingerprint provided, using keypair alias..."
-              # Use smctl to sign with keypair alias
-              $output = & smctl sign --keypair-alias "${{ secrets.SM_KEYPAIR_ALIAS }}" --input "$($file.FullName)" --config-file "$pkcs11Config" --verbose 2>&1
-              $exitCode = $LASTEXITCODE
-            }
-
-            Write-Host "Exit code: $exitCode"
-            Write-Host "Output: $output"
-
-            # Check if output contains "FAILED" even with exit code 0
-            if ($output -match "FAILED" -or $output -match "error" -or $output -match "Error") {
-              Write-Host ""
-              Write-Host "[ERROR] Signing failed for $($file.Name)"
-              Write-Host "[ERROR] smctl returned success but output indicates failure"
-              Write-Host ""
-              Write-Host "Possible issues:"
-              Write-Host "  1. Certificate not fully synced to KeyLocker (wait a few minutes)"
-              Write-Host "  2. Incorrect keypair alias"
-              Write-Host "  3. API key lacks signing permissions"
-              Write-Host ""
-              Write-Host "Please verify in DigiCert ONE portal:"
-              Write-Host "  - Certificate status is 'Issued' (not Pending)"
-              Write-Host "  - Keypair status is 'Online'"
-              Write-Host "  - 'Can sign' is set to 'Yes'"
-              exit 1
-            }
-
-            if ($exitCode -ne 0) {
-              Write-Host "[ERROR] Failed to sign $($file.Name)"
-              Write-Host "Full error output:"
-              Write-Host $output
-              exit 1
-            }
-
-            $signedCount++
-            Write-Host "[SUCCESS] Signed: $($file.Name)"
-            Write-Host ""
-          }
-
-          Write-Host "=== Summary ==="
-          Write-Host "[SUCCESS] Signed $signedCount/$($filesToSign.Count) files successfully"
-
-      - name: Verify notarization (macOS only)
-        if: matrix.platform == 'macos-15' || matrix.platform == 'macos-15-intel'
-        run: |
-          echo "🔍 Verifying notarization status..."
-          cd ./frontend/src-tauri/target
-          DMG_FILE=$(find . -name "*.dmg" | head -1)
-          if [ -n "$DMG_FILE" ]; then
-            echo "Found DMG: $DMG_FILE"
-            echo "Checking notarization ticket..."
-            spctl -a -vvv -t install "$DMG_FILE" || echo "⚠️ Notarization check failed or not yet complete"
-            stapler validate "$DMG_FILE" || echo "⚠️ No notarization ticket attached"
-          else
-            echo "⚠️ No DMG file found to verify"
-          fi
-
-      - name: Rename artifacts
-        shell: bash
-        run: |
-          mkdir -p ./dist
-          cd ./frontend/src-tauri/target
-
-          # Find and rename artifacts based on platform
-          if [ "${{ matrix.platform }}" = "windows-latest" ]; then
-            find . -name "*.exe" -exec cp {} "../../../dist/Stirling-PDF-${{ matrix.name }}.exe" \;
-            find . -name "*.msi" -exec cp {} "../../../dist/Stirling-PDF-${{ matrix.name }}.msi" \;
-          elif [ "${{ matrix.platform }}" = "macos-15" ] || [ "${{ matrix.platform }}" = "macos-15-intel" ]; then
-            find . -name "*.dmg" -exec cp {} "../../../dist/Stirling-PDF-${{ matrix.name }}.dmg" \;
-            find . -name "*.app" -exec cp -r {} "../../../dist/Stirling-PDF-${{ matrix.name }}.app" \;
-          else
-            find . -name "*.deb" -exec cp {} "../../../dist/Stirling-PDF-${{ matrix.name }}.deb" \;
-            find . -name "*.AppImage" -exec cp {} "../../../dist/Stirling-PDF-${{ matrix.name }}.AppImage" \;
-          fi
-
-      - name: Verify Windows Code Signature
-        if: matrix.platform == 'windows-latest' && github.ref == 'refs/heads/main'
-        shell: pwsh
-        run: |
-          Write-Host "Verifying Windows code signatures..."
-
-          $exePath = "./dist/Stirling-PDF-${{ matrix.name }}.exe"
-          $msiPath = "./dist/Stirling-PDF-${{ matrix.name }}.msi"
-
-          $allSigned = $true
-          $usingKeyLocker = "${{ env.SM_API_KEY }}" -ne ""
-          $usingPfx = "${{ env.WINDOWS_CERTIFICATE }}" -ne ""
-
-          # Check EXE signature
-          if (Test-Path $exePath) {
-            $exeSig = Get-AuthenticodeSignature -FilePath $exePath
-            Write-Host "EXE Signature Status: $($exeSig.Status)"
-            Write-Host "EXE Signer: $($exeSig.SignerCertificate.Subject)"
-            Write-Host "EXE Timestamp: $($exeSig.TimeStamperCertificate.NotAfter)"
-
-            if ($exeSig.Status -ne "Valid") {
-              Write-Host "[WARNING] EXE is not properly signed (Status: $($exeSig.Status))"
-              if ($usingKeyLocker -or $usingPfx) {
-                Write-Host "[ERROR] Certificate was provided but signing failed"
-                $allSigned = $false
-              } else {
-                Write-Host "[INFO] Building unsigned binary (no certificate provided)"
-              }
-            } else {
-              Write-Host "[SUCCESS] EXE is properly signed"
-            }
-          }
-
-          # Check MSI signature
-          if (Test-Path $msiPath) {
-            $msiSig = Get-AuthenticodeSignature -FilePath $msiPath
-            Write-Host "MSI Signature Status: $($msiSig.Status)"
-            Write-Host "MSI Signer: $($msiSig.SignerCertificate.Subject)"
-            Write-Host "MSI Timestamp: $($msiSig.TimeStamperCertificate.NotAfter)"
-
-            if ($msiSig.Status -ne "Valid") {
-              Write-Host "[WARNING] MSI is not properly signed (Status: $($msiSig.Status))"
-              if ($usingKeyLocker -or $usingPfx) {
-                Write-Host "[ERROR] Certificate was provided but signing failed"
-                $allSigned = $false
-              } else {
-                Write-Host "[INFO] Building unsigned binary (no certificate provided)"
-              }
-            } else {
-              Write-Host "[SUCCESS] MSI is properly signed"
-            }
-          }
-
-          if (($usingKeyLocker -or $usingPfx) -and -not $allSigned) {
-            Write-Host "[ERROR] Code signing verification failed"
-            exit 1
-          } else {
-            Write-Host "[SUCCESS] Code signature verification completed"
-          }
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: Stirling-PDF-${{ matrix.name }}
-          path: ./dist/*
-          retention-days: 7
- 
-      - name: Verify build artifacts
-        shell: bash
-        run: |
-          cd ./frontend/src-tauri/target
-
-          # Check for expected artifacts based on platform
-          if [ "${{ matrix.platform }}" = "windows-latest" ]; then
-            echo "Checking for Windows artifacts..."
-            find . -name "*.exe" -o -name "*.msi" | head -5
-            if [ $(find . -name "*.exe" | wc -l) -eq 0 ]; then
-              echo "❌ No Windows executable found"
-              exit 1
-            fi
-          elif [ "${{ matrix.platform }}" = "macos-15" ] || [ "${{ matrix.platform }}" = "macos-15-intel" ]; then
-            echo "Checking for macOS artifacts..."
-            find . -name "*.dmg" -o -name "*.app" | head -5
-            if [ $(find . -name "*.dmg" -o -name "*.app" | wc -l) -eq 0 ]; then
-              echo "❌ No macOS artifacts found"
-              exit 1
-            fi
-          else
-            echo "Checking for Linux artifacts..."
-            find . -name "*.deb" -o -name "*.AppImage" | head -5
-            if [ $(find . -name "*.deb" -o -name "*.AppImage" | wc -l) -eq 0 ]; then
-              echo "❌ No Linux artifacts found"
-              exit 1
-            fi
-          fi
-
-          echo "✅ Build artifacts found for ${{ matrix.name }}"
-
-      - name: Test artifact sizes
-        shell: bash
-        run: |
-          cd ./frontend/src-tauri/target
-          echo "Artifact sizes for ${{ matrix.name }}:"
-          find . -name "*.exe" -o -name "*.dmg" -o -name "*.deb" -o -name "*.AppImage" -o -name "*.msi" | while read file; do
-            if [ -f "$file" ]; then
-              size=$(stat -c%s "$file" 2>/dev/null || stat -f%z "$file" 2>/dev/null || echo "unknown")
-              echo "$file: $size bytes"
-              # Check if file is suspiciously small (less than 1MB)
-              if [ "$size" != "unknown" ] && [ "$size" -lt 1048576 ]; then
-                echo "⚠️  Warning: $file is smaller than 1MB"
-              fi
-            fi
-          done
-
-  report:
-    needs: build
-    runs-on: ubuntu-latest
-    if: always()
-    steps:
-      - name: Report build results
-        run: |
-          if [ "${{ needs.build.result }}" = "success" ]; then
-            echo "✅ All Tauri builds completed successfully!"
-            echo "Artifacts are ready for distribution."
-          else
-            echo "❌ Some Tauri builds failed."
-            echo "Please check the logs and fix any issues."
-            exit 1
-          fi

.gitignore

@@ -33,7 +33,6 @@ SwaggerDoc.json
 
 # Gradle
 .gradle
-.gradle-home
 .lock
 
 # External tool builders
@@ -214,17 +213,3 @@ node_modules/
 test_batch.json
 *.backup.*.json
 frontend/public/locales/*/translation.backup*.json
-
-# Development/build artifacts
-.gradle-cache/
-scripts/pdf-collection/
-**/tmp/
-*.backup
-
-# Type3 development data
-docs/type3/signatures/
-
-
-# Type3 sample PDFs (development only)
-**/type3/samples/
-

DeveloperGuide.md

@@ -32,12 +32,6 @@ This guide focuses on developing for Stirling 2.0, including both the React fron
 - Docker for containerization
 - Gradle for build management
 
-**Desktop Application (Tauri):**
-- Tauri for cross-platform desktop app packaging
-- Rust backend for system integration
-- PDF file association support
-- Self-contained JRE bundling with JLink
-
 **Legacy (reference only during development):**
 - Thymeleaf templates (being completely replaced in 2.0)
 
@@ -50,8 +44,6 @@ This guide focuses on developing for Stirling 2.0, including both the React fron
 - Java JDK 17 or later (JDK 21 recommended)
 - Node.js 18+ and npm (required for frontend development)
 - Gradle 7.0 or later (Included within the repo)
-- Rust and Cargo (required for Tauri desktop app development)
-- Tauri CLI (install with `cargo install tauri-cli`)
 
 ### Setup Steps
 
@@ -103,10 +95,6 @@ Stirling 2.0 uses client-side file storage:
 ### Legacy Code Reference
 The existing Thymeleaf templates remain in the codebase during development as reference material but will be completely removed for the 2.0 release.
 
-### Tauri Desktop App Development
-Stirling-PDF can be packaged as a cross-platform desktop application using Tauri with PDF file association support and bundled JRE.
-See [the frontend README](frontend/README.md#tauri) for build instructions.
-
 ## 5. Project Structure
 
 ```bash
@@ -121,12 +109,6 @@ Stirling-PDF/
 │   │   ├── services/      # API and utility services
 │   │   ├── types/         # TypeScript type definitions
 │   │   └── utils/         # Utility functions
-│   ├── src-tauri/         # Tauri desktop app configuration
-│   │   ├── src/           # Rust backend code
-│   │   ├── libs/          # JAR files (generated by build scripts)
-│   │   ├── runtime/       # Bundled JRE (generated by build scripts)
-│   │   ├── Cargo.toml     # Rust dependencies
-│   │   └── tauri.conf.json # Tauri configuration
 │   ├── public/
 │   │   └── locales/       # Internationalization files (JSON)
 │   ├── package.json       # Frontend dependencies
@@ -410,23 +392,23 @@ For Stirling 2.0, new features are built as React components instead of Thymelea
    // frontend/src/tools/NewTool.tsx
    import { useState } from 'react';
    import { Button, FileInput, Container } from '@mantine/core';
-
+   
    interface NewToolProps {
      params: Record<string, any>;
      updateParams: (updates: Record<string, any>) => void;
    }
-
+   
    export default function NewTool({ params, updateParams }: NewToolProps) {
      const [files, setFiles] = useState<File[]>([]);
-
+     
      const handleProcess = async () => {
        // Process files using API or client-side logic
      };
-
+     
      return (
        <Container>
-         <FileInput
-           multiple
+         <FileInput 
+           multiple 
            accept="application/pdf"
            onChange={setFiles}
          />

README.md

@@ -115,46 +115,46 @@ Stirling-PDF currently supports 40 languages!
 
 | Language                                     | Progress                               |
 | -------------------------------------------- | -------------------------------------- |
-| Arabic (العربية) (ar_AR)                        | ![87%](https://geps.dev/progress/87)   |
-| Azerbaijani (Azərbaycan Dili) (az_AZ)        | ![86%](https://geps.dev/progress/86)   |
-| Basque (Euskara) (eu_ES)                     | ![86%](https://geps.dev/progress/86)   |
-| Bulgarian (Български) (bg_BG)                | ![86%](https://geps.dev/progress/86)   |
-| Catalan (Català) (ca_CA)                     | ![85%](https://geps.dev/progress/85)   |
-| Croatian (Hrvatski) (hr_HR)                  | ![86%](https://geps.dev/progress/86)   |
-| Czech (Česky) (cs_CZ)                        | ![84%](https://geps.dev/progress/84)   |
-| Danish (Dansk) (da_DK)                       | ![85%](https://geps.dev/progress/85)   |
-| Dutch (Nederlands) (nl_NL)                   | ![85%](https://geps.dev/progress/85)   |
+| Arabic (العربية) (ar_AR)                        | ![83%](https://geps.dev/progress/83)   |
+| Azerbaijani (Azərbaycan Dili) (az_AZ)        | ![32%](https://geps.dev/progress/32)   |
+| Basque (Euskara) (eu_ES)                     | ![18%](https://geps.dev/progress/18)   |
+| Bulgarian (Български) (bg_BG)                | ![35%](https://geps.dev/progress/35)   |
+| Catalan (Català) (ca_CA)                     | ![34%](https://geps.dev/progress/34)   |
+| Croatian (Hrvatski) (hr_HR)                  | ![31%](https://geps.dev/progress/31)   |
+| Czech (Česky) (cs_CZ)                        | ![34%](https://geps.dev/progress/34)   |
+| Danish (Dansk) (da_DK)                       | ![30%](https://geps.dev/progress/30)   |
+| Dutch (Nederlands) (nl_NL)                   | ![30%](https://geps.dev/progress/30)   |
 | English (English) (en_GB)                    | ![100%](https://geps.dev/progress/100) |
 | English (US) (en_US)                         | ![100%](https://geps.dev/progress/100) |
-| French (Français) (fr_FR)                    | ![85%](https://geps.dev/progress/85)   |
-| German (Deutsch) (de_DE)                     | ![86%](https://geps.dev/progress/86)   |
-| Greek (Ελληνικά) (el_GR)                     | ![86%](https://geps.dev/progress/86)   |
-| Hindi (हिंदी) (hi_IN)                          | ![86%](https://geps.dev/progress/86)   |
-| Hungarian (Magyar) (hu_HU)                   | ![86%](https://geps.dev/progress/86)   |
-| Indonesian (Bahasa Indonesia) (id_ID)        | ![85%](https://geps.dev/progress/85)   |
-| Irish (Gaeilge) (ga_IE)                      | ![86%](https://geps.dev/progress/86)   |
-| Italian (Italiano) (it_IT)                   | ![85%](https://geps.dev/progress/85)   |
-| Japanese (日本語) (ja_JP)                    | ![86%](https://geps.dev/progress/86)   |
-| Korean (한국어) (ko_KR)                      | ![86%](https://geps.dev/progress/86)   |
-| Norwegian (Norsk) (no_NB)                    | ![86%](https://geps.dev/progress/86)   |
-| Persian (فارسی) (fa_IR)                      | ![86%](https://geps.dev/progress/86)   |
-| Polish (Polski) (pl_PL)                      | ![86%](https://geps.dev/progress/86)   |
-| Portuguese (Português) (pt_PT)               | ![86%](https://geps.dev/progress/86)   |
-| Portuguese Brazilian (Português) (pt_BR)     | ![86%](https://geps.dev/progress/86)   |
-| Romanian (Română) (ro_RO)                    | ![85%](https://geps.dev/progress/85)   |
-| Russian (Русский) (ru_RU)                    | ![86%](https://geps.dev/progress/86)   |
-| Serbian Latin alphabet (Srpski) (sr_LATN_RS) | ![86%](https://geps.dev/progress/86)   |
-| Simplified Chinese (简体中文) (zh_CN)         | ![87%](https://geps.dev/progress/87)   |
-| Slovakian (Slovensky) (sk_SK)                | ![86%](https://geps.dev/progress/86)   |
-| Slovenian (Slovenščina) (sl_SI)              | ![86%](https://geps.dev/progress/86)   |
-| Spanish (Español) (es_ES)                    | ![86%](https://geps.dev/progress/86)   |
-| Swedish (Svenska) (sv_SE)                    | ![86%](https://geps.dev/progress/86)   |
-| Thai (ไทย) (th_TH)                           | ![86%](https://geps.dev/progress/86)   |
+| French (Français) (fr_FR)                    | ![82%](https://geps.dev/progress/82)   |
+| German (Deutsch) (de_DE)                     | ![84%](https://geps.dev/progress/84)   |
+| Greek (Ελληνικά) (el_GR)                     | ![34%](https://geps.dev/progress/34)   |
+| Hindi (हिंदी) (hi_IN)                          | ![34%](https://geps.dev/progress/34)   |
+| Hungarian (Magyar) (hu_HU)                   | ![38%](https://geps.dev/progress/38)   |
+| Indonesian (Bahasa Indonesia) (id_ID)        | ![31%](https://geps.dev/progress/31)   |
+| Irish (Gaeilge) (ga_IE)                      | ![34%](https://geps.dev/progress/34)   |
+| Italian (Italiano) (it_IT)                   | ![84%](https://geps.dev/progress/84)   |
+| Japanese (日本語) (ja_JP)                    | ![62%](https://geps.dev/progress/62)   |
+| Korean (한국어) (ko_KR)                      | ![34%](https://geps.dev/progress/34)   |
+| Norwegian (Norsk) (no_NB)                    | ![32%](https://geps.dev/progress/32)   |
+| Persian (فارسی) (fa_IR)                      | ![34%](https://geps.dev/progress/34)   |
+| Polish (Polski) (pl_PL)                      | ![36%](https://geps.dev/progress/36)   |
+| Portuguese (Português) (pt_PT)               | ![34%](https://geps.dev/progress/34)   |
+| Portuguese Brazilian (Português) (pt_BR)     | ![83%](https://geps.dev/progress/83)   |
+| Romanian (Română) (ro_RO)                    | ![28%](https://geps.dev/progress/28)   |
+| Russian (Русский) (ru_RU)                    | ![83%](https://geps.dev/progress/83)   |
+| Serbian Latin alphabet (Srpski) (sr_LATN_RS) | ![37%](https://geps.dev/progress/37)   |
+| Simplified Chinese (简体中文) (zh_CN)         | ![85%](https://geps.dev/progress/85)   |
+| Slovakian (Slovensky) (sk_SK)                | ![26%](https://geps.dev/progress/26)   |
+| Slovenian (Slovenščina) (sl_SI)              | ![36%](https://geps.dev/progress/36)   |
+| Spanish (Español) (es_ES)                    | ![84%](https://geps.dev/progress/84)   |
+| Swedish (Svenska) (sv_SE)                    | ![33%](https://geps.dev/progress/33)   |
+| Thai (ไทย) (th_TH)                           | ![31%](https://geps.dev/progress/31)   |
 | Tibetan (བོད་ཡིག་) (bo_CN)                     | ![65%](https://geps.dev/progress/65) |
-| Traditional Chinese (繁體中文) (zh_TW)        | ![87%](https://geps.dev/progress/87)   |
-| Turkish (Türkçe) (tr_TR)                     | ![86%](https://geps.dev/progress/86)   |
-| Ukrainian (Українська) (uk_UA)               | ![86%](https://geps.dev/progress/86)   |
-| Vietnamese (Tiếng Việt) (vi_VN)              | ![86%](https://geps.dev/progress/86)   |
+| Traditional Chinese (繁體中文) (zh_TW)        | ![38%](https://geps.dev/progress/38)   |
+| Turkish (Türkçe) (tr_TR)                     | ![37%](https://geps.dev/progress/37)   |
+| Ukrainian (Українська) (uk_UA)               | ![36%](https://geps.dev/progress/36)   |
+| Vietnamese (Tiếng Việt) (vi_VN)              | ![28%](https://geps.dev/progress/28)   |
 | Malayalam (മലയാളം) (ml_IN)              | ![73%](https://geps.dev/progress/73)   |
 
 ## Stirling PDF Enterprise

WINDOWS_SIGNING.md

@@ -1,258 +0,0 @@
-# Windows Code Signing Setup Guide
-
-This guide explains how to set up Windows code signing for Stirling-PDF desktop application builds.
-
-## Overview
-
-Windows code signing is essential for:
-- Preventing Windows SmartScreen warnings
-- Building trust with users
-- Enabling Microsoft Store distribution
-- Professional application distribution
-
-## Certificate Types
-
-### OV Certificate (Organization Validated)
-- More affordable option
-- Requires business verification
-- May trigger SmartScreen warnings initially until reputation builds
-- Suitable for most independent software vendors
-
-### EV Certificate (Extended Validation)
-- Premium option with immediate SmartScreen reputation
-- Requires hardware security module (HSM) or cloud-based signing
-- Higher cost but provides immediate trust
-- Required since June 2023 for new certificates
-
-## Obtaining a Certificate
-
-### Certificate Authorities
-Popular certificate authorities for Windows code signing:
-- DigiCert
-- Sectigo (formerly Comodo)
-- GlobalSign
-- SSL.com
-
-### Certificate Format
-You'll receive a certificate in one of these formats:
-- `.pfx` or `.p12` (preferred - contains both certificate and private key)
-- `.cer` + private key (needs conversion to .pfx)
-
-### Converting to PFX (if needed)
-If you have separate certificate and private key files:
-
-```bash
-openssl pkcs12 -export -out certificate.pfx -inkey private-key.key -in certificate.cer
-```
-
-## Setting Up GitHub Secrets
-
-### Required Secrets
-
-Navigate to your GitHub repository → Settings → Secrets and variables → Actions
-
-Add the following secrets:
-
-#### 1. `WINDOWS_CERTIFICATE`
-- **Description**: Base64-encoded .pfx certificate file
-- **How to create**:
-
-**On macOS/Linux:**
-```bash
-base64 -i certificate.pfx | pbcopy  # Copies to clipboard
-```
-
-**On Windows (PowerShell):**
-```powershell
-[Convert]::ToBase64String([IO.File]::ReadAllBytes("certificate.pfx")) | Set-Clipboard
-```
-
-Paste the entire base64 string into the GitHub secret.
-
-#### 2. `WINDOWS_CERTIFICATE_PASSWORD`
-- **Description**: Password for the .pfx certificate
-- **Value**: The password you set when creating/exporting the .pfx file
-
-### Optional Secrets for Tauri Updater
-
-If you're using Tauri's built-in updater feature:
-
-#### `TAURI_SIGNING_PRIVATE_KEY`
-- Generated using Tauri CLI: `npm run tauri signer generate`
-- Used for update package verification
-
-#### `TAURI_SIGNING_PRIVATE_KEY_PASSWORD`
-- Password for the Tauri signing key
-
-## Configuration Files
-
-### 1. Tauri Configuration (frontend/src-tauri/tauri.conf.json)
-
-The Windows signing configuration is already set up:
-
-```json
-"windows": {
-  "certificateThumbprint": null,
-  "digestAlgorithm": "sha256",
-  "timestampUrl": "http://timestamp.digicert.com"
-}
-```
-
-**Configuration Options:**
-- `certificateThumbprint`: Automatically extracted from imported certificate (leave as `null`)
-- `digestAlgorithm`: Hashing algorithm - `sha256` is recommended
-- `timestampUrl`: Timestamp server to prove signing time (survives certificate expiration)
-
-**Alternative Timestamp Servers:**
-- DigiCert: `http://timestamp.digicert.com`
-- Sectigo: `http://timestamp.sectigo.com`
-- GlobalSign: `http://timestamp.globalsign.com`
-
-### 2. GitHub Workflow (.github/workflows/tauri-build.yml)
-
-The workflow includes three Windows signing steps:
-
-1. **Import Certificate**: Decodes and imports the .pfx certificate into Windows certificate store
-2. **Build Tauri App**: Builds and signs the application using the imported certificate
-3. **Verify Signature**: Validates that both .exe and .msi files are properly signed
-
-## Testing the Setup
-
-### 1. Local Testing (Windows Only)
-
-Before pushing to GitHub, test locally:
-
-```powershell
-# Set environment variables
-$env:WINDOWS_CERTIFICATE = [Convert]::ToBase64String([IO.File]::ReadAllBytes("certificate.pfx"))
-$env:WINDOWS_CERTIFICATE_PASSWORD = "your-certificate-password"
-
-# Build the application
-cd frontend
-npm run tauri build
-
-# Verify the signature
-Get-AuthenticodeSignature "./src-tauri/target/release/bundle/msi/Stirling-PDF_*.msi"
-```
-
-### 2. GitHub Actions Testing
-
-1. Push your changes to a branch
-2. Manually trigger the workflow:
-   - Go to Actions → Build Tauri Applications
-   - Click "Run workflow"
-   - Select "windows" platform
-3. Check the build logs for:
-   - ✅ Certificate import success
-   - ✅ Build completion
-   - ✅ Signature verification
-
-### 3. Verifying Signed Binaries
-
-After downloading the built artifacts:
-
-**Windows (PowerShell):**
-```powershell
-Get-AuthenticodeSignature "Stirling-PDF-windows-x86_64.exe"
-Get-AuthenticodeSignature "Stirling-PDF-windows-x86_64.msi"
-```
-
-Look for:
-- Status: `Valid`
-- Signer: Your organization name
-- Timestamp: Recent date/time
-
-**Windows (GUI):**
-1. Right-click the .exe or .msi file
-2. Select "Properties"
-3. Go to "Digital Signatures" tab
-4. Verify signature details
-
-## Troubleshooting
-
-### "HashMismatch" Status
-- Certificate doesn't match the binary
-- Possible file corruption during download
-- Re-download and verify
-
-### "NotSigned" Status
-- Certificate wasn't imported correctly
-- Check GitHub secrets are set correctly
-- Verify base64 encoding is complete (no truncation)
-
-### "UnknownError" Status
-- Timestamp server unreachable
-- Try alternative timestamp URL in tauri.conf.json
-- Check network connectivity in GitHub Actions
-
-### SmartScreen Still Shows Warnings
-- Normal for OV certificates initially
-- Reputation builds over time with user downloads
-- Consider EV certificate for immediate reputation
-
-### Certificate Not Found During Build
-- Verify `WINDOWS_CERTIFICATE` secret is set
-- Check base64 encoding is correct (no extra whitespace)
-- Ensure password is correct
-
-## Security Best Practices
-
-1. **Never commit certificates to version control**
-   - Keep .pfx files secure and backed up
-   - Use GitHub secrets for CI/CD
-
-2. **Rotate certificates before expiration**
-   - Set calendar reminders
-   - Update GitHub secrets with new certificate
-
-3. **Use strong passwords**
-   - Certificate password should be complex
-   - Store securely (password manager)
-
-4. **Monitor certificate usage**
-   - Review GitHub Actions logs
-   - Set up notifications for failed builds
-
-5. **Limit access to secrets**
-   - Only repository admins should access secrets
-   - Audit secret access regularly
-
-## Certificate Lifecycle
-
-### Before Expiration
-1. Obtain new certificate from CA (typically annual renewal)
-2. Convert to .pfx format if needed
-3. Update `WINDOWS_CERTIFICATE` secret with new base64-encoded certificate
-4. Update `WINDOWS_CERTIFICATE_PASSWORD` if password changed
-5. Test build to verify new certificate works
-
-### Expired Certificates
-- Signed binaries remain valid (timestamp proves signing time)
-- New builds will fail until certificate is renewed
-- Users can still install previously signed versions
-
-## Cost Considerations
-
-### Certificate Costs (Annual, as of 2024)
-- **OV Certificate**: $100-400/year
-- **EV Certificate**: $400-1000/year
-
-### Choosing the Right Certificate
-- **Open source / early stage**: Start with OV
-- **Commercial / enterprise**: Consider EV for better trust
-- **Microsoft Store**: EV certificate required
-
-## Additional Resources
-
-- [Tauri Windows Signing Documentation](https://v2.tauri.app/distribute/sign/windows/)
-- [Microsoft Code Signing Overview](https://docs.microsoft.com/windows/win32/seccrypto/cryptography-tools)
-- [DigiCert Code Signing Guide](https://www.digicert.com/signing/code-signing-certificates)
-- [Windows SmartScreen FAQ](https://support.microsoft.com/windows/smartscreen-faq)
-
-## Support
-
-If you encounter issues with Windows code signing:
-1. Check GitHub Actions logs for detailed error messages
-2. Verify all secrets are set correctly
-3. Test certificate locally first (Windows environment required)
-4. Open an issue in the repository with relevant logs (remove sensitive data)

app/common/build.gradle

@@ -37,8 +37,6 @@ dependencies {
     api 'com.drewnoakes:metadata-extractor:2.19.0' // Image metadata extractor
     api 'com.vladsch.flexmark:flexmark-html2md-converter:0.64.8'
     api "org.apache.pdfbox:pdfbox:$pdfboxVersion"
-    api "org.apache.pdfbox:xmpbox:$pdfboxVersion"
-    api "org.apache.pdfbox:preflight:$pdfboxVersion"
     api 'com.github.junrar:junrar:7.5.5' // RAR archive support for CBR files
     api 'jakarta.servlet:jakarta.servlet-api:6.1.0'
     api 'org.snakeyaml:snakeyaml-engine:2.10'

app/common/src/main/java/stirling/software/common/annotations/api/InviteApi.java

@@ -1,37 +0,0 @@
-package stirling.software.common.annotations.api;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import io.swagger.v3.oas.annotations.tags.Tag;
-
-/**
- * Combined annotation for Invite management controllers.
- * Includes @RestController, @RequestMapping("/api/v1/invite"), and OpenAPI @Tag.
- */
-@Target(ElementType.TYPE)
-@Retention(RetentionPolicy.RUNTIME)
-@RestController
-@RequestMapping("/api/v1/invite")
-@Tag(
-        name = "Invite",
-        description =
-                """
-                Invite-link generation and acceptance endpoints for onboarding new users.
-
-                Provides the ability to issue invitation tokens, send optional email invites,
-                validate and accept invite links, and manage pending invitations for teams.
-
-                Typical use cases include:
-                • Admin workflows for issuing time-limited invitations to external users
-                • Self-service invite acceptance and team assignment
-                • License limit enforcement when provisioning new accounts
-
-                Target users: administrators and automation scripts orchestrating user onboarding.
-                """)
-public @interface InviteApi {}

app/common/src/main/java/stirling/software/common/model/ApplicationProperties.java

@@ -505,19 +505,10 @@ public class ApplicationProperties {
     public static class Ui {
         private String appNameNavbar;
         private List<String> languages;
-        private String logoStyle = "classic"; // Options: "classic" (default) or "modern"
 
         public String getAppNameNavbar() {
             return appNameNavbar != null && !appNameNavbar.trim().isEmpty() ? appNameNavbar : null;
         }
-
-        public String getLogoStyle() {
-            // Validate and return either "modern" or "classic"
-            if ("modern".equalsIgnoreCase(logoStyle)) {
-                return "modern";
-            }
-            return "classic"; // default
-        }
     }
 
     @Data

app/common/src/main/java/stirling/software/common/service/CustomPDFDocumentFactory.java

@@ -41,7 +41,7 @@ public class CustomPDFDocumentFactory {
 
     // Memory thresholds and limits
 
-    public static final long SMALL_FILE_THRESHOLD = 10 * 1024 * 1024; // 10 MB
+    private static final long SMALL_FILE_THRESHOLD = 10 * 1024 * 1024; // 10 MB
     // Files smaller than this threshold are loaded entirely in memory for better performance.
     // These files use IOUtils.createMemoryOnlyStreamCache() which keeps all document data in RAM.
     // No temp files are created for document data, reducing I/O operations but consuming more

app/common/src/main/java/stirling/software/common/service/JobExecutorService.java

@@ -9,7 +9,6 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Supplier;
 
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
@@ -38,9 +37,6 @@ public class JobExecutorService {
     private final ExecutorService executor = ExecutorFactory.newVirtualOrCachedThreadExecutor();
     private final long effectiveTimeoutMs;
 
-    @Autowired(required = false)
-    private JobOwnershipService jobOwnershipService;
-
     public JobExecutorService(
             TaskManager taskManager,
             FileStorage fileStorage,
@@ -102,17 +98,11 @@ public class JobExecutorService {
             long customTimeoutMs,
             boolean queueable,
             int resourceWeight) {
-        // Generate base UUID
-        String baseJobId = UUID.randomUUID().toString();
+        String jobId = UUID.randomUUID().toString();
 
-        // Scope job to authenticated user if security is enabled
-        String scopedJobKey = getScopedJobKey(baseJobId);
-
-        log.debug("Generated jobId: {} (base: {})", scopedJobKey, baseJobId);
-
-        // Store the scoped job ID in the request for potential use by other components
+        // Store the job ID in the request for potential use by other components
         if (request != null) {
-            request.setAttribute("jobId", scopedJobKey);
+            request.setAttribute("jobId", jobId);
 
             // Also track this job ID in the user's session for authorization purposes
             // This ensures users can only cancel their own jobs
@@ -126,13 +116,11 @@ public class JobExecutorService {
                     request.getSession().setAttribute("userJobIds", userJobIds);
                 }
 
-                userJobIds.add(scopedJobKey);
-                log.debug("Added scoped job ID {} to user session", scopedJobKey);
+                userJobIds.add(jobId);
+                log.debug("Added job ID {} to user session", jobId);
             }
         }
 
-        String jobId = scopedJobKey;
-
         // Determine which timeout to use
         long timeoutToUse = customTimeoutMs > 0 ? customTimeoutMs : effectiveTimeoutMs;
 
@@ -161,31 +149,17 @@ public class JobExecutorService {
             taskManager.createTask(jobId);
 
             // Create a specialized wrapper that updates the TaskManager
-            final String capturedJobIdForQueue = jobId;
             Supplier<Object> wrappedWork =
                     () -> {
                         try {
-                            // Set jobId in ThreadLocal context for the queued job
-                            stirling.software.common.util.JobContext.setJobId(
-                                    capturedJobIdForQueue);
-                            log.debug(
-                                    "Set jobId {} in JobContext for queued job execution",
-                                    capturedJobIdForQueue);
-
                             Object result = work.get();
-                            processJobResult(capturedJobIdForQueue, result);
+                            processJobResult(jobId, result);
                             return result;
                         } catch (Exception e) {
                             log.error(
-                                    "Error executing queued job {}: {}",
-                                    capturedJobIdForQueue,
-                                    e.getMessage(),
-                                    e);
-                            taskManager.setError(capturedJobIdForQueue, e.getMessage());
+                                    "Error executing queued job {}: {}", jobId, e.getMessage(), e);
+                            taskManager.setError(jobId, e.getMessage());
                             throw e;
-                        } finally {
-                            // Clean up ThreadLocal to avoid memory leaks
-                            stirling.software.common.util.JobContext.clear();
                         }
                     };
 
@@ -197,36 +171,21 @@ public class JobExecutorService {
             return ResponseEntity.ok().body(new JobResponse<>(true, jobId, null));
         } else if (async) {
             taskManager.createTask(jobId);
-
-            // Capture the jobId for the async thread
-            final String capturedJobId = jobId;
-
             executor.execute(
                     () -> {
                         try {
                             log.debug(
-                                    "Running async job {} with timeout {} ms",
-                                    capturedJobId,
-                                    timeoutToUse);
-
-                            // Set jobId in ThreadLocal context for the async thread
-                            stirling.software.common.util.JobContext.setJobId(capturedJobId);
-                            log.debug(
-                                    "Set jobId {} in JobContext for async execution",
-                                    capturedJobId);
+                                    "Running async job {} with timeout {} ms", jobId, timeoutToUse);
 
                             // Execute with timeout
                             Object result = executeWithTimeout(() -> work.get(), timeoutToUse);
-                            processJobResult(capturedJobId, result);
+                            processJobResult(jobId, result);
                         } catch (TimeoutException te) {
                             log.error("Job {} timed out after {} ms", jobId, timeoutToUse);
                             taskManager.setError(jobId, "Job timed out");
                         } catch (Exception e) {
                             log.error("Error executing job {}: {}", jobId, e.getMessage(), e);
                             taskManager.setError(jobId, e.getMessage());
-                        } finally {
-                            // Clean up ThreadLocal to avoid memory leaks
-                            stirling.software.common.util.JobContext.clear();
                         }
                     });
 
@@ -235,10 +194,6 @@ public class JobExecutorService {
             try {
                 log.debug("Running sync job with timeout {} ms", timeoutToUse);
 
-                // Make jobId available to downstream components on the worker thread
-                stirling.software.common.util.JobContext.setJobId(jobId);
-                log.debug("Set jobId {} in JobContext for sync execution", jobId);
-
                 // Execute with timeout
                 Object result = executeWithTimeout(() -> work.get(), timeoutToUse);
 
@@ -258,8 +213,6 @@ public class JobExecutorService {
                 // Construct a JSON error response
                 return ResponseEntity.internalServerError()
                         .body(Map.of("error", "Job failed: " + e.getMessage()));
-            } finally {
-                stirling.software.common.util.JobContext.clear();
             }
         }
     }
@@ -513,23 +466,8 @@ public class JobExecutorService {
             throws TimeoutException, Exception {
         // Use the same executor as other async jobs for consistency
         // This ensures all operations run on the same thread pool
-        String currentJobId = stirling.software.common.util.JobContext.getJobId();
-
         java.util.concurrent.CompletableFuture<T> future =
-                java.util.concurrent.CompletableFuture.supplyAsync(
-                        () -> {
-                            if (currentJobId != null) {
-                                stirling.software.common.util.JobContext.setJobId(currentJobId);
-                            }
-                            try {
-                                return supplier.get();
-                            } finally {
-                                if (currentJobId != null) {
-                                    stirling.software.common.util.JobContext.clear();
-                                }
-                            }
-                        },
-                        executor);
+                java.util.concurrent.CompletableFuture.supplyAsync(supplier, executor);
 
         try {
             return future.get(timeoutMs, TimeUnit.MILLISECONDS);
@@ -545,18 +483,4 @@ public class JobExecutorService {
             throw new Exception("Execution was interrupted", e);
         }
     }
-
-    /**
-     * Get a scoped job key that includes user ownership when security is enabled.
-     *
-     * @param baseJobId the base job identifier
-     * @return scoped job key, or just baseJobId if no ownership service available
-     */
-    private String getScopedJobKey(String baseJobId) {
-        if (jobOwnershipService != null) {
-            return jobOwnershipService.createScopedJobKey(baseJobId);
-        }
-        // Security disabled, return unsecured job key
-        return baseJobId;
-    }
 }

app/common/src/main/java/stirling/software/common/service/JobOwnershipService.java

@@ -1,42 +0,0 @@
-package stirling.software.common.service;
-
-import java.util.Optional;
-
-/**
- * Service interface for managing job ownership and access control. Implementations can provide
- * user-scoped job isolation when security is enabled, or no-op behavior when security is disabled.
- */
-public interface JobOwnershipService {
-
-    /**
-     * Get the current authenticated user's identifier.
-     *
-     * @return Optional containing user identifier, or empty if not authenticated
-     */
-    Optional<String> getCurrentUserId();
-
-    /**
-     * Create a scoped job key that includes user ownership when security is enabled.
-     *
-     * @param jobId the base job identifier
-     * @return scoped job key in format "userId:jobId", or just jobId if no user authenticated
-     */
-    String createScopedJobKey(String jobId);
-
-    /**
-     * Validate that the current user has access to the given job.
-     *
-     * @param scopedJobKey the scoped job key to validate
-     * @return true if current user owns the job or no authentication is required
-     * @throws SecurityException if current user does not own the job
-     */
-    boolean validateJobAccess(String scopedJobKey);
-
-    /**
-     * Extract the base job ID from a scoped job key.
-     *
-     * @param scopedJobKey the scoped job key
-     * @return the base job ID without user prefix
-     */
-    String extractJobId(String scopedJobKey);
-}

app/common/src/main/java/stirling/software/common/service/UserServiceInterface.java

@@ -8,6 +8,4 @@ public interface UserServiceInterface {
     long getTotalUsersCount();
 
     boolean isCurrentUserAdmin();
-
-    boolean isCurrentUserFirstLogin();
 }

app/common/src/main/java/stirling/software/common/util/FormUtils.java

@@ -0,0 +1,658 @@
+package stirling.software.common.util;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.pdfbox.cos.COSName;
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDDocumentCatalog;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.PDResources;
+import org.apache.pdfbox.pdmodel.common.PDRectangle;
+import org.apache.pdfbox.pdmodel.font.PDType1Font;
+import org.apache.pdfbox.pdmodel.font.Standard14Fonts;
+import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotation;
+import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotationWidget;
+import org.apache.pdfbox.pdmodel.interactive.form.*;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public final class FormUtils {
+
+    private FormUtils() {}
+
+    public static boolean hasAnyRotatedPage(PDDocument document) {
+        try {
+            for (PDPage page : document.getPages()) {
+                int rot = page.getRotation();
+                int norm = ((rot % 360) + 360) % 360;
+                if (norm != 0) {
+                    return true;
+                }
+            }
+        } catch (Exception e) {
+            log.warn("Failed to inspect page rotations: {}", e.getMessage(), e);
+        }
+        return false;
+    }
+
+    public static void copyAndTransformFormFields(
+            PDDocument sourceDocument,
+            PDDocument newDocument,
+            int totalPages,
+            int pagesPerSheet,
+            int cols,
+            int rows,
+            float cellWidth,
+            float cellHeight)
+            throws IOException {
+
+        PDDocumentCatalog sourceCatalog = sourceDocument.getDocumentCatalog();
+        PDAcroForm sourceAcroForm = sourceCatalog.getAcroForm();
+
+        if (sourceAcroForm == null || sourceAcroForm.getFields().isEmpty()) {
+            return;
+        }
+
+        PDDocumentCatalog newCatalog = newDocument.getDocumentCatalog();
+        PDAcroForm newAcroForm = new PDAcroForm(newDocument);
+        newCatalog.setAcroForm(newAcroForm);
+
+        PDResources dr = new PDResources();
+        PDType1Font helvetica = new PDType1Font(Standard14Fonts.FontName.HELVETICA);
+        PDType1Font zapfDingbats = new PDType1Font(Standard14Fonts.FontName.ZAPF_DINGBATS);
+        dr.put(COSName.getPDFName("Helv"), helvetica);
+        dr.put(COSName.getPDFName("ZaDb"), zapfDingbats);
+        newAcroForm.setDefaultResources(dr);
+        newAcroForm.setDefaultAppearance("/Helv 12 Tf 0 g");
+
+        // Do not mutate the source AcroForm; skip bad widgets during copy
+        newAcroForm.setNeedAppearances(true);
+
+        Map<String, Integer> fieldNameCounters = new HashMap<>();
+
+        // Build widget -> field map once for efficient lookups
+        Map<PDAnnotationWidget, PDField> widgetFieldMap = buildWidgetFieldMap(sourceAcroForm);
+
+        for (int pageIndex = 0; pageIndex < totalPages; pageIndex++) {
+            PDPage sourcePage = sourceDocument.getPage(pageIndex);
+            List<PDAnnotation> annotations = sourcePage.getAnnotations();
+
+            if (annotations.isEmpty()) {
+                continue;
+            }
+
+            int destinationPageIndex = pageIndex / pagesPerSheet;
+            int adjustedPageIndex = pageIndex % pagesPerSheet;
+            int rowIndex = adjustedPageIndex / cols;
+            int colIndex = adjustedPageIndex % cols;
+
+            if (destinationPageIndex >= newDocument.getNumberOfPages()) {
+                continue;
+            }
+
+            PDPage destinationPage = newDocument.getPage(destinationPageIndex);
+            PDRectangle sourceRect = sourcePage.getMediaBox();
+
+            float scaleWidth = cellWidth / sourceRect.getWidth();
+            float scaleHeight = cellHeight / sourceRect.getHeight();
+            float scale = Math.min(scaleWidth, scaleHeight);
+
+            float x = colIndex * cellWidth + (cellWidth - sourceRect.getWidth() * scale) / 2;
+            float y =
+                    destinationPage.getMediaBox().getHeight()
+                            - ((rowIndex + 1) * cellHeight
+                                    - (cellHeight - sourceRect.getHeight() * scale) / 2);
+
+            copyBasicFormFields(
+                    sourceAcroForm,
+                    newAcroForm,
+                    sourcePage,
+                    destinationPage,
+                    x,
+                    y,
+                    scale,
+                    pageIndex,
+                    fieldNameCounters,
+                    widgetFieldMap);
+        }
+
+        // Refresh appearances to ensure widgets render correctly across viewers
+        try {
+            // Use reflection to avoid compile-time dependency on PDFBox version
+            Method m = newAcroForm.getClass().getMethod("refreshAppearances");
+            m.invoke(newAcroForm);
+        } catch (NoSuchMethodException nsme) {
+            log.warn(
+                    "AcroForm.refreshAppearances() not available in this PDFBox version; relying on NeedAppearances.");
+        } catch (Throwable t) {
+            log.warn("Failed to refresh field appearances via AcroForm: {}", t.getMessage(), t);
+        }
+    }
+
+    private static void copyBasicFormFields(
+            PDAcroForm sourceAcroForm,
+            PDAcroForm newAcroForm,
+            PDPage sourcePage,
+            PDPage destinationPage,
+            float offsetX,
+            float offsetY,
+            float scale,
+            int pageIndex,
+            Map<String, Integer> fieldNameCounters,
+            Map<PDAnnotationWidget, PDField> widgetFieldMap) {
+
+        try {
+            List<PDAnnotation> sourceAnnotations = sourcePage.getAnnotations();
+            List<PDAnnotation> destinationAnnotations = destinationPage.getAnnotations();
+
+            for (PDAnnotation annotation : sourceAnnotations) {
+                if (annotation instanceof PDAnnotationWidget widgetAnnotation) {
+                    if (widgetAnnotation.getRectangle() == null) {
+                        continue;
+                    }
+                    PDField sourceField =
+                            widgetFieldMap != null ? widgetFieldMap.get(widgetAnnotation) : null;
+                    if (sourceField == null) {
+                        continue; // skip widgets without a matching field
+                    }
+                    if (sourceField instanceof PDTextField pdtextfield) {
+                        createSimpleTextField(
+                                newAcroForm,
+                                destinationPage,
+                                destinationAnnotations,
+                                pdtextfield,
+                                widgetAnnotation,
+                                offsetX,
+                                offsetY,
+                                scale,
+                                pageIndex,
+                                fieldNameCounters);
+                    } else if (sourceField instanceof PDCheckBox pdCheckBox) {
+                        createSimpleCheckBoxField(
+                                newAcroForm,
+                                destinationPage,
+                                destinationAnnotations,
+                                pdCheckBox,
+                                widgetAnnotation,
+                                offsetX,
+                                offsetY,
+                                scale,
+                                pageIndex,
+                                fieldNameCounters);
+                    } else if (sourceField instanceof PDRadioButton pdRadioButton) {
+                        createSimpleRadioButtonField(
+                                newAcroForm,
+                                destinationPage,
+                                destinationAnnotations,
+                                pdRadioButton,
+                                widgetAnnotation,
+                                offsetX,
+                                offsetY,
+                                scale,
+                                pageIndex,
+                                fieldNameCounters);
+                    } else if (sourceField instanceof PDComboBox pdComboBox) {
+                        createSimpleComboBoxField(
+                                newAcroForm,
+                                destinationPage,
+                                destinationAnnotations,
+                                pdComboBox,
+                                widgetAnnotation,
+                                offsetX,
+                                offsetY,
+                                scale,
+                                pageIndex,
+                                fieldNameCounters);
+                    } else if (sourceField instanceof PDListBox pdlistbox) {
+                        createSimpleListBoxField(
+                                newAcroForm,
+                                destinationPage,
+                                destinationAnnotations,
+                                pdlistbox,
+                                widgetAnnotation,
+                                offsetX,
+                                offsetY,
+                                scale,
+                                pageIndex,
+                                fieldNameCounters);
+                    } else if (sourceField instanceof PDSignatureField pdSignatureField) {
+                        createSimpleSignatureField(
+                                newAcroForm,
+                                destinationPage,
+                                destinationAnnotations,
+                                pdSignatureField,
+                                widgetAnnotation,
+                                offsetX,
+                                offsetY,
+                                scale,
+                                pageIndex,
+                                fieldNameCounters);
+                    } else if (sourceField instanceof PDPushButton pdPushButton) {
+                        createSimplePushButtonField(
+                                newAcroForm,
+                                destinationPage,
+                                destinationAnnotations,
+                                pdPushButton,
+                                widgetAnnotation,
+                                offsetX,
+                                offsetY,
+                                scale,
+                                pageIndex,
+                                fieldNameCounters);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            log.warn(
+                    "Failed to copy basic form fields for page {}: {}",
+                    pageIndex,
+                    e.getMessage(),
+                    e);
+        }
+    }
+
+    private static void createSimpleTextField(
+            PDAcroForm newAcroForm,
+            PDPage destinationPage,
+            List<PDAnnotation> destinationAnnotations,
+            PDTextField sourceField,
+            PDAnnotationWidget sourceWidget,
+            float offsetX,
+            float offsetY,
+            float scale,
+            int pageIndex,
+            Map<String, Integer> fieldNameCounters) {
+
+        try {
+            PDTextField newTextField = new PDTextField(newAcroForm);
+            newTextField.setDefaultAppearance("/Helv 12 Tf 0 g");
+
+            boolean initialized =
+                    initializeFieldWithWidget(
+                            newAcroForm,
+                            destinationPage,
+                            destinationAnnotations,
+                            newTextField,
+                            sourceField.getPartialName(),
+                            "textField",
+                            sourceWidget,
+                            offsetX,
+                            offsetY,
+                            scale,
+                            pageIndex,
+                            fieldNameCounters);
+
+            if (!initialized) {
+                return;
+            }
+
+            if (sourceField.getValueAsString() != null) {
+                newTextField.setValue(sourceField.getValueAsString());
+            }
+
+        } catch (Exception e) {
+            log.warn(
+                    "Failed to create text field '{}': {}",
+                    sourceField.getPartialName(),
+                    e.getMessage(),
+                    e);
+        }
+    }
+
+    private static void createSimpleCheckBoxField(
+            PDAcroForm newAcroForm,
+            PDPage destinationPage,
+            List<PDAnnotation> destinationAnnotations,
+            PDCheckBox sourceField,
+            PDAnnotationWidget sourceWidget,
+            float offsetX,
+            float offsetY,
+            float scale,
+            int pageIndex,
+            Map<String, Integer> fieldNameCounters) {
+
+        try {
+            PDCheckBox newCheckBox = new PDCheckBox(newAcroForm);
+
+            boolean initialized =
+                    initializeFieldWithWidget(
+                            newAcroForm,
+                            destinationPage,
+                            destinationAnnotations,
+                            newCheckBox,
+                            sourceField.getPartialName(),
+                            "checkBox",
+                            sourceWidget,
+                            offsetX,
+                            offsetY,
+                            scale,
+                            pageIndex,
+                            fieldNameCounters);
+
+            if (!initialized) {
+                return;
+            }
+
+            if (sourceField.isChecked()) {
+                newCheckBox.check();
+            } else {
+                newCheckBox.unCheck();
+            }
+
+        } catch (Exception e) {
+            log.warn(
+                    "Failed to create checkbox field '{}': {}",
+                    sourceField.getPartialName(),
+                    e.getMessage(),
+                    e);
+        }
+    }
+
+    private static void createSimpleRadioButtonField(
+            PDAcroForm newAcroForm,
+            PDPage destinationPage,
+            List<PDAnnotation> destinationAnnotations,
+            PDRadioButton sourceField,
+            PDAnnotationWidget sourceWidget,
+            float offsetX,
+            float offsetY,
+            float scale,
+            int pageIndex,
+            Map<String, Integer> fieldNameCounters) {
+
+        try {
+            PDRadioButton newRadioButton = new PDRadioButton(newAcroForm);
+
+            boolean initialized =
+                    initializeFieldWithWidget(
+                            newAcroForm,
+                            destinationPage,
+                            destinationAnnotations,
+                            newRadioButton,
+                            sourceField.getPartialName(),
+                            "radioButton",
+                            sourceWidget,
+                            offsetX,
+                            offsetY,
+                            scale,
+                            pageIndex,
+                            fieldNameCounters);
+
+            if (!initialized) {
+                return;
+            }
+
+            if (sourceField.getExportValues() != null) {
+                newRadioButton.setExportValues(sourceField.getExportValues());
+            }
+            if (sourceField.getValue() != null) {
+                newRadioButton.setValue(sourceField.getValue());
+            }
+        } catch (Exception e) {
+            log.warn(
+                    "Failed to create radio button field '{}': {}",
+                    sourceField.getPartialName(),
+                    e.getMessage(),
+                    e);
+        }
+    }
+
+    private static void createSimpleComboBoxField(
+            PDAcroForm newAcroForm,
+            PDPage destinationPage,
+            List<PDAnnotation> destinationAnnotations,
+            PDComboBox sourceField,
+            PDAnnotationWidget sourceWidget,
+            float offsetX,
+            float offsetY,
+            float scale,
+            int pageIndex,
+            Map<String, Integer> fieldNameCounters) {
+
+        try {
+            PDComboBox newComboBox = new PDComboBox(newAcroForm);
+
+            boolean initialized =
+                    initializeFieldWithWidget(
+                            newAcroForm,
+                            destinationPage,
+                            destinationAnnotations,
+                            newComboBox,
+                            sourceField.getPartialName(),
+                            "comboBox",
+                            sourceWidget,
+                            offsetX,
+                            offsetY,
+                            scale,
+                            pageIndex,
+                            fieldNameCounters);
+
+            if (!initialized) {
+                return;
+            }
+
+            if (sourceField.getOptions() != null) {
+                newComboBox.setOptions(sourceField.getOptions());
+            }
+            if (sourceField.getValue() != null && !sourceField.getValue().isEmpty()) {
+                newComboBox.setValue(sourceField.getValue());
+            }
+        } catch (Exception e) {
+            log.warn(
+                    "Failed to create combo box field '{}': {}",
+                    sourceField.getPartialName(),
+                    e.getMessage(),
+                    e);
+        }
+    }
+
+    private static void createSimpleListBoxField(
+            PDAcroForm newAcroForm,
+            PDPage destinationPage,
+            List<PDAnnotation> destinationAnnotations,
+            PDListBox sourceField,
+            PDAnnotationWidget sourceWidget,
+            float offsetX,
+            float offsetY,
+            float scale,
+            int pageIndex,
+            Map<String, Integer> fieldNameCounters) {
+
+        try {
+            PDListBox newListBox = new PDListBox(newAcroForm);
+
+            boolean initialized =
+                    initializeFieldWithWidget(
+                            newAcroForm,
+                            destinationPage,
+                            destinationAnnotations,
+                            newListBox,
+                            sourceField.getPartialName(),
+                            "listBox",
+                            sourceWidget,
+                            offsetX,
+                            offsetY,
+                            scale,
+                            pageIndex,
+                            fieldNameCounters);
+
+            if (!initialized) {
+                return;
+            }
+
+            if (sourceField.getOptions() != null) {
+                newListBox.setOptions(sourceField.getOptions());
+            }
+            if (sourceField.getValue() != null && !sourceField.getValue().isEmpty()) {
+                newListBox.setValue(sourceField.getValue());
+            }
+        } catch (Exception e) {
+            log.warn(
+                    "Failed to create list box field '{}': {}",
+                    sourceField.getPartialName(),
+                    e.getMessage(),
+                    e);
+        }
+    }
+
+    private static void createSimpleSignatureField(
+            PDAcroForm newAcroForm,
+            PDPage destinationPage,
+            List<PDAnnotation> destinationAnnotations,
+            PDSignatureField sourceField,
+            PDAnnotationWidget sourceWidget,
+            float offsetX,
+            float offsetY,
+            float scale,
+            int pageIndex,
+            Map<String, Integer> fieldNameCounters) {
+
+        try {
+            PDSignatureField newSignatureField = new PDSignatureField(newAcroForm);
+
+            boolean initialized =
+                    initializeFieldWithWidget(
+                            newAcroForm,
+                            destinationPage,
+                            destinationAnnotations,
+                            newSignatureField,
+                            sourceField.getPartialName(),
+                            "signature",
+                            sourceWidget,
+                            offsetX,
+                            offsetY,
+                            scale,
+                            pageIndex,
+                            fieldNameCounters);
+
+            if (!initialized) {
+                return;
+            }
+        } catch (Exception e) {
+            log.warn(
+                    "Failed to create signature field '{}': {}",
+                    sourceField.getPartialName(),
+                    e.getMessage(),
+                    e);
+        }
+    }
+
+    private static void createSimplePushButtonField(
+            PDAcroForm newAcroForm,
+            PDPage destinationPage,
+            List<PDAnnotation> destinationAnnotations,
+            PDPushButton sourceField,
+            PDAnnotationWidget sourceWidget,
+            float offsetX,
+            float offsetY,
+            float scale,
+            int pageIndex,
+            Map<String, Integer> fieldNameCounters) {
+
+        try {
+            PDPushButton newPushButton = new PDPushButton(newAcroForm);
+
+            boolean initialized =
+                    initializeFieldWithWidget(
+                            newAcroForm,
+                            destinationPage,
+                            destinationAnnotations,
+                            newPushButton,
+                            sourceField.getPartialName(),
+                            "pushButton",
+                            sourceWidget,
+                            offsetX,
+                            offsetY,
+                            scale,
+                            pageIndex,
+                            fieldNameCounters);
+
+        } catch (Exception e) {
+            log.warn(
+                    "Failed to create push button field '{}': {}",
+                    sourceField.getPartialName(),
+                    e.getMessage(),
+                    e);
+        }
+    }
+
+    private static <T extends PDTerminalField> boolean initializeFieldWithWidget(
+            PDAcroForm newAcroForm,
+            PDPage destinationPage,
+            List<PDAnnotation> destinationAnnotations,
+            T newField,
+            String originalName,
+            String fallbackName,
+            PDAnnotationWidget sourceWidget,
+            float offsetX,
+            float offsetY,
+            float scale,
+            int pageIndex,
+            Map<String, Integer> fieldNameCounters) {
+
+        String baseName = (originalName != null) ? originalName : fallbackName;
+        String newFieldName = generateUniqueFieldName(baseName, pageIndex, fieldNameCounters);
+        newField.setPartialName(newFieldName);
+
+        PDAnnotationWidget newWidget = new PDAnnotationWidget();
+        PDRectangle sourceRect = sourceWidget.getRectangle();
+        if (sourceRect == null) {
+            return false;
+        }
+
+        float newX = (sourceRect.getLowerLeftX() * scale) + offsetX;
+        float newY = (sourceRect.getLowerLeftY() * scale) + offsetY;
+        float newWidth = sourceRect.getWidth() * scale;
+        float newHeight = sourceRect.getHeight() * scale;
+        newWidget.setRectangle(new PDRectangle(newX, newY, newWidth, newHeight));
+        newWidget.setPage(destinationPage);
+
+        newField.getWidgets().add(newWidget);
+        newWidget.setParent(newField);
+        newAcroForm.getFields().add(newField);
+        destinationAnnotations.add(newWidget);
+        return true;
+    }
+
+    private static String generateUniqueFieldName(
+            String originalName, int pageIndex, Map<String, Integer> fieldNameCounters) {
+        String baseName = "page" + pageIndex + "_" + originalName;
+
+        Integer counter = fieldNameCounters.get(baseName);
+        if (counter == null) {
+            counter = 0;
+        } else {
+            counter++;
+        }
+        fieldNameCounters.put(baseName, counter);
+
+        return counter == 0 ? baseName : baseName + "_" + counter;
+    }
+
+    private static Map<PDAnnotationWidget, PDField> buildWidgetFieldMap(PDAcroForm acroForm) {
+        Map<PDAnnotationWidget, PDField> map = new HashMap<>();
+        if (acroForm == null) {
+            return map;
+        }
+        try {
+            for (PDField field : acroForm.getFieldTree()) {
+                List<PDAnnotationWidget> widgets = field.getWidgets();
+                if (widgets != null) {
+                    for (PDAnnotationWidget w : widgets) {
+                        if (w != null) {
+                            map.put(w, field);
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            log.warn("Failed to build widget->field map: {}", e.getMessage(), e);
+        }
+        return map;
+    }
+}

app/common/src/main/java/stirling/software/common/util/GeneralUtils.java

@@ -38,7 +38,6 @@ public class GeneralUtils {
             Set.of(
                     "OCR images.json",
                     "Prepare-pdfs-for-email.json",
-                    "Pre-publish-sanitization.json",
                     "split-rotate-auto-rename.json");
 
     private final String DEFAULT_WEBUI_CONFIGS_DIR = "defaultWebUIConfigs";

app/common/src/main/java/stirling/software/common/util/JobContext.java

@@ -1,18 +0,0 @@
-package stirling.software.common.util;
-
-/** Thread-local context for passing job ID across async boundaries */
-public class JobContext {
-    private static final ThreadLocal<String> CURRENT_JOB_ID = new ThreadLocal<>();
-
-    public static void setJobId(String jobId) {
-        CURRENT_JOB_ID.set(jobId);
-    }
-
-    public static String getJobId() {
-        return CURRENT_JOB_ID.get();
-    }
-
-    public static void clear() {
-        CURRENT_JOB_ID.remove();
-    }
-}

app/common/src/main/java/stirling/software/common/util/ProcessExecutor.java

@@ -96,7 +96,6 @@ public class ProcessExecutor {
                                                 .getProcessExecutor()
                                                 .getSessionLimit()
                                                 .getOcrMyPdfSessionLimit();
-                                case CFF_CONVERTER -> 1;
                             };
 
                     long timeoutMinutes =
@@ -151,7 +150,6 @@ public class ProcessExecutor {
                                                 .getProcessExecutor()
                                                 .getTimeoutMinutes()
                                                 .getOcrMyPdfTimeoutMinutes();
-                                case CFF_CONVERTER -> 5L;
                             };
                     return new ProcessExecutor(semaphoreLimit, liveUpdates, timeoutMinutes);
                 });
@@ -304,8 +302,7 @@ public class ProcessExecutor {
         TESSERACT,
         QPDF,
         GHOSTSCRIPT,
-        OCR_MY_PDF,
-        CFF_CONVERTER
+        OCR_MY_PDF
     }
 
     @Setter

app/common/src/main/java/stirling/software/common/util/RegexPatternUtils.java

@@ -1,6 +1,5 @@
 package stirling.software.common.util;
 
-import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
@@ -242,11 +241,6 @@ public final class RegexPatternUtils {
         return getPattern("\\s+");
     }
 
-    /** Pattern for matching punctuation characters */
-    public Pattern getPunctuationPattern() {
-        return getPattern("[\\p{Punct}]+");
-    }
-
     /** Pattern for matching newlines (Windows and Unix style) */
     public Pattern getNewlinesPattern() {
         return getPattern("\\r?\\n");
@@ -292,24 +286,6 @@ public final class RegexPatternUtils {
         return getPattern("[^a-zA-Z0-9 ]");
     }
 
-    /** Pattern for removing bracketed indices like [0], [Child], etc. in field names */
-    public Pattern getFormFieldBracketPattern() {
-        return getPattern("\\[[^\\]]*\\]");
-    }
-
-    /** Pattern that replaces underscores or hyphens with spaces */
-    public Pattern getUnderscoreHyphenPattern() {
-        return getPattern("[-_]+");
-    }
-
-    /**
-     * Pattern that matches camelCase or alpha-numeric boundaries to allow inserting spaces.
-     * Examples: firstName -> first Name, field1 -> field 1, A5Size -> A5 Size
-     */
-    public Pattern getCamelCaseBoundaryPattern() {
-        return getPattern("(?<=[a-z])(?=[A-Z])|(?<=[A-Za-z])(?=\\d)|(?<=\\d)(?=[A-Za-z])");
-    }
-
     /** Pattern for removing angle brackets */
     public Pattern getAngleBracketsPattern() {
         return getPattern("[<>]");
@@ -359,26 +335,6 @@ public final class RegexPatternUtils {
         return getPattern("[1-9][0-9]{0,2}");
     }
 
-    /**
-     * Pattern for very simple generic field tokens such as "field", "text", "checkbox" with
-     * optional numeric suffix (e.g. "field 1"). Case-insensitive.
-     */
-    public Pattern getGenericFieldNamePattern() {
-        return getPattern(
-                "^(field|text|checkbox|radio|button|signature|name|value|option|select|choice)(\\s*\\d+)?$",
-                Pattern.CASE_INSENSITIVE);
-    }
-
-    /** Pattern for short identifiers like t1, f2, a10 etc. */
-    public Pattern getSimpleFormFieldPattern() {
-        return getPattern("^[A-Za-z]{1,2}\\s*\\d{1,3}$");
-    }
-
-    /** Pattern for optional leading 't' followed by digits, e.g., t1, 1, t 12. */
-    public Pattern getOptionalTNumericPattern() {
-        return getPattern("^(?:t\\s*)?\\d+$", Pattern.CASE_INSENSITIVE);
-    }
-
     /** Pattern for validating mathematical expressions */
     public Pattern getMathExpressionPattern() {
         return getPattern("[0-9n+\\-*/() ]+");
@@ -511,11 +467,6 @@ public final class RegexPatternUtils {
         return getPattern("/");
     }
 
-    /** Supported logical types when creating new fields programmatically */
-    public Set<String> getSupportedNewFieldTypes() {
-        return Set.of("text", "checkbox", "combobox", "listbox", "radio", "button", "signature");
-    }
-
     /**
      * Pre-compile commonly used patterns for immediate availability. This eliminates first-call
      * compilation overhead for frequent patterns.

app/common/src/main/java/stirling/software/common/util/RequestUriUtils.java

@@ -49,38 +49,4 @@ public class RequestUriUtils {
                 || requestURI.startsWith("/fonts")
                 || requestURI.startsWith("/pdfjs"));
     }
-
-    /**
-     * Checks if the request URI is a public authentication endpoint that doesn't require
-     * authentication. This includes login, signup, OAuth callbacks, and public config endpoints.
-     *
-     * @param requestURI The full request URI
-     * @param contextPath The servlet context path
-     * @return true if the endpoint is public and doesn't require authentication
-     */
-    public static boolean isPublicAuthEndpoint(String requestURI, String contextPath) {
-        // Remove context path from URI to normalize path matching
-        String trimmedUri =
-                requestURI.startsWith(contextPath)
-                        ? requestURI.substring(contextPath.length())
-                        : requestURI;
-
-        // Public auth endpoints that don't require authentication
-        return trimmedUri.startsWith("/login")
-                || trimmedUri.startsWith("/auth/")
-                || trimmedUri.startsWith("/oauth2")
-                || trimmedUri.startsWith("/saml2")
-                || trimmedUri.contains("/login/oauth2/code/") // Spring Security OAuth2 callback
-                || trimmedUri.contains("/oauth2/authorization/") // OAuth2 authorization endpoint
-                || trimmedUri.startsWith("/api/v1/auth/login")
-                || trimmedUri.startsWith("/api/v1/auth/refresh")
-                || trimmedUri.startsWith("/api/v1/auth/logout")
-                || trimmedUri.startsWith(
-                        "/api/v1/proprietary/ui-data/login") // Login page config (SSO providers +
-                // enableLogin)
-                || trimmedUri.startsWith("/v1/api-docs")
-                || trimmedUri.startsWith("/api/v1/invite/validate")
-                || trimmedUri.startsWith("/api/v1/invite/accept")
-                || trimmedUri.contains("/v1/api-docs");
-    }
 }

app/common/src/test/java/stirling/software/common/service/JobExecutorServiceTest.java

@@ -78,23 +78,6 @@ class JobExecutorServiceTest {
         verify(request).setAttribute(eq("jobId"), anyString());
     }
 
-    @Test
-    void shouldExposeJobIdInJobContextDuringSyncExecution() throws Exception {
-        // Given
-        Supplier<Object> work = stirling.software.common.util.JobContext::getJobId;
-
-        // When
-        ResponseEntity<?> response = jobExecutorService.runJobGeneric(false, work);
-
-        // Then
-        assertEquals(HttpStatus.OK, response.getStatusCode());
-        assertNotNull(response.getBody());
-
-        var requestJobIdCaptor = ArgumentCaptor.forClass(String.class);
-        verify(request).setAttribute(eq("jobId"), requestJobIdCaptor.capture());
-        assertEquals(requestJobIdCaptor.getValue(), response.getBody());
-    }
-
     @Test
     void shouldRunAsyncJobSuccessfully() throws Exception {
         // Given

app/core/build.gradle

@@ -41,6 +41,7 @@ dependencies {
     if (System.getenv('STIRLING_PDF_DESKTOP_UI') != 'false'
         || (project.hasProperty('STIRLING_PDF_DESKTOP_UI')
         && project.getProperty('STIRLING_PDF_DESKTOP_UI') != 'false')) {
+        implementation 'me.friwi:jcefmaven:132.3.1'
         implementation 'org.openjfx:javafx-controls:21'
         implementation 'org.openjfx:javafx-swing:21'
     }

app/core/src/main/java/stirling/software/SPDF/Factories/ReplaceAndInvertColorFactory.java

@@ -5,7 +5,6 @@ import org.springframework.web.multipart.MultipartFile;
 
 import lombok.RequiredArgsConstructor;
 
-import stirling.software.SPDF.config.EndpointConfiguration;
 import stirling.software.common.model.api.misc.HighContrastColorCombination;
 import stirling.software.common.model.api.misc.ReplaceAndInvert;
 import stirling.software.common.util.TempFileManager;
@@ -19,7 +18,6 @@ import stirling.software.common.util.misc.ReplaceAndInvertColorStrategy;
 public class ReplaceAndInvertColorFactory {
 
     private final TempFileManager tempFileManager;
-    private final EndpointConfiguration endpointConfiguration;
 
     public ReplaceAndInvertColorStrategy replaceAndInvert(
             MultipartFile file,
@@ -28,13 +26,6 @@ public class ReplaceAndInvertColorFactory {
             String backGroundColor,
             String textColor) {
 
-        // Check Ghostscript availability for CMYK conversion
-        if (replaceAndInvertOption == ReplaceAndInvert.COLOR_SPACE_CONVERSION
-                && !endpointConfiguration.isGroupEnabled("Ghostscript")) {
-            throw new IllegalStateException(
-                    "CMYK color space conversion requires Ghostscript, which is not available on this system");
-        }
-
         return switch (replaceAndInvertOption) {
             case CUSTOM_COLOR, HIGH_CONTRAST_COLOR ->
                     new CustomColorReplaceStrategy(

app/core/src/main/java/stirling/software/SPDF/SPDFApplication.java

@@ -12,8 +12,6 @@ import java.util.Properties;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.boot.web.context.WebServerInitializedEvent;
-import org.springframework.context.event.EventListener;
 import org.springframework.core.env.Environment;
 import org.springframework.scheduling.annotation.EnableScheduling;
 
@@ -146,13 +144,6 @@ public class SPDFApplication {
         serverPortStatic = serverPort;
         String url = baseUrl + ":" + getStaticPort() + contextPath;
 
-        // Log Tauri mode information
-        if (Boolean.parseBoolean(System.getProperty("STIRLING_PDF_TAURI_MODE", "false"))) {
-            String parentPid = System.getenv("TAURI_PARENT_PID");
-            log.info(
-                    "Running in Tauri mode. Parent process PID: {}",
-                    parentPid != null ? parentPid : "not set");
-        }
         // Desktop UI initialization removed - webBrowser dependency eliminated
         // Keep backwards compatibility for STIRLING_PDF_DESKTOP_UI system property
         if (Boolean.parseBoolean(System.getProperty("STIRLING_PDF_DESKTOP_UI", "false"))) {
@@ -200,14 +191,6 @@ public class SPDFApplication {
         // }
     }
 
-    @EventListener
-    public void onWebServerInitialized(WebServerInitializedEvent event) {
-        int actualPort = event.getWebServer().getPort();
-        serverPortStatic = String.valueOf(actualPort);
-        // Log the actual runtime port for Tauri to parse
-        log.info("Stirling-PDF running on port: {}", actualPort);
-    }
-
     private static void printStartupLogs() {
         log.info("Stirling-PDF Started.");
         String url = baseUrlStatic + ":" + getStaticPort() + contextPathStatic;

app/core/src/main/java/stirling/software/SPDF/config/EndpointConfiguration.java

@@ -18,37 +18,11 @@ import stirling.software.common.model.ApplicationProperties;
 @Slf4j
 public class EndpointConfiguration {
 
-    public enum DisableReason {
-        CONFIG,
-        DEPENDENCY,
-        UNKNOWN
-    }
-
-    public static class EndpointAvailability {
-        private final boolean enabled;
-        private final DisableReason reason;
-
-        public EndpointAvailability(boolean enabled, DisableReason reason) {
-            this.enabled = enabled;
-            this.reason = reason;
-        }
-
-        public boolean isEnabled() {
-            return enabled;
-        }
-
-        public DisableReason getReason() {
-            return reason;
-        }
-    }
-
     private static final String REMOVE_BLANKS = "remove-blanks";
     private final ApplicationProperties applicationProperties;
     @Getter private Map<String, Boolean> endpointStatuses = new ConcurrentHashMap<>();
     private Map<String, Set<String>> endpointGroups = new ConcurrentHashMap<>();
     private Set<String> disabledGroups = new HashSet<>();
-    private Map<String, DisableReason> endpointDisableReasons = new ConcurrentHashMap<>();
-    private Map<String, DisableReason> groupDisableReasons = new ConcurrentHashMap<>();
     private Map<String, Set<String>> endpointAlternatives = new ConcurrentHashMap<>();
     private final boolean runningProOrHigher;
 
@@ -61,31 +35,16 @@ public class EndpointConfiguration {
         processEnvironmentConfigs();
     }
 
-    private String normalizeEndpoint(String endpoint) {
-        if (endpoint == null) {
-            return null;
-        }
-        return endpoint.startsWith("/") ? endpoint.substring(1) : endpoint;
-    }
-
     public void enableEndpoint(String endpoint) {
-        String normalized = normalizeEndpoint(endpoint);
-        endpointStatuses.put(normalized, true);
-        endpointDisableReasons.remove(normalized);
-        log.debug("Enabled endpoint: {}", normalized);
+        endpointStatuses.put(endpoint, true);
+        log.debug("Enabled endpoint: {}", endpoint);
     }
 
     public void disableEndpoint(String endpoint) {
-        disableEndpoint(endpoint, DisableReason.CONFIG);
-    }
-
-    public void disableEndpoint(String endpoint, DisableReason reason) {
-        String normalized = normalizeEndpoint(endpoint);
-        if (!Boolean.FALSE.equals(endpointStatuses.get(normalized))) {
-            log.debug("Disabling endpoint: {}", normalized);
+        if (!Boolean.FALSE.equals(endpointStatuses.get(endpoint))) {
+            log.debug("Disabling endpoint: {}", endpoint);
         }
-        endpointStatuses.put(normalized, false);
-        endpointDisableReasons.put(normalized, reason);
+        endpointStatuses.put(endpoint, false);
     }
 
     public boolean isEndpointEnabled(String endpoint) {
@@ -191,10 +150,6 @@ public class EndpointConfiguration {
     }
 
     public void disableGroup(String group) {
-        disableGroup(group, DisableReason.CONFIG);
-    }
-
-    public void disableGroup(String group, DisableReason reason) {
         if (disabledGroups.add(group)) {
             if (isToolGroup(group)) {
                 log.debug(
@@ -206,12 +161,11 @@ public class EndpointConfiguration {
                         group);
             }
         }
-        groupDisableReasons.put(group, reason);
         // Only cascade to endpoints for *functional* groups
         if (!isToolGroup(group)) {
             Set<String> endpoints = endpointGroups.get(group);
             if (endpoints != null) {
-                endpoints.forEach(endpoint -> disableEndpoint(endpoint, reason));
+                endpoints.forEach(this::disableEndpoint);
             }
         }
     }
@@ -220,39 +174,12 @@ public class EndpointConfiguration {
         if (disabledGroups.remove(group)) {
             log.debug("Enabling group: {}", group);
         }
-        groupDisableReasons.remove(group);
         Set<String> endpoints = endpointGroups.get(group);
         if (endpoints != null) {
             endpoints.forEach(this::enableEndpoint);
         }
     }
 
-    public EndpointAvailability getEndpointAvailability(String endpoint) {
-        boolean enabled = isEndpointEnabled(endpoint);
-        DisableReason reason = enabled ? null : determineDisableReason(endpoint);
-        return new EndpointAvailability(enabled, reason);
-    }
-
-    private DisableReason determineDisableReason(String endpoint) {
-        String normalized = normalizeEndpoint(endpoint);
-        if (Boolean.FALSE.equals(endpointStatuses.get(normalized))) {
-            return endpointDisableReasons.getOrDefault(normalized, DisableReason.CONFIG);
-        }
-
-        for (Map.Entry<String, Set<String>> entry : endpointGroups.entrySet()) {
-            String group = entry.getKey();
-            Set<String> endpoints = entry.getValue();
-            if (!disabledGroups.contains(group) || endpoints == null) {
-                continue;
-            }
-            if (endpoints.contains(normalized)) {
-                return groupDisableReasons.getOrDefault(group, DisableReason.CONFIG);
-            }
-        }
-
-        return DisableReason.UNKNOWN;
-    }
-
     public Set<String> getDisabledGroups() {
         return new HashSet<>(disabledGroups);
     }
@@ -334,10 +261,6 @@ public class EndpointConfiguration {
         addEndpointToGroup("Convert", "pdf-to-csv");
         addEndpointToGroup("Convert", "pdf-to-markdown");
         addEndpointToGroup("Convert", "eml-to-pdf");
-        addEndpointToGroup("Convert", "cbz-to-pdf");
-        addEndpointToGroup("Convert", "pdf-to-cbz");
-        addEndpointToGroup("Convert", "pdf-to-json");
-        addEndpointToGroup("Convert", "json-to-pdf");
 
         // Adding endpoints to "Security" group
         addEndpointToGroup("Security", "add-password");
@@ -371,12 +294,6 @@ public class EndpointConfiguration {
         addEndpointToGroup("Other", "replace-and-invert-color-pdf");
         addEndpointToGroup("Other", "multi-tool");
 
-        // Adding form-related endpoints to "Other" group
-        addEndpointToGroup("Other", "fields");
-        addEndpointToGroup("Other", "modify-fields");
-        addEndpointToGroup("Other", "delete-fields");
-        addEndpointToGroup("Other", "fill");
-
         // Adding endpoints to "Advance" group
         addEndpointToGroup("Advance", "adjust-contrast");
         addEndpointToGroup("Advance", "compress-pdf");
@@ -471,10 +388,6 @@ public class EndpointConfiguration {
         addEndpointToGroup("Java", "pdf-to-markdown");
         addEndpointToGroup("Java", "add-attachments");
         addEndpointToGroup("Java", "compress-pdf");
-        addEndpointToGroup("Java", "cbz-to-pdf");
-        addEndpointToGroup("Java", "pdf-to-cbz");
-        addEndpointToGroup("Java", "pdf-to-json");
-        addEndpointToGroup("Java", "json-to-pdf");
         addEndpointToGroup("rar", "pdf-to-cbr");
 
         // Javascript
@@ -490,6 +403,8 @@ public class EndpointConfiguration {
         /* Ghostscript */
         addEndpointToGroup("Ghostscript", "repair");
         addEndpointToGroup("Ghostscript", "compress-pdf");
+        addEndpointToGroup("Ghostscript", "crop");
+        addEndpointToGroup("Ghostscript", "replace-invert-pdf");
 
         /* tesseract */
         addEndpointToGroup("tesseract", "ocr-pdf");

app/core/src/main/java/stirling/software/SPDF/config/ExternalAppDepConfig.java

@@ -12,7 +12,6 @@ import jakarta.annotation.PostConstruct;
 
 import lombok.extern.slf4j.Slf4j;
 
-import stirling.software.SPDF.config.EndpointConfiguration.DisableReason;
 import stirling.software.common.configuration.RuntimePathConfig;
 import stirling.software.common.util.RegexPatternUtils;
 
@@ -25,7 +24,6 @@ public class ExternalAppDepConfig {
     private final String weasyprintPath;
     private final String unoconvPath;
     private final Map<String, List<String>> commandToGroupMapping;
-    private volatile boolean dependenciesChecked = false;
 
     public ExternalAppDepConfig(
             EndpointConfiguration endpointConfiguration, RuntimePathConfig runtimePathConfig) {
@@ -99,7 +97,7 @@ public class ExternalAppDepConfig {
             if (affectedGroups != null) {
                 for (String group : affectedGroups) {
                     List<String> affectedFeatures = getAffectedFeatures(group);
-                    endpointConfiguration.disableGroup(group, DisableReason.DEPENDENCY);
+                    endpointConfiguration.disableGroup(group);
                     log.warn(
                             "Missing dependency: {} - Disabling group: {} (Affected features: {})",
                             command,
@@ -112,10 +110,6 @@ public class ExternalAppDepConfig {
         }
     }
 
-    public boolean isDependenciesChecked() {
-        return dependenciesChecked;
-    }
-
     @PostConstruct
     public void checkDependencies() {
         // Check core dependencies
@@ -133,8 +127,8 @@ public class ExternalAppDepConfig {
         if (!pythonAvailable) {
             List<String> pythonFeatures = getAffectedFeatures("Python");
             List<String> openCVFeatures = getAffectedFeatures("OpenCV");
-            endpointConfiguration.disableGroup("Python", DisableReason.DEPENDENCY);
-            endpointConfiguration.disableGroup("OpenCV", DisableReason.DEPENDENCY);
+            endpointConfiguration.disableGroup("Python");
+            endpointConfiguration.disableGroup("OpenCV");
             log.warn(
                     "Missing dependency: Python - Disabling Python features: {} and OpenCV features: {}",
                     String.join(", ", pythonFeatures),
@@ -152,14 +146,14 @@ public class ExternalAppDepConfig {
                 int exitCode = process.waitFor();
                 if (exitCode != 0) {
                     List<String> openCVFeatures = getAffectedFeatures("OpenCV");
-                    endpointConfiguration.disableGroup("OpenCV", DisableReason.DEPENDENCY);
+                    endpointConfiguration.disableGroup("OpenCV");
                     log.warn(
                             "OpenCV not available in Python - Disabling OpenCV features: {}",
                             String.join(", ", openCVFeatures));
                 }
             } catch (Exception e) {
                 List<String> openCVFeatures = getAffectedFeatures("OpenCV");
-                endpointConfiguration.disableGroup("OpenCV", DisableReason.DEPENDENCY);
+                endpointConfiguration.disableGroup("OpenCV");
                 log.warn(
                         "Error checking OpenCV: {} - Disabling OpenCV features: {}",
                         e.getMessage(),
@@ -167,7 +161,5 @@ public class ExternalAppDepConfig {
             }
         }
         endpointConfiguration.logDisabledEndpointsSummary();
-        dependenciesChecked = true;
-        log.info("Dependency checks completed");
     }
 }

app/core/src/main/java/stirling/software/SPDF/config/InitialSetup.java

@@ -28,8 +28,6 @@ public class InitialSetup {
 
     private final ApplicationProperties applicationProperties;
 
-    private static boolean isNewServer = false;
-
     @PostConstruct
     public void init() throws IOException {
         initUUIDKey();
@@ -90,13 +88,6 @@ public class InitialSetup {
     }
 
     public void initSetAppVersion() throws IOException {
-        // Check if this is a new server before setting the version
-        String existingVersion = applicationProperties.getAutomaticallyGenerated().getAppVersion();
-        isNewServer =
-                existingVersion == null
-                        || existingVersion.isEmpty()
-                        || existingVersion.equals("0.0.0");
-
         String appVersion = "0.0.0";
         Resource resource = new ClassPathResource("version.properties");
         Properties props = new Properties();
@@ -108,8 +99,4 @@ public class InitialSetup {
         GeneralUtils.saveKeyToSettings("AutomaticallyGenerated.appVersion", appVersion);
         applicationProperties.getAutomaticallyGenerated().setAppVersion(appVersion);
     }
-
-    public static boolean isNewServer() {
-        return isNewServer;
-    }
 }

app/core/src/main/java/stirling/software/SPDF/config/TauriProcessMonitor.java

@@ -1,157 +0,0 @@
-package stirling.software.SPDF.config;
-
-import java.lang.management.ManagementFactory;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.ConfigurableApplicationContext;
-import org.springframework.stereotype.Component;
-
-import jakarta.annotation.PostConstruct;
-import jakarta.annotation.PreDestroy;
-
-/**
- * Monitor for Tauri parent process to detect orphaned Java backend processes. When running in Tauri
- * mode, this component periodically checks if the parent Tauri process is still alive. If the
- * parent process terminates unexpectedly, this will trigger a graceful shutdown of the Java backend
- * to prevent orphaned processes.
- */
-@Component
-@ConditionalOnProperty(name = "STIRLING_PDF_TAURI_MODE", havingValue = "true")
-public class TauriProcessMonitor {
-
-    private static final Logger logger = LoggerFactory.getLogger(TauriProcessMonitor.class);
-
-    private final ApplicationContext applicationContext;
-    private String parentProcessId;
-    private ScheduledExecutorService scheduler;
-    private volatile boolean monitoring = false;
-
-    public TauriProcessMonitor(ApplicationContext applicationContext) {
-        this.applicationContext = applicationContext;
-    }
-
-    @PostConstruct
-    public void init() {
-        parentProcessId = System.getenv("TAURI_PARENT_PID");
-
-        if (parentProcessId != null && !parentProcessId.trim().isEmpty()) {
-            logger.info("Tauri mode detected. Parent process ID: {}", parentProcessId);
-            startMonitoring();
-        } else {
-            logger.warn(
-                    "TAURI_PARENT_PID environment variable not found. Tauri process monitoring disabled.");
-        }
-    }
-
-    private void startMonitoring() {
-        scheduler =
-                Executors.newSingleThreadScheduledExecutor(
-                        r -> {
-                            Thread t = new Thread(r, "tauri-process-monitor");
-                            t.setDaemon(true);
-                            return t;
-                        });
-
-        monitoring = true;
-
-        // Check every 5 seconds
-        scheduler.scheduleAtFixedRate(this::checkParentProcess, 5, 5, TimeUnit.SECONDS);
-
-        logger.info("Started monitoring parent Tauri process (PID: {})", parentProcessId);
-    }
-
-    private void checkParentProcess() {
-        if (!monitoring) {
-            return;
-        }
-
-        try {
-            if (!isProcessAlive(parentProcessId)) {
-                logger.warn(
-                        "Parent Tauri process (PID: {}) is no longer alive. Initiating graceful shutdown...",
-                        parentProcessId);
-                initiateGracefulShutdown();
-            }
-        } catch (Exception e) {
-            logger.error("Error checking parent process status", e);
-        }
-    }
-
-    private boolean isProcessAlive(String pid) {
-        try {
-            long processId = Long.parseLong(pid);
-
-            // Check if process exists using ProcessHandle (Java 9+)
-            return ProcessHandle.of(processId).isPresent();
-
-        } catch (NumberFormatException e) {
-            logger.error("Invalid parent process ID format: {}", pid);
-            return false;
-        } catch (Exception e) {
-            logger.error("Error checking if process {} is alive", pid, e);
-            return false;
-        }
-    }
-
-    private void initiateGracefulShutdown() {
-        monitoring = false;
-
-        logger.info("Orphaned Java backend detected. Shutting down gracefully...");
-
-        // Shutdown asynchronously to avoid blocking the monitor thread
-        CompletableFuture.runAsync(
-                () -> {
-                    try {
-                        // Give a small delay to ensure logging completes
-                        Thread.sleep(1000);
-
-                        if (applicationContext instanceof ConfigurableApplicationContext) {
-                            ((ConfigurableApplicationContext) applicationContext).close();
-                        } else {
-                            // Fallback to system exit
-                            logger.warn(
-                                    "Unable to shutdown Spring context gracefully, using System.exit");
-                            System.exit(0);
-                        }
-                    } catch (Exception e) {
-                        logger.error("Error during graceful shutdown", e);
-                        System.exit(1);
-                    }
-                });
-    }
-
-    @PreDestroy
-    public void cleanup() {
-        monitoring = false;
-
-        if (scheduler != null && !scheduler.isShutdown()) {
-            logger.info("Shutting down Tauri process monitor");
-            scheduler.shutdown();
-
-            try {
-                if (!scheduler.awaitTermination(2, TimeUnit.SECONDS)) {
-                    scheduler.shutdownNow();
-                }
-            } catch (InterruptedException e) {
-                scheduler.shutdownNow();
-                Thread.currentThread().interrupt();
-            }
-        }
-    }
-
-    /** Get the current Java process ID for logging/debugging purposes */
-    public static String getCurrentProcessId() {
-        try {
-            return ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
-        } catch (Exception e) {
-            return "unknown";
-        }
-    }
-}

app/core/src/main/java/stirling/software/SPDF/config/WAUTrackingFilter.java

@@ -1,49 +0,0 @@
-package stirling.software.SPDF.config;
-
-import java.io.IOException;
-
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.stereotype.Component;
-
-import jakarta.servlet.Filter;
-import jakarta.servlet.FilterChain;
-import jakarta.servlet.ServletException;
-import jakarta.servlet.ServletRequest;
-import jakarta.servlet.ServletResponse;
-import jakarta.servlet.http.HttpServletRequest;
-
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-
-import stirling.software.SPDF.service.WeeklyActiveUsersService;
-
-/**
- * Filter to track browser IDs for Weekly Active Users (WAU) counting. Only active when security is
- * disabled (no-login mode).
- */
-@Component
-@ConditionalOnProperty(name = "security.enableLogin", havingValue = "false")
-@RequiredArgsConstructor
-@Slf4j
-public class WAUTrackingFilter implements Filter {
-
-    private final WeeklyActiveUsersService wauService;
-
-    @Override
-    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
-            throws IOException, ServletException {
-
-        if (request instanceof HttpServletRequest httpRequest) {
-            // Extract browser ID from header
-            String browserId = httpRequest.getHeader("X-Browser-Id");
-
-            if (browserId != null && !browserId.trim().isEmpty()) {
-                // Record browser access
-                wauService.recordBrowserAccess(browserId);
-            }
-        }
-
-        // Continue the filter chain
-        chain.doFilter(request, response);
-    }
-}

app/core/src/main/java/stirling/software/SPDF/config/WebMvcConfig.java

@@ -1,7 +1,5 @@
 package stirling.software.SPDF.config;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.CorsRegistry;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
@@ -18,8 +16,6 @@ public class WebMvcConfig implements WebMvcConfigurer {
     private final EndpointInterceptor endpointInterceptor;
     private final ApplicationProperties applicationProperties;
 
-    private static final Logger logger = LoggerFactory.getLogger(WebMvcConfig.class);
-
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(endpointInterceptor);
@@ -27,50 +23,10 @@ public class WebMvcConfig implements WebMvcConfigurer {
 
     @Override
     public void addCorsMappings(CorsRegistry registry) {
-        // Check if running in Tauri mode
-        boolean isTauriMode =
-                Boolean.parseBoolean(System.getProperty("STIRLING_PDF_TAURI_MODE", "false"));
-
-        // Check if user has configured custom origins
-        boolean hasConfiguredOrigins =
-                applicationProperties.getSystem() != null
-                        && applicationProperties.getSystem().getCorsAllowedOrigins() != null
-                        && !applicationProperties.getSystem().getCorsAllowedOrigins().isEmpty();
-
-        if (isTauriMode) {
-            // Automatically enable CORS for Tauri desktop app
-            // Tauri v1 uses tauri://localhost, v2 uses http(s)://tauri.localhost
-            logger.info("Tauri mode detected - enabling CORS for Tauri protocols (v1 and v2)");
-            registry.addMapping("/**")
-                    .allowedOrigins(
-                            "tauri://localhost",
-                            "http://tauri.localhost",
-                            "https://tauri.localhost")
-                    .allowedMethods("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS")
-                    .allowedHeaders(
-                            "Authorization",
-                            "Content-Type",
-                            "X-Requested-With",
-                            "Accept",
-                            "Origin",
-                            "X-API-KEY",
-                            "X-CSRF-TOKEN",
-                            "X-XSRF-TOKEN",
-                            "X-Browser-Id")
-                    .exposedHeaders(
-                            "WWW-Authenticate",
-                            "X-Total-Count",
-                            "X-Page-Number",
-                            "X-Page-Size",
-                            "Content-Disposition",
-                            "Content-Type")
-                    .allowCredentials(true)
-                    .maxAge(3600);
-        } else if (hasConfiguredOrigins) {
-            // Use user-configured origins
-            logger.info(
-                    "Configuring CORS with allowed origins: {}",
-                    applicationProperties.getSystem().getCorsAllowedOrigins());
+        // Only configure CORS if allowed origins are specified
+        if (applicationProperties.getSystem() != null
+                && applicationProperties.getSystem().getCorsAllowedOrigins() != null
+                && !applicationProperties.getSystem().getCorsAllowedOrigins().isEmpty()) {
 
             String[] allowedOrigins =
                     applicationProperties
@@ -79,53 +35,21 @@ public class WebMvcConfig implements WebMvcConfigurer {
                             .toArray(new String[0]);
 
             registry.addMapping("/**")
-                    .allowedOriginPatterns(allowedOrigins)
-                    .allowedMethods("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS")
-                    .allowedHeaders(
-                            "Authorization",
-                            "Content-Type",
-                            "X-Requested-With",
-                            "Accept",
-                            "Origin",
-                            "X-API-KEY",
-                            "X-CSRF-TOKEN",
-                            "X-XSRF-TOKEN",
-                            "X-Browser-Id")
-                    .exposedHeaders(
-                            "WWW-Authenticate",
-                            "X-Total-Count",
-                            "X-Page-Number",
-                            "X-Page-Size",
-                            "Content-Disposition",
-                            "Content-Type")
-                    .allowCredentials(true)
-                    .maxAge(3600);
-        } else {
-            // Default to allowing all origins when nothing is configured
-            logger.info(
-                    "No CORS allowed origins configured in settings.yml (system.corsAllowedOrigins); allowing all origins.");
-            registry.addMapping("/**")
-                    .allowedOriginPatterns("*")
-                    .allowedMethods("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS")
-                    .allowedHeaders(
-                            "Authorization",
-                            "Content-Type",
-                            "X-Requested-With",
-                            "Accept",
-                            "Origin",
-                            "X-API-KEY",
-                            "X-CSRF-TOKEN",
-                            "X-XSRF-TOKEN",
-                            "X-Browser-Id")
-                    .exposedHeaders(
-                            "WWW-Authenticate",
-                            "X-Total-Count",
-                            "X-Page-Number",
-                            "X-Page-Size",
-                            "Content-Disposition",
-                            "Content-Type")
+                    .allowedOrigins(allowedOrigins)
+                    .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH")
+                    .allowedHeaders("*")
                     .allowCredentials(true)
                     .maxAge(3600);
         }
+        // If no origins are configured, CORS is not enabled (secure by default)
     }
+
+    // @Override
+    // public void addResourceHandlers(ResourceHandlerRegistry registry) {
+    //     // Handler for external static resources - DISABLED in backend-only mode
+    //     registry.addResourceHandler("/**")
+    //             .addResourceLocations(
+    //                     "file:" + InstallationPathConfig.getStaticPath(), "classpath:/static/");
+    //     // .setCachePeriod(0); // Optional: disable caching
+    // }
 }

app/core/src/main/java/stirling/software/SPDF/controller/api/CropController.java

@@ -22,7 +22,6 @@ import io.swagger.v3.oas.annotations.Operation;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
-import stirling.software.SPDF.config.EndpointConfiguration;
 import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.general.CropPdfForm;
 import stirling.software.common.annotations.AutoJobPostMapping;
@@ -38,11 +37,6 @@ import stirling.software.common.util.WebResponseUtils;
 public class CropController {
 
     private final CustomPDFDocumentFactory pdfDocumentFactory;
-    private final EndpointConfiguration endpointConfiguration;
-
-    private boolean isGhostscriptEnabled() {
-        return endpointConfiguration.isGroupEnabled("Ghostscript");
-    }
 
     @AutoJobPostMapping(value = "/crop", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
     @StandardPdfResponse
@@ -52,13 +46,9 @@ public class CropController {
                     "This operation takes an input PDF file and crops it according to the given"
                             + " coordinates. Input:PDF Output:PDF Type:SISO")
     public ResponseEntity<byte[]> cropPdf(@ModelAttribute CropPdfForm request) throws IOException {
-        if (request.isRemoveDataOutsideCrop() && isGhostscriptEnabled()) {
+        if (request.isRemoveDataOutsideCrop()) {
             return cropWithGhostscript(request);
         } else {
-            if (request.isRemoveDataOutsideCrop()) {
-                log.warn(
-                        "Ghostscript not available - 'removeDataOutsideCrop' option requires Ghostscript. Falling back to visual crop only.");
-            }
             return cropWithPDFBox(request);
         }
     }

app/core/src/main/java/stirling/software/SPDF/controller/api/EditTableOfContentsController.java

@@ -29,6 +29,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 
+import stirling.software.SPDF.config.swagger.JsonDataResponse;
 import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.EditTableOfContentsRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
@@ -48,12 +49,13 @@ public class EditTableOfContentsController {
     @AutoJobPostMapping(
             value = "/extract-bookmarks",
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @JsonDataResponse
     @Operation(
             summary = "Extract PDF Bookmarks",
             description = "Extracts bookmarks/table of contents from a PDF document as JSON.")
     @ResponseBody
-    public ResponseEntity<List<Map<String, Object>>> extractBookmarks(
-            @RequestParam("file") MultipartFile file) throws Exception {
+    public List<Map<String, Object>> extractBookmarks(@RequestParam("file") MultipartFile file)
+            throws Exception {
         PDDocument document = null;
         try {
             document = pdfDocumentFactory.load(file);
@@ -61,10 +63,10 @@ public class EditTableOfContentsController {
 
             if (outline == null) {
                 log.info("No outline/bookmarks found in PDF");
-                return ResponseEntity.ok(new ArrayList<>());
+                return new ArrayList<>();
             }
 
-            return ResponseEntity.ok(extractBookmarkItems(document, outline));
+            return extractBookmarkItems(document, outline);
         } finally {
             if (document != null) {
                 document.close();

app/core/src/main/java/stirling/software/SPDF/controller/api/MultiPageLayoutController.java

@@ -26,6 +26,7 @@ import stirling.software.SPDF.model.api.general.MergeMultiplePagesRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.util.FormUtils;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.WebResponseUtils;
 
@@ -136,6 +137,26 @@ public class MultiPageLayoutController {
 
         contentStream.close();
 
+        // If any source page is rotated, skip form copying/transformation entirely
+        boolean hasRotation = FormUtils.hasAnyRotatedPage(sourceDocument);
+        if (hasRotation) {
+            log.info("Source document has rotated pages; skipping form field copying.");
+        } else {
+            try {
+                FormUtils.copyAndTransformFormFields(
+                        sourceDocument,
+                        newDocument,
+                        totalPages,
+                        pagesPerSheet,
+                        cols,
+                        rows,
+                        cellWidth,
+                        cellHeight);
+            } catch (Exception e) {
+                log.warn("Failed to copy and transform form fields: {}", e.getMessage(), e);
+            }
+        }
+
         sourceDocument.close();
 
         ByteArrayOutputStream baos = new ByteArrayOutputStream();

app/core/src/main/java/stirling/software/SPDF/controller/api/misc/ConfigController.java

@@ -1,7 +1,6 @@
 package stirling.software.SPDF.controller.api.misc;
 
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 import org.springframework.context.ApplicationContext;
@@ -11,14 +10,7 @@ import org.springframework.web.bind.annotation.RequestParam;
 
 import io.swagger.v3.oas.annotations.Hidden;
 
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.Size;
-
-import lombok.extern.slf4j.Slf4j;
-
 import stirling.software.SPDF.config.EndpointConfiguration;
-import stirling.software.SPDF.config.EndpointConfiguration.EndpointAvailability;
-import stirling.software.SPDF.config.InitialSetup;
 import stirling.software.common.annotations.api.ConfigApi;
 import stirling.software.common.configuration.AppConfig;
 import stirling.software.common.model.ApplicationProperties;
@@ -27,7 +19,6 @@ import stirling.software.common.service.UserServiceInterface;
 
 @ConfigApi
 @Hidden
-@Slf4j
 public class ConfigController {
 
     private final ApplicationProperties applicationProperties;
@@ -35,7 +26,6 @@ public class ConfigController {
     private final EndpointConfiguration endpointConfiguration;
     private final ServerCertificateServiceInterface serverCertificateService;
     private final UserServiceInterface userService;
-    private final stirling.software.SPDF.config.ExternalAppDepConfig externalAppDepConfig;
 
     public ConfigController(
             ApplicationProperties applicationProperties,
@@ -44,14 +34,12 @@ public class ConfigController {
             @org.springframework.beans.factory.annotation.Autowired(required = false)
                     ServerCertificateServiceInterface serverCertificateService,
             @org.springframework.beans.factory.annotation.Autowired(required = false)
-                    UserServiceInterface userService,
-            stirling.software.SPDF.config.ExternalAppDepConfig externalAppDepConfig) {
+                    UserServiceInterface userService) {
         this.applicationProperties = applicationProperties;
         this.applicationContext = applicationContext;
         this.endpointConfiguration = endpointConfiguration;
         this.serverCertificateService = serverCertificateService;
         this.userService = userService;
-        this.externalAppDepConfig = externalAppDepConfig;
     }
 
     @GetMapping("/app-config")
@@ -59,9 +47,6 @@ public class ConfigController {
         Map<String, Object> configData = new HashMap<>();
 
         try {
-            // Add dependency check status
-            configData.put("dependenciesReady", externalAppDepConfig.isDependenciesChecked());
-
             // Get AppConfig bean
             AppConfig appConfig = applicationContext.getBean(AppConfig.class);
 
@@ -73,15 +58,9 @@ public class ConfigController {
             // Extract values from ApplicationProperties
             configData.put("appNameNavbar", applicationProperties.getUi().getAppNameNavbar());
             configData.put("languages", applicationProperties.getUi().getLanguages());
-            configData.put("logoStyle", applicationProperties.getUi().getLogoStyle());
 
             // Security settings
-            // enableLogin requires both the config flag AND proprietary features to be loaded
-            // If userService is null, proprietary module isn't loaded
-            // (DISABLE_ADDITIONAL_FEATURES=true or DOCKER_ENABLE_SECURITY=false)
-            boolean enableLogin =
-                    applicationProperties.getSecurity().getEnableLogin() && userService != null;
-            configData.put("enableLogin", enableLogin);
+            configData.put("enableLogin", applicationProperties.getSecurity().getEnableLogin());
 
             // Mail settings - check both SMTP enabled AND invites enabled
             boolean smtpEnabled = applicationProperties.getMail().isEnabled();
@@ -99,22 +78,6 @@ public class ConfigController {
             }
             configData.put("isAdmin", isAdmin);
 
-            // Check if this is a new server (version was 0.0.0 before initialization)
-            configData.put("isNewServer", InitialSetup.isNewServer());
-
-            // Check if the current user is a first-time user
-            boolean isNewUser =
-                    false; // Default to false when security is disabled or user not found
-            if (userService != null) {
-                try {
-                    isNewUser = userService.isCurrentUserFirstLogin();
-                } catch (Exception e) {
-                    // If there's an error, assume not new user for safety
-                    isNewUser = false;
-                }
-            }
-            configData.put("isNewUser", isNewUser);
-
             // System settings
             configData.put(
                     "enableAlphaFunctionality",
@@ -165,25 +128,6 @@ public class ConfigController {
                 // EE features not available, continue without them
             }
 
-            // Add version and machine info for update checking
-            try {
-                if (applicationContext.containsBean("appVersion")) {
-                    configData.put(
-                            "appVersion", applicationContext.getBean("appVersion", String.class));
-                }
-                if (applicationContext.containsBean("machineType")) {
-                    configData.put(
-                            "machineType", applicationContext.getBean("machineType", String.class));
-                }
-                if (applicationContext.containsBean("activeSecurity")) {
-                    configData.put(
-                            "activeSecurity",
-                            applicationContext.getBean("activeSecurity", Boolean.class));
-                }
-            } catch (Exception e) {
-                // Version/machine info not available
-            }
-
             return ResponseEntity.ok(configData);
 
         } catch (Exception e) {
@@ -211,19 +155,4 @@ public class ConfigController {
         }
         return ResponseEntity.ok(result);
     }
-
-    @GetMapping("/endpoints-availability")
-    public ResponseEntity<Map<String, EndpointAvailability>> getEndpointAvailability(
-            @RequestParam(name = "endpoints")
-                    @Size(min = 1, max = 100, message = "Must provide between 1 and 100 endpoints")
-                    List<@NotBlank String> endpoints) {
-        Map<String, EndpointAvailability> result = new HashMap<>();
-        for (String endpoint : endpoints) {
-            String trimmedEndpoint = endpoint.trim();
-            result.put(
-                    trimmedEndpoint,
-                    endpointConfiguration.getEndpointAvailability(trimmedEndpoint));
-        }
-        return ResponseEntity.ok(result);
-    }
 }

app/core/src/main/java/stirling/software/SPDF/controller/api/misc/StampController.java

@@ -196,9 +196,9 @@ public class StampController {
         resourceDir =
                 switch (alphabet) {
                     case "arabic" -> "static/fonts/NotoSansArabic-Regular.ttf";
-                    case "japanese" -> "static/fonts/NotoSansJP-Regular.ttf";
-                    case "korean" -> "static/fonts/NotoSansKR-Regular.ttf";
-                    case "chinese" -> "static/fonts/NotoSansSC-Regular.ttf";
+                    case "japanese" -> "static/fonts/Meiryo.ttf";
+                    case "korean" -> "static/fonts/malgun.ttf";
+                    case "chinese" -> "static/fonts/SimSun.ttf";
                     case "thai" -> "static/fonts/NotoSansThai-Regular.ttf";
                     case "roman" -> "static/fonts/NotoSans-Regular.ttf";
                     default -> "static/fonts/NotoSans-Regular.ttf";

app/core/src/main/java/stirling/software/SPDF/controller/api/security/WatermarkController.java

@@ -171,9 +171,9 @@ public class WatermarkController {
         resourceDir =
                 switch (alphabet) {
                     case "arabic" -> "static/fonts/NotoSansArabic-Regular.ttf";
-                    case "japanese" -> "static/fonts/NotoSansJP-Regular.ttf";
-                    case "korean" -> "static/fonts/NotoSansKR-Regular.ttf";
-                    case "chinese" -> "static/fonts/NotoSansSC-Regular.ttf";
+                    case "japanese" -> "static/fonts/Meiryo.ttf";
+                    case "korean" -> "static/fonts/malgun.ttf";
+                    case "chinese" -> "static/fonts/SimSun.ttf";
                     case "thai" -> "static/fonts/NotoSansThai-Regular.ttf";
                     default -> "static/fonts/NotoSans-Regular.ttf";
                 };

app/core/src/main/java/stirling/software/SPDF/controller/web/MetricsController.java

@@ -23,7 +23,6 @@ import lombok.extern.slf4j.Slf4j;
 
 import stirling.software.SPDF.config.EndpointInspector;
 import stirling.software.SPDF.config.StartupApplicationListener;
-import stirling.software.SPDF.service.WeeklyActiveUsersService;
 import stirling.software.common.annotations.api.InfoApi;
 import stirling.software.common.model.ApplicationProperties;
 
@@ -35,7 +34,6 @@ public class MetricsController {
     private final ApplicationProperties applicationProperties;
     private final MeterRegistry meterRegistry;
     private final EndpointInspector endpointInspector;
-    private final Optional<WeeklyActiveUsersService> wauService;
     private boolean metricsEnabled;
 
     @PostConstruct
@@ -354,36 +352,6 @@ public class MetricsController {
         return ResponseEntity.ok(formatDuration(uptime));
     }
 
-    @GetMapping("/wau")
-    @Operation(
-            summary = "Weekly Active Users statistics",
-            description =
-                    "Returns WAU (Weekly Active Users) count and total unique browsers. "
-                            + "Only available when security is disabled (no-login mode). "
-                            + "Tracks unique browsers via client-generated UUID in localStorage.")
-    public ResponseEntity<?> getWeeklyActiveUsers() {
-        if (!metricsEnabled) {
-            return ResponseEntity.status(HttpStatus.FORBIDDEN).body("This endpoint is disabled.");
-        }
-
-        // Check if WAU service is available (only when security.enableLogin=false)
-        if (wauService.isEmpty()) {
-            return ResponseEntity.status(HttpStatus.NOT_FOUND)
-                    .body(
-                            "WAU tracking is only available when security is disabled (no-login mode)");
-        }
-
-        WeeklyActiveUsersService service = wauService.get();
-
-        Map<String, Object> wauStats = new HashMap<>();
-        wauStats.put("weeklyActiveUsers", service.getWeeklyActiveUsers());
-        wauStats.put("totalUniqueBrowsers", service.getTotalUniqueBrowsers());
-        wauStats.put("daysOnline", service.getDaysOnline());
-        wauStats.put("trackingSince", service.getStartTime().toString());
-
-        return ResponseEntity.ok(wauStats);
-    }
-
     private String formatDuration(Duration duration) {
         long days = duration.toDays();
         long hours = duration.toHoursPart();

app/core/src/main/java/stirling/software/SPDF/service/WeeklyActiveUsersService.java

@@ -1,101 +0,0 @@
-package stirling.software.SPDF.service;
-
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.springframework.stereotype.Service;
-
-import lombok.extern.slf4j.Slf4j;
-
-/**
- * Service for tracking Weekly Active Users (WAU) in no-login mode. Uses in-memory storage with
- * automatic cleanup of old entries.
- */
-@Service
-@Slf4j
-public class WeeklyActiveUsersService {
-
-    // Map of browser ID -> last seen timestamp
-    private final Map<String, Instant> activeBrowsers = new ConcurrentHashMap<>();
-
-    // Track total unique browsers seen (overall)
-    private long totalUniqueBrowsers = 0;
-
-    // Application start time
-    private final Instant startTime = Instant.now();
-
-    /**
-     * Records a browser access with the current timestamp
-     *
-     * @param browserId Unique browser identifier from X-Browser-Id header
-     */
-    public void recordBrowserAccess(String browserId) {
-        if (browserId == null || browserId.trim().isEmpty()) {
-            return;
-        }
-
-        boolean isNewBrowser = !activeBrowsers.containsKey(browserId);
-        activeBrowsers.put(browserId, Instant.now());
-
-        if (isNewBrowser) {
-            totalUniqueBrowsers++;
-            log.debug("New browser recorded: {} (Total: {})", browserId, totalUniqueBrowsers);
-        }
-    }
-
-    /**
-     * Gets the count of unique browsers seen in the last 7 days
-     *
-     * @return Weekly Active Users count
-     */
-    public long getWeeklyActiveUsers() {
-        cleanupOldEntries();
-        return activeBrowsers.size();
-    }
-
-    /**
-     * Gets the total count of unique browsers ever seen
-     *
-     * @return Total unique browsers count
-     */
-    public long getTotalUniqueBrowsers() {
-        return totalUniqueBrowsers;
-    }
-
-    /**
-     * Gets the number of days the service has been running
-     *
-     * @return Days online
-     */
-    public long getDaysOnline() {
-        return ChronoUnit.DAYS.between(startTime, Instant.now());
-    }
-
-    /**
-     * Gets the timestamp when tracking started
-     *
-     * @return Start time
-     */
-    public Instant getStartTime() {
-        return startTime;
-    }
-
-    /** Removes entries older than 7 days */
-    private void cleanupOldEntries() {
-        Instant sevenDaysAgo = Instant.now().minus(7, ChronoUnit.DAYS);
-        activeBrowsers.entrySet().removeIf(entry -> entry.getValue().isBefore(sevenDaysAgo));
-    }
-
-    /** Manual cleanup trigger (can be called by scheduled task if needed) */
-    public void performCleanup() {
-        int sizeBefore = activeBrowsers.size();
-        cleanupOldEntries();
-        int sizeAfter = activeBrowsers.size();
-
-        if (sizeBefore != sizeAfter) {
-            log.debug("Cleaned up {} old browser entries", sizeBefore - sizeAfter);
-        }
-    }
-}

app/core/src/main/java/stirling/software/common/controller/JobController.java

@@ -5,7 +5,6 @@ import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Map;
 
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.DeleteMapping;
@@ -25,7 +24,6 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.common.model.job.JobResult;
 import stirling.software.common.model.job.ResultFile;
 import stirling.software.common.service.FileStorage;
-import stirling.software.common.service.JobOwnershipService;
 import stirling.software.common.service.JobQueue;
 import stirling.software.common.service.TaskManager;
 import stirling.software.common.util.RegexPatternUtils;
@@ -43,9 +41,6 @@ public class JobController {
     private final JobQueue jobQueue;
     private final HttpServletRequest request;
 
-    @Autowired(required = false)
-    private JobOwnershipService jobOwnershipService;
-
     /**
      * Get the status of a job
      *
@@ -55,13 +50,6 @@ public class JobController {
     @GetMapping("/job/{jobId}")
     @Operation(summary = "Get job status")
     public ResponseEntity<?> getJobStatus(@PathVariable("jobId") String jobId) {
-        // Validate job ownership
-        if (!validateJobAccess(jobId)) {
-            log.warn("Unauthorized attempt to access job status: {}", jobId);
-            return ResponseEntity.status(403)
-                    .body(Map.of("message", "You are not authorized to access this job"));
-        }
-
         JobResult result = taskManager.getJobResult(jobId);
         if (result == null) {
             return ResponseEntity.notFound().build();
@@ -91,13 +79,6 @@ public class JobController {
     @GetMapping("/job/{jobId}/result")
     @Operation(summary = "Get job result")
     public ResponseEntity<?> getJobResult(@PathVariable("jobId") String jobId) {
-        // Validate job ownership
-        if (!validateJobAccess(jobId)) {
-            log.warn("Unauthorized attempt to access job result: {}", jobId);
-            return ResponseEntity.status(403)
-                    .body(Map.of("message", "You are not authorized to access this job"));
-        }
-
         JobResult result = taskManager.getJobResult(jobId);
         if (result == null) {
             return ResponseEntity.notFound().build();
@@ -163,8 +144,13 @@ public class JobController {
     public ResponseEntity<?> cancelJob(@PathVariable("jobId") String jobId) {
         log.debug("Request to cancel job: {}", jobId);
 
-        // Validate job ownership
-        if (!validateJobAccess(jobId)) {
+        // Verify that this job belongs to the current user
+        // We can use the current request's session to validate ownership
+        Object sessionJobIds = request.getSession().getAttribute("userJobIds");
+        if (sessionJobIds == null
+                || !(sessionJobIds instanceof java.util.Set)
+                || !((java.util.Set<?>) sessionJobIds).contains(jobId)) {
+            // Either no jobs in session or jobId doesn't match user's jobs
             log.warn("Unauthorized attempt to cancel job: {}", jobId);
             return ResponseEntity.status(403)
                     .body(Map.of("message", "You are not authorized to cancel this job"));
@@ -224,13 +210,6 @@ public class JobController {
     @GetMapping("/job/{jobId}/result/files")
     @Operation(summary = "Get job result files")
     public ResponseEntity<?> getJobFiles(@PathVariable("jobId") String jobId) {
-        // Validate job ownership
-        if (!validateJobAccess(jobId)) {
-            log.warn("Unauthorized attempt to access job files: {}", jobId);
-            return ResponseEntity.status(403)
-                    .body(Map.of("message", "You are not authorized to access this job"));
-        }
-
         JobResult result = taskManager.getJobResult(jobId);
         if (result == null) {
             return ResponseEntity.notFound().build();
@@ -351,26 +330,4 @@ public class JobController {
             return "attachment; filename=\"" + fileName + "\"";
         }
     }
-
-    /**
-     * Validate that the current user has access to the given job.
-     *
-     * @param jobId the job identifier to validate
-     * @return true if user has access, false otherwise
-     */
-    private boolean validateJobAccess(String jobId) {
-        // If JobOwnershipService is available (security enabled), use it
-        if (jobOwnershipService != null) {
-            try {
-                return jobOwnershipService.validateJobAccess(jobId);
-            } catch (SecurityException e) {
-                log.warn("Job ownership validation failed for jobId {}: {}", jobId, e.getMessage());
-                return false;
-            }
-        }
-
-        // Security disabled - allow all access (backwards compatibility)
-        // When security is not enabled, any user can access any job by jobId
-        return true;
-    }
 }

app/core/src/main/resources/application.properties

@@ -1,6 +1,5 @@
 multipart.enabled=true
 logging.level.org.springframework=WARN
-logging.level.org.springframework.security=WARN
 logging.level.org.hibernate=WARN
 logging.level.org.eclipse.jetty=WARN
 #logging.level.org.springframework.security.oauth2=DEBUG
@@ -8,9 +7,6 @@ logging.level.org.eclipse.jetty=WARN
 #logging.level.org.opensaml=DEBUG
 #logging.level.stirling.software.proprietary.security=DEBUG
 logging.level.com.zaxxer.hikari=WARN
-logging.level.stirling.software.SPDF.service.PdfJsonConversionService=INFO
-logging.level.stirling.software.common.service.JobExecutorService=INFO
-logging.level.stirling.software.common.service.TaskManager=INFO
 spring.jpa.open-in-view=false
 server.forward-headers-strategy=NATIVE
 server.error.path=/error

app/core/src/main/resources/settings.yml.template

@@ -11,7 +11,7 @@
 #############################################################################################################
 
 security:
-  enableLogin: true # set to 'true' to enable login
+  enableLogin: false # set to 'true' to enable login
   csrfDisabled: false # set to 'true' to disable CSRF protection (not recommended for production)
   loginAttemptCount: 5 # lock user account after 5 tries; when using e.g. Fail2Ban you can deactivate the function with -1
   loginResetTimeMinutes: 120 # lock account for 2 hours after x attempts
@@ -174,26 +174,8 @@ system:
   databaseBackup:
     cron: '0 0 0 * * ?' # Cron expression for automatic database backups "0 0 0 * * ?" daily at midnight
 
-stirling:
-  pdf:
-    fallback-font: classpath:/static/fonts/NotoSans-Regular.ttf # Override to point at a custom fallback font
-    json:
-      font-normalization:
-        enabled: false # IMPORTANT: Disable to preserve ToUnicode CMaps for correct font rendering. Ghostscript strips Unicode mappings from CID fonts.
-      cff-converter:
-        enabled: true # Wrap CFF/Type1C fonts as OpenType-CFF for browser compatibility
-        method: python # Converter method: 'python' (fontTools, recommended - wraps as OTF), 'fontforge' (legacy - converts to TTF, may hang on CID fonts)
-        python-command: /opt/venv/bin/python3 # Python interpreter path
-        python-script: /scripts/convert_cff_to_ttf.py # Path to font wrapping script
-        fontforge-command: fontforge # Override if FontForge is installed under a different name/path
-      type3:
-        library:
-          enabled: true # Match common Type3 fonts against the built-in library of converted programs
-          index: classpath:/type3/library/index.json # Override to point at a custom index.json (supports http:, file:, classpath:)
-
 ui:
   appNameNavbar: '' # name displayed on the navigation bar
-  logoStyle: classic # Options: 'classic' (default - classic S icon) or 'modern' (minimalist logo)
   languages: [] # If empty, all languages are enabled. To display only German and Polish ["de_DE", "pl_PL"]. British English is always enabled.
 
 endpoints:

app/core/src/main/resources/static/css/theme/theme.css

@@ -7,8 +7,6 @@
   --md-sys-color-surface-3: color-mix(in srgb, var(--md-sys-color-primary) 13%, rgba(0, 0, 255, 0.11) 5%);
   --md-sys-color-surface-4: color-mix(in srgb, var(--md-sys-color-primary) 13%, rgba(0, 0, 255, 0.12) 5%);
   --md-sys-color-surface-5: color-mix(in srgb, var(--md-sys-color-primary) 13%, rgba(0, 0, 255, 0.14) 5%);
-  /* Clear button disabled text color (default/light) */
-  --spdf-clear-disabled-text: var(--md-sys-color-primary);
   /* Icon fill */
   --md-sys-icon-fill-0: 'FILL' 0, 'wght' 500;
   --md-sys-icon-fill-1: 'FILL' 1, 'wght' 500;
@@ -27,12 +25,6 @@
   --md-sys-elevation-5: 0px 8px 10px -6px rgb(var(--md-elevation-shadow-color), 0.2), 0px 16px 24px 2px rgb(var(--md-elevation-shadow-color), 0.14), 0px 6px 30px 5px rgb(var(--md-elevation-shadow-color), 0.12);
 }
 
-/* Dark theme overrides */
-.dark-theme {
-  /* In dark mode, use a neutral grey for disabled Clear button text */
-  --spdf-clear-disabled-text: var(--mantine-color-gray-5, #9e9e9e);
-}
-
 .fill {
   font-variation-settings: var(--md-sys-icon-fill-1);
 }

app/core/src/main/resources/static/pipeline/defaultWebUIConfigs/Pre-publish-sanitization.json

@@ -1,54 +0,0 @@
-{
-  "name": "Pre-publish-sanitization",
-  "pipeline": [
-    {
-      "operation": "/api/v1/security/sanitize-pdf",
-      "parameters": {
-        "removeJavaScript": true,
-        "removeEmbeddedFiles": true,
-        "removeXMPMetadata": true,
-        "removeMetadata": true,
-        "removeLinks": true,
-        "removeFonts": false
-      }
-    },
-    {
-      "operation": "/api/v1/misc/flatten",
-      "parameters": {
-        "flattenOnlyForms": true
-      }
-    },
-    {
-      "operation": "/api/v1/general/remove-annotations",
-      "parameters": {}
-    },
-    {
-      "operation": "/api/v1/misc/update-metadata",
-      "parameters": {
-        "deleteAll": true,
-        "author": "",
-        "creationDate": "",
-        "creator": "",
-        "keywords": "",
-        "modificationDate": "",
-        "producer": "",
-        "subject": "",
-        "title": "",
-        "trapped": ""
-      }
-    },
-    {
-      "operation": "/api/v1/misc/compress-pdf",
-      "parameters": {
-        "optimizeLevel": 3,
-        "expectedOutputSize": ""
-      }
-    }
-  ],
-  "_examples": {
-    "outputDir": "{outputFolder}/{folderName}",
-    "outputFileName": "{filename}-{pipelineName}-{date}-{time}"
-  },
-  "outputDir": "{outputFolder}",
-  "outputFileName": "pre_publish_{filename}.PDF"
-}

app/core/src/main/resources/type3/catalogue.json

@@ -1,592 +0,0 @@
-[
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "1867"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "1888"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "2029"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "2069"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "2089"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "2116"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSansMono",
-    "encoding": "2174"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans-Oblique",
-    "encoding": "2192"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "2209"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "Cmsy10",
-    "encoding": "2228"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "STIXSizeThreeSym-Regular",
-    "encoding": "2233"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSansDisplay",
-    "encoding": "2239"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4403"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4438"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4519"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4685"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4733"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4782"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4813"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4834"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSansMono",
-    "encoding": "4878"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4906"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4929"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "4971"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5001"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5030"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5052"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5083"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5116"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5143"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5175"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5207"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5243"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "Cmr10",
-    "encoding": "5263"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "Cmex10",
-    "encoding": "5270"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "Cmsy10",
-    "encoding": "5275"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "Cmmi10",
-    "encoding": "5280"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5295"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans-Oblique",
-    "encoding": "5313"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSansDisplay",
-    "encoding": "5319"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5334"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5370"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5399"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5427"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5459"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5486"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5513"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5554"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5601"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5647"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5694"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5732"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5771"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5803"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5861"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5904"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5924"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "5951"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "6084"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "6445"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "7195"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "7409"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "7474"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "7708"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "7747"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "7885"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "9029"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "9617"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "10460"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "11445"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans-Bold",
-    "encoding": "11486"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "11497"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "11543"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "12280"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "12301"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "12350"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "12372"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "12395"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "12416"
-  },
-  {
-    "source": "01_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "13324"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "3214"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "3251"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "7190"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "9937"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "10792"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "10852"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "14712"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "18396"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "18719"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans-Bold",
-    "encoding": "18741"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "18778"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "18804"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "20974"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "20993"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "21093"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "21117"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "21141"
-  },
-  {
-    "source": "02_Matplotlib.pdf",
-    "fontName": "DejaVuSans",
-    "encoding": "21174"
-  },
-  {
-    "source": "03_handout-beginner.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "17"
-  },
-  {
-    "source": "03_handout-beginner.pdf",
-    "fontName": "EVICAO+DejaVuSans-Bold",
-    "encoding": "133"
-  },
-  {
-    "source": "03_handout-beginner.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "152"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "13"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "85"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "104"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "121"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "135"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "159"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "179"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "198"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "NVMZUP+SourceCodePro-Regular",
-    "encoding": "208"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "BMQQDV+DejaVuSans",
-    "encoding": "231"
-  },
-  {
-    "source": "04_handout-intermediate.pdf",
-    "fontName": "NVMZUP+SourceCodePro-Regular",
-    "encoding": "241"
-  },
-  {
-    "source": "07_matplotlib.pdf",
-    "fontName": "SauceCodePowerline-Bold",
-    "encoding": "22"
-  },
-  {
-    "source": "07_matplotlib.pdf",
-    "fontName": "SauceCodePowerline-Regular",
-    "encoding": "47"
-  },
-  {
-    "source": "07_matplotlib.pdf",
-    "fontName": "SauceCodePowerline-Regular",
-    "encoding": "65"
-  },
-  {
-    "source": "07_matplotlib.pdf",
-    "fontName": "SauceCodePowerline-Bold",
-    "encoding": "110"
-  },
-  {
-    "source": "08_matplotlib.pdf",
-    "fontName": "F36",
-    "encoding": "12"
-  },
-  {
-    "source": "08_matplotlib.pdf",
-    "fontName": "F59",
-    "encoding": "42"
-  }
-]