init, but broken

2026-02-27 11:01:50 +00:00
414 changed files with 7280 additions and 49762 deletions
@@ -68,8 +68,3 @@ updates:
    schedule:
      interval: "weekly"
    rebase-strategy: "auto"
-
-  - package-ecosystem: cargo
-    directory: /frontend/src-tauri/provisioner
-    schedule:
-      interval: daily
@@ -87,7 +87,7 @@ jobs:
      - name: AI PR Title Analysis
        if: steps.actor.outputs.is_repo_dev == 'true'
        id: ai-title-analysis
-        uses: actions/ai-inference@e09e65981758de8b2fdab13c2bfb7c7d5493b0b6 # v2.0.7
+        uses: actions/ai-inference@a6101c89c6feaecc585efdd8d461f18bb7896f20 # v2.0.5
        with:
          model: openai/gpt-4o
          system-prompt-file: ".github/config/system-prompt.txt"
@@ -69,7 +69,7 @@ jobs:
          distribution: "temurin"

      - name: Cache Gradle dependency artifacts
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/wrapper
@@ -147,14 +147,14 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

-      - name: Set up JDK 25
+      - name: Set up JDK 21
        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
        with:
          java-version: "25"
          distribution: "temurin"

      - name: Cache Gradle dependency artifacts
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/wrapper
@@ -194,7 +194,7 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Node.js
-        uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
        with:
          node-version: "22"
          cache: "npm"
@@ -202,7 +202,7 @@ jobs:
      - name: Install frontend dependencies
        run: cd frontend && npm ci
      - name: Type-check frontend
-        run: cd frontend && npm run prep && npm run typecheck:all
+        run: cd frontend && npm run prebuild && npm run typecheck:all
      - name: Lint frontend
        run: cd frontend && npm run lint
      - name: Build frontend
@@ -236,7 +236,7 @@ jobs:
          distribution: "temurin"

      - name: Cache Gradle dependency artifacts
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/wrapper
@@ -309,7 +309,7 @@ jobs:
          distribution: "temurin"

      - name: Cache Gradle dependency artifacts
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/wrapper
@@ -328,7 +328,7 @@ jobs:

      # Expose ACTIONS_RUNTIME_TOKEN / ACTIONS_RESULTS_URL for docker buildx type=gha cache backend.
      - name: Expose GitHub runtime for Buildx cache
-        uses: crazy-max/ghaction-github-runtime@3cb05d89e1f492524af3d41a1c98c83bc3025124 # v3.1.0
+        uses: crazy-max/ghaction-github-runtime@v3

      - name: Install Docker Compose
        run: |
@@ -416,7 +416,7 @@ jobs:
          distribution: "temurin"

      - name: Cache Gradle dependency artifacts
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/wrapper
@@ -77,7 +77,7 @@ jobs:
          persist-credentials: false

      - name: Set up Node.js
-        uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
        with:
          node-version: "22"
          cache: "npm"
@@ -49,7 +49,7 @@ jobs:
          distribution: "temurin"

      - name: Cache Gradle dependencies
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/caches
@@ -138,7 +138,7 @@ jobs:

      - name: Setup Node.js
        if: matrix.variant.build_frontend == true
-        uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          node-version: 22
          cache: "npm"
@@ -193,7 +193,7 @@ jobs:
          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@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          node-version: 22
          cache: "npm"
@@ -299,7 +299,7 @@ jobs:
      - name: Setup DigiCert KeyLocker
        id: digicert-setup
        if: ${{ matrix.platform == 'windows-latest' && env.SM_API_KEY != '' && (github.event_name == 'release' || github.ref == 'refs/heads/V2-master') }}
-        uses: digicert/ssm-code-signing@1d820463733701cf1484c7eb5d7d24a15ca2c454 # v1.2.1
+        uses: digicert/ssm-code-signing@af7f4b07694120e514fe5b19f0598af3c20256e3 # v1.2.0
        env:
          SM_API_KEY: ${{ secrets.SM_API_KEY }}
          SM_CLIENT_CERT_FILE_B64: ${{ secrets.SM_CLIENT_CERT_FILE_B64 }}
@@ -419,9 +419,8 @@ jobs:
          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 || 'sb_publishable_UHz2SVRF5mvdrPHWkRteyA_yNlZTkYb' }}
-          VITE_SAAS_SERVER_URL: ${{ secrets.VITE_SAAS_SERVER_URL || 'https://app.stirlingpdf.com' }}
-          VITE_SAAS_BACKEND_API_URL: ${{ secrets.VITE_SAAS_BACKEND_API_URL || 'https://api.stirlingpdf.com' }}
+          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 release or V2-master
          SIGN: ${{ (github.event_name == 'release' || github.ref == 'refs/heads/V2-master') && (env.SM_API_KEY == '' && env.WINDOWS_CERTIFICATE != '') && '1' || '0' }}
          CI: true
@@ -59,10 +59,10 @@ jobs:
          pre-commit run trailing-whitespace --all-files -c .pre-commit-config.yaml
        continue-on-error: true

-      - name: Set up JDK 25
+      - name: Set up JDK 21
        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
        with:
-          java-version: "25"
+          java-version: 21
          distribution: "temurin"

      - name: Setup Gradle
@@ -46,7 +46,7 @@ jobs:
          distribution: "temurin"

      - name: Cache Gradle dependencies
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/caches
@@ -75,6 +75,6 @@ jobs:

      # Upload the results to GitHub's code scanning dashboard.
      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@89a39a4e59826350b863aa6b6252a07ad50cf83e # v3.29.5
+        uses: github/codeql-action/upload-sarif@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v3.29.5
        with:
          sarif_file: results.sarif
@@ -14,7 +14,7 @@ on:
          - macos
          - linux
  pull_request:
-    branches: [main]
+    branches: [main, V2-tauri-windows]
    types: [opened, reopened, synchronize, ready_for_review]
    paths:
      - "frontend/src-tauri/**"
@@ -43,42 +43,27 @@ jobs:

      - name: Determine build matrix
        id: set-matrix
-        env:
-          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
        run: |
-          WINDOWS='{"platform":"windows-latest","args":"--target x86_64-pc-windows-msvc","name":"windows-x86_64"}'
-          MACOS_ARM='{"platform":"macos-15","args":"--target aarch64-apple-darwin","name":"macos-aarch64"}'
-          MACOS_INTEL='{"platform":"macos-15-intel","args":"--target x86_64-apple-darwin","name":"macos-x86_64"}'
-          LINUX='{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64"}'
-
-          # Resolve requested platform (non-dispatch events always build all)
          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            PLATFORM="${{ github.event.inputs.platform }}"
+            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
-            PLATFORM="all"
+            # 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 candidate list
-          case "$PLATFORM" in
-            windows) ENTRIES=("$WINDOWS") ;;
-            macos)   ENTRIES=("$MACOS_ARM" "$MACOS_INTEL") ;;
-            linux)   ENTRIES=("$LINUX") ;;
-            *)       ENTRIES=("$WINDOWS" "$MACOS_ARM" "$MACOS_INTEL" "$LINUX") ;;
-          esac
-
-          # Drop macOS entries when Apple certificate secret is unavailable
-          if [ -z "$APPLE_CERTIFICATE" ]; then
-            echo "⚠️ APPLE_CERTIFICATE secret not available - skipping macOS builds"
-            FILTERED=()
-            for entry in "${ENTRIES[@]}"; do
-              [[ "$entry" != *'"macos'* ]] && FILTERED+=("$entry")
-            done
-            ENTRIES=("${FILTERED[@]}")
-          fi
-
-          JOINED=$(IFS=','; echo "${ENTRIES[*]}")
-          echo "matrix={\"include\":[$JOINED]}" >> $GITHUB_OUTPUT
-
  build:
    needs: determine-matrix
    strategy:
@@ -88,7 +73,6 @@ jobs:
    env:
      SM_API_KEY: ${{ secrets.SM_API_KEY }}
      WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
-      APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@20cf305ff2072d973412fa9b1e3a4f227bda3c76 # v2.14.0
@@ -105,7 +89,7 @@ jobs:
          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@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          node-version: 22
          cache: "npm"
@@ -117,10 +101,10 @@ jobs:
          toolchain: stable
          targets: ${{ (matrix.platform == 'macos-15' || matrix.platform == 'macos-15-intel') && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}

-      - name: Set up JDK 25
+      - name: Set up JDK 21
        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
        with:
-          java-version: "25"
+          java-version: "21"
          distribution: "temurin"

      - name: Setup Gradle
@@ -212,7 +196,7 @@ jobs:
      - 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@1d820463733701cf1484c7eb5d7d24a15ca2c454 # v1.2.1
+        uses: digicert/ssm-code-signing@af7f4b07694120e514fe5b19f0598af3c20256e3 # v1.2.0
        env:
          SM_API_KEY: ${{ secrets.SM_API_KEY }}
          SM_CLIENT_CERT_FILE_B64: ${{ secrets.SM_CLIENT_CERT_FILE_B64 }}
@@ -287,7 +271,7 @@ jobs:
          }

      - name: Import Apple Developer Certificate
-        if: (matrix.platform == 'macos-15' || matrix.platform == 'macos-15-intel') && env.APPLE_CERTIFICATE != ''
+        if: matrix.platform == 'macos-15' || matrix.platform == 'macos-15-intel'
        env:
          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
@@ -308,7 +292,7 @@ jobs:
          rm certificate.p12

      - name: Verify Certificate
-        if: (matrix.platform == 'macos-15' || matrix.platform == 'macos-15-intel') && env.APPLE_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
@@ -343,9 +327,9 @@ jobs:
          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 || 'sb_publishable_UHz2SVRF5mvdrPHWkRteyA_yNlZTkYb' }}
-          VITE_SAAS_SERVER_URL: ${{ secrets.VITE_SAAS_SERVER_URL || 'https://app.stirlingpdf.com' }}
-          VITE_SAAS_BACKEND_API_URL: ${{ secrets.VITE_SAAS_BACKEND_API_URL || 'https://api.stirlingpdf.com' }}
+          VITE_SUPABASE_PUBLISHABLE_DEFAULT_KEY: ${{ secrets.VITE_SUPABASE_PUBLISHABLE_DEFAULT_KEY }}
+          VITE_SAAS_SERVER_URL: ${{ secrets.VITE_SAAS_SERVER_URL }}
+          VITE_SAAS_BACKEND_API_URL: ${{ secrets.VITE_SAAS_BACKEND_API_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
@@ -32,10 +32,10 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

-      - name: Set up JDK 25
+      - name: Set up JDK 21
        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
        with:
-          java-version: "25"
+          java-version: "21"
          distribution: "temurin"

      - name: Setup Gradle
@@ -157,7 +157,7 @@ jobs:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

      - name: Set up Node
-        uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
        with:
          cache: "npm"
          cache-dependency-path: frontend/package-lock.json
@@ -158,7 +158,6 @@ __pycache__/

 # Virtual environments
 .env*
-!.env*.example
 .venv*
 env*/
 venv*/
@@ -1,347 +0,0 @@
-# AGENTS.md
-
-This file provides guidance to AI Agents when working with code in this repository.
-
-## Common Development Commands
-
-### Build and Test
- **Build project**: `./gradlew clean build`
- **Run locally**: `./gradlew bootRun`
- **Full test suite**: `./test.sh` (builds all Docker variants and runs comprehensive tests)
- **Code formatting**: `./gradlew spotlessApply` (runs automatically before compilation)
-
-### Docker Development
- **Build ultra-lite**: `docker build -t stirlingtools/stirling-pdf:latest-ultra-lite -f ./Dockerfile.ultra-lite .`
- **Build standard**: `docker build -t stirlingtools/stirling-pdf:latest -f ./Dockerfile .`
- **Build fat version**: `docker build -t stirlingtools/stirling-pdf:latest-fat -f ./Dockerfile.fat .`
- **Example compose files**: Located in `exampleYmlFiles/` directory
-
-### Security Mode Development
-Set `DOCKER_ENABLE_SECURITY=true` environment variable to enable security features during development. This is required for testing the full version locally.
-
-### Frontend Development
- **Frontend dev server**: `cd frontend && npm run dev` (requires backend on localhost:8080)
- **Tech Stack**: Vite + React + TypeScript + Mantine UI + TailwindCSS
- **Proxy Configuration**: Vite proxies `/api/*` calls to backend (localhost:8080)
- **Build Process**: DO NOT run build scripts manually - builds are handled by CI/CD pipelines
- **Package Installation**: DO NOT run npm install commands - package management handled separately
- **Deployment Options**:
-  - **Desktop App**: `npm run tauri-build` (native desktop application)
-  - **Web Server**: `npm run build` then serve dist/ folder
-  - **Development**: `npm run tauri-dev` for desktop dev mode
-
-#### Environment Variables
- All `VITE_*` variables must be declared in the appropriate example file:
-  - `frontend/config/.env.example` — core, proprietary, and shared vars
-  - `frontend/config/.env.saas.example` — SaaS-only vars
-  - `frontend/config/.env.desktop.example` — desktop (Tauri)-only vars
- Never use `|| 'hardcoded-fallback'` inline — put defaults in the example files
- `npm run prep` / `prep:saas` / `prep:desktop` auto-create the env files from examples on first run, and error if any required keys are missing
- These prep scripts run automatically at the start of all `dev*`, `build*`, and `tauri*` commands
- See `frontend/README.md#environment-variables` for full documentation
-
-#### Import Paths - CRITICAL
-**ALWAYS use `@app/*` for imports.** Do not use `@core/*` or `@proprietary/*` unless explicitly wrapping/extending a lower layer implementation.
-
-```typescript
-// ✅ CORRECT - Use @app/* for all imports
-import { AppLayout } from "@app/components/AppLayout";
-import { useFileContext } from "@app/contexts/FileContext";
-import { FileContext } from "@app/contexts/FileContext";
-
-// ❌ WRONG - Do not use @core/* or @proprietary/* in normal code
-import { AppLayout } from "@core/components/AppLayout";
-import { useFileContext } from "@proprietary/contexts/FileContext";
-```
-
-**Only use explicit aliases when:**
- Building layer-specific override that wraps a lower layer's component
- Example: `import { AppProviders as CoreAppProviders } from "@core/components/AppProviders"` when creating proprietary/AppProviders.tsx that extends the core version
-
-The `@app/*` alias automatically resolves to the correct layer based on build target (core/proprietary/desktop) and handles the fallback cascade.
-
-#### Component Override Pattern (Stub/Shadow)
-Use this pattern for desktop-specific or proprietary-specific features WITHOUT runtime checks or conditionals.
-
-**How it works:**
-1. Core defines stub component (returns null or no-op)
-2. Desktop/proprietary overrides with same path/name
-3. Core imports via `@app/*` - higher layer "shadows" core in those builds
-4. No `@ts-ignore`, no `isTauri()` checks, no runtime conditionals!
-
-**Example - Desktop-specific footer:**
-
-```typescript
-// core/components/rightRail/RightRailFooterExtensions.tsx (stub)
-interface RightRailFooterExtensionsProps {
-  className?: string;
-}
-
-export function RightRailFooterExtensions(_props: RightRailFooterExtensionsProps) {
-  return null; // Stub - does nothing in web builds
-}
-```
-
-```typescript
-// desktop/components/rightRail/RightRailFooterExtensions.tsx (real implementation)
-import { Box } from '@mantine/core';
-import { BackendHealthIndicator } from '@app/components/BackendHealthIndicator';
-
-interface RightRailFooterExtensionsProps {
-  className?: string;
-}
-
-export function RightRailFooterExtensions({ className }: RightRailFooterExtensionsProps) {
-  return (
-    <Box className={className}>
-      <BackendHealthIndicator />
-    </Box>
-  );
-}
-```
-
-```typescript
-// core/components/shared/RightRail.tsx (usage - works in ALL builds)
-import { RightRailFooterExtensions } from '@app/components/rightRail/RightRailFooterExtensions';
-
-export function RightRail() {
-  return (
-    <div>
-      {/* In web builds: renders nothing (stub returns null) */}
-      {/* In desktop builds: renders BackendHealthIndicator */}
-      <RightRailFooterExtensions className="right-rail-footer" />
-    </div>
-  );
-}
-```
-
-**Build resolution:**
- **Core build**: `@app/*` → `core/*` → Gets stub (returns null)
- **Desktop build**: `@app/*` → `desktop/*` → Gets real implementation (shadows core)
-
-**Benefits:**
- No runtime checks or feature flags
- Type-safe across all builds
- Clean, readable code
- Build-time optimization (dead code elimination)
-
-#### Multi-Tool Workflow Architecture
-Frontend designed for **stateful document processing**:
- Users upload PDFs once, then chain tools (split → merge → compress → view)
- File state and processing results persist across tool switches
- No file reloading between tools - performance critical for large PDFs (up to 100GB+)
-
-#### FileContext - Central State Management
-**Location**: `frontend/src/core/contexts/FileContext.tsx`
- **Active files**: Currently loaded PDFs and their variants
- **Tool navigation**: Current mode (viewer/pageEditor/fileEditor/toolName)
- **Memory management**: PDF document cleanup, blob URL lifecycle, Web Worker management
- **IndexedDB persistence**: File storage with thumbnail caching
- **Preview system**: Tools can preview results (e.g., Split → Viewer → back to Split) without context pollution
-
-**Critical**: All file operations go through FileContext. Don't bypass with direct file handling.
-
-#### Processing Services
- **enhancedPDFProcessingService**: Background PDF parsing and manipulation
- **thumbnailGenerationService**: Web Worker-based with main-thread fallback
- **fileStorage**: IndexedDB with LRU cache management
-
-#### Memory Management Strategy
-**Why manual cleanup exists**: Large PDFs (up to 100GB+) through multiple tools accumulate:
- PDF.js documents that need explicit .destroy() calls
- Blob URLs from tool outputs that need revocation
- Web Workers that need termination
-Without cleanup: browser crashes with memory leaks.
-
-#### Tool Development
-
-**Architecture**: Modular hook-based system with clear separation of concerns:
-
- **useToolOperation** (`frontend/src/core/hooks/tools/shared/useToolOperation.ts`): Main orchestrator hook
-  - Coordinates all tool operations with consistent interface
-  - Integrates with FileContext for operation tracking
-  - Handles validation, error handling, and UI state management
-
- **Supporting Hooks**:
-  - **useToolState**: UI state management (loading, progress, error, files)
-  - **useToolApiCalls**: HTTP requests and file processing
-  - **useToolResources**: Blob URLs, thumbnails, ZIP downloads
-
- **Utilities**:
-  - **toolErrorHandler**: Standardized error extraction and i18n support
-  - **toolResponseProcessor**: API response handling (single/zip/custom)
-  - **toolOperationTracker**: FileContext integration utilities
-
-**Three Tool Patterns**:
-
-**Pattern 1: Single-File Tools** (Individual processing)
- Backend processes one file per API call
- Set `multiFileEndpoint: false`
- Examples: Compress, Rotate
-```typescript
-return useToolOperation({
-  operationType: 'compress',
-  endpoint: '/api/v1/misc/compress-pdf',
-  buildFormData: (params, file: File) => { /* single file */ },
-  multiFileEndpoint: false,
-});
-```
-
-**Pattern 2: Multi-File Tools** (Batch processing)
- Backend accepts `MultipartFile[]` arrays in single API call
- Set `multiFileEndpoint: true`
- Examples: Split, Merge, Overlay
-```typescript
-return useToolOperation({
-  operationType: 'split',
-  endpoint: '/api/v1/general/split-pages',
-  buildFormData: (params, files: File[]) => { /* all files */ },
-  multiFileEndpoint: true,
-  filePrefix: 'split_',
-});
-```
-
-**Pattern 3: Complex Tools** (Custom processing)
- Tools with complex routing logic or non-standard processing
- Provide `customProcessor` for full control
- Examples: Convert, OCR
-```typescript
-return useToolOperation({
-  operationType: 'convert',
-  customProcessor: async (params, files) => { /* custom logic */ },
-});
-```
-
-**Benefits**:
- **No Timeouts**: Operations run until completion (supports 100GB+ files)
- **Consistent**: All tools follow same pattern and interface
- **Maintainable**: Single responsibility hooks, easy to test and modify
- **i18n Ready**: Built-in internationalization support
- **Type Safe**: Full TypeScript support with generic interfaces
- **Memory Safe**: Automatic resource cleanup and blob URL management
-
-## Architecture Overview
-
-### Project Structure
- **Backend**: Spring Boot application
- **Frontend**: React-based SPA in `/frontend` directory
-  - **File Storage**: IndexedDB for client-side file persistence and thumbnails
-  - **Internationalization**: JSON-based translations (converted from backend .properties)
- **PDF Processing**: PDFBox for core PDF operations, LibreOffice for conversions, PDF.js for client-side rendering
- **Security**: Spring Security with optional authentication (controlled by `DOCKER_ENABLE_SECURITY`)
- **Configuration**: YAML-based configuration with environment variable overrides
-
-### Controller Architecture
- **API Controllers** (`src/main/java/.../controller/api/`): REST endpoints for PDF operations
-  - Organized by function: converters, security, misc, pipeline
-  - Follow pattern: `@RestController` + `@RequestMapping("/api/v1/...")`
-
-### Key Components
- **SPDFApplication.java**: Main application class with desktop UI and browser launching logic
- **ConfigInitializer**: Handles runtime configuration and settings files
- **Pipeline System**: Automated PDF processing workflows via `PipelineController`
- **Security Layer**: Authentication, authorization, and user management (when enabled)
-
-### Frontend Directory Structure
-The frontend is organized with a clear separation of concerns:
-
- **`frontend/src/core/`**: Main application code (shared, production-ready components)
-  - **`core/components/`**: React components organized by feature
-    - `core/components/tools/`: Individual PDF tool implementations
-    - `core/components/viewer/`: PDF viewer components
-    - `core/components/pageEditor/`: Page manipulation UI
-    - `core/components/tooltips/`: Help tooltips for tools
-    - `core/components/shared/`: Reusable UI components
-  - **`core/contexts/`**: React Context providers
-    - `FileContext.tsx`: Central file state management
-    - `file/`: File reducer and selectors
-    - `toolWorkflow/`: Tool workflow state
-  - **`core/hooks/`**: Custom React hooks
-    - `hooks/tools/`: Tool-specific operation hooks (one directory per tool)
-    - `hooks/tools/shared/`: Shared hook utilities (useToolOperation, etc.)
-  - **`core/constants/`**: Application constants and configuration
-  - **`core/data/`**: Static data (tool taxonomy, etc.)
-  - **`core/services/`**: Business logic services (PDF processing, storage, etc.)
-
- **`frontend/src/desktop/`**: Desktop-specific (Tauri) code
- **`frontend/src/proprietary/`**: Proprietary/licensed features
- **`frontend/src-tauri/`**: Tauri (Rust) native desktop application code
- **`frontend/public/`**: Static assets served directly
-  - `public/locales/`: Translation JSON files
-
-### Component Architecture
- **Static Assets**: CSS, JS, and resources in `src/main/resources/static/` (legacy) + `frontend/public/` (modern)
- **Internationalization**:
-  - Backend: `messages_*.properties` files
-  - Frontend: JSON files in `frontend/public/locales/` (converted from .properties)
-  - Conversion Script: `scripts/convert_properties_to_json.py`
-
-### Configuration Modes
- **Ultra-lite**: Basic PDF operations only
- **Standard**: Full feature set
- **Fat**: Pre-downloaded dependencies for air-gapped environments
- **Security Mode**: Adds authentication, user management, and enterprise features
-
-### Testing Strategy
- **Integration Tests**: Cucumber tests in `testing/cucumber/`
- **Docker Testing**: `test.sh` validates all Docker variants
- **Manual Testing**: No unit tests currently - relies on UI and API testing
-
-## Development Workflow
-
-1. **Local Development**:
-   - Backend: `./gradlew bootRun` (runs on localhost:8080)
-   - Frontend: `cd frontend && npm run dev` (runs on localhost:5173, proxies to backend)
-2. **Docker Testing**: Use `./test.sh` before submitting PRs
-3. **Code Style**: Spotless enforces Google Java Format automatically
-4. **Translations**:
-   - Backend: Use helper scripts in `/scripts` for multi-language updates
-   - Frontend: Update JSON files in `frontend/public/locales/` or use conversion script
-5. **Documentation**: API docs auto-generated and available at `/swagger-ui/index.html`
-
-## Frontend Architecture Status
-
- **Core Status**: React SPA architecture complete with multi-tool workflow support
- **State Management**: FileContext handles all file operations and tool navigation
- **File Processing**: Production-ready with memory management for large PDF workflows (up to 100GB+)
- **Tool Integration**: Modular hook architecture with `useToolOperation` orchestrator
-  - Individual hooks: `useToolState`, `useToolApiCalls`, `useToolResources`
-  - Utilities: `toolErrorHandler`, `toolResponseProcessor`, `toolOperationTracker`
-  - Pattern: Each tool creates focused operation hook, UI consumes state/actions
- **Preview System**: Tool results can be previewed without polluting file context (Split tool example)
- **Performance**: Web Worker thumbnails, IndexedDB persistence, background processing
-
-## Translation Rules
-
- **CRITICAL**: Always update translations in `en-GB` only, never `en-US`
- Translation files are located in `frontend/public/locales/`
-
-## Important Notes
-
- **Java Version**: Minimum JDK 21, supports and recommends JDK 25
- **Lombok**: Used extensively - ensure IDE plugin is installed
- **File Persistence**:
-  - **Backend**: Designed to be stateless - files are processed in memory/temp locations only
-  - **Frontend**: Uses IndexedDB for client-side file storage and caching (with thumbnails)
- **Security**: When `DOCKER_ENABLE_SECURITY=false`, security-related classes are excluded from compilation
- **Import Paths**: ALWAYS use `@app/*` for imports - never use `@core/*` or `@proprietary/*` unless explicitly wrapping/extending a lower layer
- **FileContext**: All file operations MUST go through FileContext - never bypass with direct File handling
- **Memory Management**: Manual cleanup required for PDF.js documents and blob URLs - don't remove cleanup code
- **Tool Development**: New tools should follow `useToolOperation` hook pattern (see `useCompressOperation.ts`)
- **Performance Target**: Must handle PDFs up to 100GB+ without browser crashes
- **Preview System**: Tools can preview results without polluting main file context (see Split tool implementation)
- **Adding Tools**: See `ADDING_TOOLS.md` for complete guide to creating new PDF tools
-
-## Communication Style
- Be direct and to the point
- No apologies or conversational filler
- Answer questions directly without preamble
- Explain reasoning concisely when asked
- Avoid unnecessary elaboration
-
-## Decision Making
- Ask clarifying questions before making assumptions
- Stop and ask when uncertain about project-specific details
- Confirm approach before making structural changes
- Request guidance on preferences (cross-platform vs specific tools, etc.)
- Verify understanding of requirements before proceeding
@@ -1 +0,0 @@
-AGENTS.md
@@ -0,0 +1,337 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Common Development Commands
+
+### Build and Test
+- **Build project**: `./gradlew clean build`
+- **Run locally**: `./gradlew bootRun`
+- **Full test suite**: `./test.sh` (builds all Docker variants and runs comprehensive tests)
+- **Code formatting**: `./gradlew spotlessApply` (runs automatically before compilation)
+
+### Docker Development
+- **Build ultra-lite**: `docker build -t stirlingtools/stirling-pdf:latest-ultra-lite -f ./Dockerfile.ultra-lite .`
+- **Build standard**: `docker build -t stirlingtools/stirling-pdf:latest -f ./Dockerfile .`
+- **Build fat version**: `docker build -t stirlingtools/stirling-pdf:latest-fat -f ./Dockerfile.fat .`
+- **Example compose files**: Located in `exampleYmlFiles/` directory
+
+### Security Mode Development
+Set `DOCKER_ENABLE_SECURITY=true` environment variable to enable security features during development. This is required for testing the full version locally.
+
+### Frontend Development
+- **Frontend dev server**: `cd frontend && npm run dev` (requires backend on localhost:8080)
+- **Tech Stack**: Vite + React + TypeScript + Mantine UI + TailwindCSS
+- **Proxy Configuration**: Vite proxies `/api/*` calls to backend (localhost:8080)
+- **Build Process**: DO NOT run build scripts manually - builds are handled by CI/CD pipelines
+- **Package Installation**: DO NOT run npm install commands - package management handled separately
+- **Deployment Options**:
+  - **Desktop App**: `npm run tauri-build` (native desktop application)
+  - **Web Server**: `npm run build` then serve dist/ folder
+  - **Development**: `npm run tauri-dev` for desktop dev mode
+
+#### Import Paths - CRITICAL
+**ALWAYS use `@app/*` for imports.** Do not use `@core/*` or `@proprietary/*` unless explicitly wrapping/extending a lower layer implementation.
+
+```typescript
+// ✅ CORRECT - Use @app/* for all imports
+import { AppLayout } from "@app/components/AppLayout";
+import { useFileContext } from "@app/contexts/FileContext";
+import { FileContext } from "@app/contexts/FileContext";
+
+// ❌ WRONG - Do not use @core/* or @proprietary/* in normal code
+import { AppLayout } from "@core/components/AppLayout";
+import { useFileContext } from "@proprietary/contexts/FileContext";
+```
+
+**Only use explicit aliases when:**
+- Building layer-specific override that wraps a lower layer's component
+- Example: `import { AppProviders as CoreAppProviders } from "@core/components/AppProviders"` when creating proprietary/AppProviders.tsx that extends the core version
+
+The `@app/*` alias automatically resolves to the correct layer based on build target (core/proprietary/desktop) and handles the fallback cascade.
+
+#### Component Override Pattern (Stub/Shadow)
+Use this pattern for desktop-specific or proprietary-specific features WITHOUT runtime checks or conditionals.
+
+**How it works:**
+1. Core defines stub component (returns null or no-op)
+2. Desktop/proprietary overrides with same path/name
+3. Core imports via `@app/*` - higher layer "shadows" core in those builds
+4. No `@ts-ignore`, no `isTauri()` checks, no runtime conditionals!
+
+**Example - Desktop-specific footer:**
+
+```typescript
+// core/components/rightRail/RightRailFooterExtensions.tsx (stub)
+interface RightRailFooterExtensionsProps {
+  className?: string;
+}
+
+export function RightRailFooterExtensions(_props: RightRailFooterExtensionsProps) {
+  return null; // Stub - does nothing in web builds
+}
+```
+
+```typescript
+// desktop/components/rightRail/RightRailFooterExtensions.tsx (real implementation)
+import { Box } from '@mantine/core';
+import { BackendHealthIndicator } from '@app/components/BackendHealthIndicator';
+
+interface RightRailFooterExtensionsProps {
+  className?: string;
+}
+
+export function RightRailFooterExtensions({ className }: RightRailFooterExtensionsProps) {
+  return (
+    <Box className={className}>
+      <BackendHealthIndicator />
+    </Box>
+  );
+}
+```
+
+```typescript
+// core/components/shared/RightRail.tsx (usage - works in ALL builds)
+import { RightRailFooterExtensions } from '@app/components/rightRail/RightRailFooterExtensions';
+
+export function RightRail() {
+  return (
+    <div>
+      {/* In web builds: renders nothing (stub returns null) */}
+      {/* In desktop builds: renders BackendHealthIndicator */}
+      <RightRailFooterExtensions className="right-rail-footer" />
+    </div>
+  );
+}
+```
+
+**Build resolution:**
+- **Core build**: `@app/*` → `core/*` → Gets stub (returns null)
+- **Desktop build**: `@app/*` → `desktop/*` → Gets real implementation (shadows core)
+
+**Benefits:**
+- No runtime checks or feature flags
+- Type-safe across all builds
+- Clean, readable code
+- Build-time optimization (dead code elimination)
+
+#### Multi-Tool Workflow Architecture
+Frontend designed for **stateful document processing**:
+- Users upload PDFs once, then chain tools (split → merge → compress → view)
+- File state and processing results persist across tool switches
+- No file reloading between tools - performance critical for large PDFs (up to 100GB+)
+
+#### FileContext - Central State Management
+**Location**: `frontend/src/core/contexts/FileContext.tsx`
+- **Active files**: Currently loaded PDFs and their variants
+- **Tool navigation**: Current mode (viewer/pageEditor/fileEditor/toolName)
+- **Memory management**: PDF document cleanup, blob URL lifecycle, Web Worker management
+- **IndexedDB persistence**: File storage with thumbnail caching
+- **Preview system**: Tools can preview results (e.g., Split → Viewer → back to Split) without context pollution
+
+**Critical**: All file operations go through FileContext. Don't bypass with direct file handling.
+
+#### Processing Services
+- **enhancedPDFProcessingService**: Background PDF parsing and manipulation
+- **thumbnailGenerationService**: Web Worker-based with main-thread fallback
+- **fileStorage**: IndexedDB with LRU cache management
+
+#### Memory Management Strategy
+**Why manual cleanup exists**: Large PDFs (up to 100GB+) through multiple tools accumulate:
+- PDF.js documents that need explicit .destroy() calls
+- Blob URLs from tool outputs that need revocation
+- Web Workers that need termination
+Without cleanup: browser crashes with memory leaks.
+
+#### Tool Development
+
+**Architecture**: Modular hook-based system with clear separation of concerns:
+
+- **useToolOperation** (`frontend/src/core/hooks/tools/shared/useToolOperation.ts`): Main orchestrator hook
+  - Coordinates all tool operations with consistent interface
+  - Integrates with FileContext for operation tracking
+  - Handles validation, error handling, and UI state management
+
+- **Supporting Hooks**:
+  - **useToolState**: UI state management (loading, progress, error, files)
+  - **useToolApiCalls**: HTTP requests and file processing
+  - **useToolResources**: Blob URLs, thumbnails, ZIP downloads
+
+- **Utilities**:
+  - **toolErrorHandler**: Standardized error extraction and i18n support
+  - **toolResponseProcessor**: API response handling (single/zip/custom)
+  - **toolOperationTracker**: FileContext integration utilities
+
+**Three Tool Patterns**:
+
+**Pattern 1: Single-File Tools** (Individual processing)
+- Backend processes one file per API call
+- Set `multiFileEndpoint: false`
+- Examples: Compress, Rotate
+```typescript
+return useToolOperation({
+  operationType: 'compress',
+  endpoint: '/api/v1/misc/compress-pdf',
+  buildFormData: (params, file: File) => { /* single file */ },
+  multiFileEndpoint: false,
+});
+```
+
+**Pattern 2: Multi-File Tools** (Batch processing)
+- Backend accepts `MultipartFile[]` arrays in single API call
+- Set `multiFileEndpoint: true`
+- Examples: Split, Merge, Overlay
+```typescript
+return useToolOperation({
+  operationType: 'split',
+  endpoint: '/api/v1/general/split-pages',
+  buildFormData: (params, files: File[]) => { /* all files */ },
+  multiFileEndpoint: true,
+  filePrefix: 'split_',
+});
+```
+
+**Pattern 3: Complex Tools** (Custom processing)
+- Tools with complex routing logic or non-standard processing
+- Provide `customProcessor` for full control
+- Examples: Convert, OCR
+```typescript
+return useToolOperation({
+  operationType: 'convert',
+  customProcessor: async (params, files) => { /* custom logic */ },
+});
+```
+
+**Benefits**:
+- **No Timeouts**: Operations run until completion (supports 100GB+ files)
+- **Consistent**: All tools follow same pattern and interface
+- **Maintainable**: Single responsibility hooks, easy to test and modify
+- **i18n Ready**: Built-in internationalization support
+- **Type Safe**: Full TypeScript support with generic interfaces
+- **Memory Safe**: Automatic resource cleanup and blob URL management
+
+## Architecture Overview
+
+### Project Structure
+- **Backend**: Spring Boot application
+- **Frontend**: React-based SPA in `/frontend` directory
+  - **File Storage**: IndexedDB for client-side file persistence and thumbnails
+  - **Internationalization**: JSON-based translations (converted from backend .properties)
+- **PDF Processing**: PDFBox for core PDF operations, LibreOffice for conversions, PDF.js for client-side rendering
+- **Security**: Spring Security with optional authentication (controlled by `DOCKER_ENABLE_SECURITY`)
+- **Configuration**: YAML-based configuration with environment variable overrides
+
+### Controller Architecture
+- **API Controllers** (`src/main/java/.../controller/api/`): REST endpoints for PDF operations
+  - Organized by function: converters, security, misc, pipeline
+  - Follow pattern: `@RestController` + `@RequestMapping("/api/v1/...")`
+
+### Key Components
+- **SPDFApplication.java**: Main application class with desktop UI and browser launching logic
+- **ConfigInitializer**: Handles runtime configuration and settings files
+- **Pipeline System**: Automated PDF processing workflows via `PipelineController`
+- **Security Layer**: Authentication, authorization, and user management (when enabled)
+
+### Frontend Directory Structure
+The frontend is organized with a clear separation of concerns:
+
+- **`frontend/src/core/`**: Main application code (shared, production-ready components)
+  - **`core/components/`**: React components organized by feature
+    - `core/components/tools/`: Individual PDF tool implementations
+    - `core/components/viewer/`: PDF viewer components
+    - `core/components/pageEditor/`: Page manipulation UI
+    - `core/components/tooltips/`: Help tooltips for tools
+    - `core/components/shared/`: Reusable UI components
+  - **`core/contexts/`**: React Context providers
+    - `FileContext.tsx`: Central file state management
+    - `file/`: File reducer and selectors
+    - `toolWorkflow/`: Tool workflow state
+  - **`core/hooks/`**: Custom React hooks
+    - `hooks/tools/`: Tool-specific operation hooks (one directory per tool)
+    - `hooks/tools/shared/`: Shared hook utilities (useToolOperation, etc.)
+  - **`core/constants/`**: Application constants and configuration
+  - **`core/data/`**: Static data (tool taxonomy, etc.)
+  - **`core/services/`**: Business logic services (PDF processing, storage, etc.)
+
+- **`frontend/src/desktop/`**: Desktop-specific (Tauri) code
+- **`frontend/src/proprietary/`**: Proprietary/licensed features
+- **`frontend/src-tauri/`**: Tauri (Rust) native desktop application code
+- **`frontend/public/`**: Static assets served directly
+  - `public/locales/`: Translation JSON files
+
+### Component Architecture
+- **Static Assets**: CSS, JS, and resources in `src/main/resources/static/` (legacy) + `frontend/public/` (modern)
+- **Internationalization**:
+  - Backend: `messages_*.properties` files
+  - Frontend: JSON files in `frontend/public/locales/` (converted from .properties)
+  - Conversion Script: `scripts/convert_properties_to_json.py`
+
+### Configuration Modes
+- **Ultra-lite**: Basic PDF operations only
+- **Standard**: Full feature set
+- **Fat**: Pre-downloaded dependencies for air-gapped environments
+- **Security Mode**: Adds authentication, user management, and enterprise features
+
+### Testing Strategy
+- **Integration Tests**: Cucumber tests in `testing/cucumber/`
+- **Docker Testing**: `test.sh` validates all Docker variants
+- **Manual Testing**: No unit tests currently - relies on UI and API testing
+
+## Development Workflow
+
+1. **Local Development**:
+   - Backend: `./gradlew bootRun` (runs on localhost:8080)
+   - Frontend: `cd frontend && npm run dev` (runs on localhost:5173, proxies to backend)
+2. **Docker Testing**: Use `./test.sh` before submitting PRs
+3. **Code Style**: Spotless enforces Google Java Format automatically
+4. **Translations**:
+   - Backend: Use helper scripts in `/scripts` for multi-language updates
+   - Frontend: Update JSON files in `frontend/public/locales/` or use conversion script
+5. **Documentation**: API docs auto-generated and available at `/swagger-ui/index.html`
+
+## Frontend Architecture Status
+
+- **Core Status**: React SPA architecture complete with multi-tool workflow support
+- **State Management**: FileContext handles all file operations and tool navigation
+- **File Processing**: Production-ready with memory management for large PDF workflows (up to 100GB+)
+- **Tool Integration**: Modular hook architecture with `useToolOperation` orchestrator
+  - Individual hooks: `useToolState`, `useToolApiCalls`, `useToolResources`
+  - Utilities: `toolErrorHandler`, `toolResponseProcessor`, `toolOperationTracker`
+  - Pattern: Each tool creates focused operation hook, UI consumes state/actions
+- **Preview System**: Tool results can be previewed without polluting file context (Split tool example)
+- **Performance**: Web Worker thumbnails, IndexedDB persistence, background processing
+
+## Translation Rules
+
+- **CRITICAL**: Always update translations in `en-GB` only, never `en-US`
+- Translation files are located in `frontend/public/locales/`
+
+## Important Notes
+
+- **Java Version**: Minimum JDK 17, supports and recommends JDK 21
+- **Lombok**: Used extensively - ensure IDE plugin is installed
+- **File Persistence**:
+  - **Backend**: Designed to be stateless - files are processed in memory/temp locations only
+  - **Frontend**: Uses IndexedDB for client-side file storage and caching (with thumbnails)
+- **Security**: When `DOCKER_ENABLE_SECURITY=false`, security-related classes are excluded from compilation
+- **Import Paths**: ALWAYS use `@app/*` for imports - never use `@core/*` or `@proprietary/*` unless explicitly wrapping/extending a lower layer
+- **FileContext**: All file operations MUST go through FileContext - never bypass with direct File handling
+- **Memory Management**: Manual cleanup required for PDF.js documents and blob URLs - don't remove cleanup code
+- **Tool Development**: New tools should follow `useToolOperation` hook pattern (see `useCompressOperation.ts`)
+- **Performance Target**: Must handle PDFs up to 100GB+ without browser crashes
+- **Preview System**: Tools can preview results without polluting main file context (see Split tool implementation)
+- **Adding Tools**: See `ADDING_TOOLS.md` for complete guide to creating new PDF tools
+
+## Communication Style
+- Be direct and to the point
+- No apologies or conversational filler
+- Answer questions directly without preamble
+- Explain reasoning concisely when asked
+- Avoid unnecessary elaboration
+
+## Decision Making
+- Ask clarifying questions before making assumptions
+- Stop and ask when uncertain about project-specific details
+- Confirm approach before making structural changes
+- Request guidance on preferences (cross-platform vs specific tools, etc.)
+- Verify understanding of requirements before proceeding
@@ -11,7 +11,7 @@ This guide focuses on developing for Stirling 2.0, including both the React fron
 **Stirling 2.0** is built using:

 **Backend:**
- Spring Boot (Java 21+, JDK 25 recommended)
+- Spring Boot (Java 17+, JDK 21 recommended)
 - PDFBox for core PDF operations
 - LibreOffice for document conversions
 - qpdf for PDF optimization
@@ -44,7 +44,7 @@ This guide focuses on developing for Stirling 2.0, including both the React fron

 - Docker
 - Git
- Java JDK 21 or later (JDK 25 recommended)
+- 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)
@@ -59,7 +59,7 @@ This guide focuses on developing for Stirling 2.0, including both the React fron
   cd Stirling-PDF
   ```

-2. Install Docker and JDK 21 (or JDK 25 recommended) if not already installed.
+2. Install Docker and JDK17 if not already installed.

 3. Install a recommended Java IDE such as Eclipse, IntelliJ, or VSCode
   1. Only VSCode
@@ -10,8 +10,6 @@ if that directory exists, is licensed under the license defined in "app/propriet
 if that directory exists, is licensed under the license defined in "frontend/src/proprietary/LICENSE".
 * All content that resides under the "frontend/src/desktop/" directory of this repository,
 if that directory exists, is licensed under the license defined in "frontend/src/desktop/LICENSE".
-* All content that resides under the "frontend/src/saas/" directory of this repository,
-if that directory exists, is licensed under the license defined in "frontend/src/saas/LICENSE".
 * Content outside of the above mentioned directories or restrictions above is
 available under the MIT License as defined below.

@@ -5,10 +5,10 @@ bootRun {
 spotless {
    java {
        target 'src/**/java/**/*.java'
-        targetExclude 'src/main/java/org/apache/**'
        googleJavaFormat(googleJavaFormatVersion).aosp().reorderImports(false)

        importOrder("java", "javax", "org", "com", "net", "io", "jakarta", "lombok", "me", "stirling")
+        toggleOffOn()
        trimTrailingWhitespace()
        leadingTabsToSpaces()
        endWithNewline()
@@ -27,7 +27,6 @@ spotless {
    }
 }
 dependencies {
-    api 'com.google.guava:guava:33.4.8-jre'
    api 'org.springframework.boot:spring-boot-starter-webmvc'
    api 'org.springframework.boot:spring-boot-starter-aspectj'
    api 'com.googlecode.owasp-java-html-sanitizer:owasp-java-html-sanitizer:20260102.1'
@@ -103,9 +103,8 @@ public class EndpointConfiguration {

        // Rule 2: Functional-group override - check if endpoint belongs to any disabled functional
        // group
-        for (Map.Entry<String, Set<String>> entry : endpointGroups.entrySet()) {
-            String group = entry.getKey();
-            if (disabledGroups.contains(group) && entry.getValue().contains(endpoint)) {
+        for (String group : endpointGroups.keySet()) {
+            if (disabledGroups.contains(group) && endpointGroups.get(group).contains(endpoint)) {
                // Skip tool groups (qpdf, OCRmyPDF, Ghostscript, LibreOffice, etc.)
                if (!isToolGroup(group)) {
                    log.debug(
@@ -132,11 +131,10 @@ public class EndpointConfiguration {

        // Rule 4: Single-dependency check - if no alternatives defined, check if endpoint belongs
        // to any disabled tool groups
-        for (Map.Entry<String, Set<String>> entry : endpointGroups.entrySet()) {
-            String group = entry.getKey();
+        for (String group : endpointGroups.keySet()) {
            if (isToolGroup(group)
                    && disabledGroups.contains(group)
-                    && entry.getValue().contains(endpoint)) {
+                    && endpointGroups.get(group).contains(endpoint)) {
                log.debug(
                        "isEndpointEnabled('{}') -> false (single tool group '{}' disabled, no alternatives)",
                        original,
@@ -647,9 +645,8 @@ public class EndpointConfiguration {
        }

        // Check if endpoint belongs to any disabled functional group
-        for (Map.Entry<String, Set<String>> entry : endpointGroups.entrySet()) {
-            String group = entry.getKey();
-            if (disabledGroups.contains(group) && entry.getValue().contains(endpoint)) {
+        for (String group : endpointGroups.keySet()) {
+            if (disabledGroups.contains(group) && endpointGroups.get(group).contains(endpoint)) {
                if (!isToolGroup(group)) {
                    return false;
                }
@@ -2,14 +2,12 @@ package stirling.software.common.aop;

 import java.io.IOException;
 import java.time.Duration;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Supplier;

 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.*;
-import org.slf4j.MDC;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Component;
 import org.springframework.web.multipart.MultipartFile;
@@ -28,7 +26,7 @@ import stirling.software.common.service.JobExecutorService;
@Component
@RequiredArgsConstructor
@Slf4j
-@Order(20) // Lower precedence - executes AFTER audit aspects populate MDC
+@Order(0) // Highest precedence - executes before audit aspects
 public class AutoJobAspect {

    private static final Duration RETRY_BASE_DELAY = Duration.ofMillis(100);
@@ -72,29 +70,26 @@ public class AutoJobAspect {
            // No retries needed, simple execution
            return jobExecutorService.runJobGeneric(
                    async,
-                    wrapWithMDC(
-                            () -> {
-                                try {
-                                    // Note: Progress tracking is handled in
-                                    // TaskManager/JobExecutorService
-                                    // The trackProgress flag controls whether detailed progress is
-                                    // stored
-                                    // for REST API queries, not WebSocket notifications
-                                    return joinPoint.proceed(args);
-                                } catch (Throwable ex) {
-                                    log.error(
-                                            "AutoJobAspect caught exception during job execution: {}",
-                                            ex.getMessage(),
-                                            ex);
-                                    // Rethrow RuntimeException as-is to preserve exception type
-                                    if (ex instanceof RuntimeException) {
-                                        throw (RuntimeException) ex;
-                                    }
-                                    // Wrap checked exceptions - GlobalExceptionHandler will unwrap
-                                    // BaseAppException
-                                    throw new RuntimeException(ex);
-                                }
-                            }),
+                    () -> {
+                        try {
+                            // Note: Progress tracking is handled in TaskManager/JobExecutorService
+                            // The trackProgress flag controls whether detailed progress is stored
+                            // for REST API queries, not WebSocket notifications
+                            return joinPoint.proceed(args);
+                        } catch (Throwable ex) {
+                            log.error(
+                                    "AutoJobAspect caught exception during job execution: {}",
+                                    ex.getMessage(),
+                                    ex);
+                            // Rethrow RuntimeException as-is to preserve exception type
+                            if (ex instanceof RuntimeException) {
+                                throw (RuntimeException) ex;
+                            }
+                            // Wrap checked exceptions - GlobalExceptionHandler will unwrap
+                            // BaseAppException
+                            throw new RuntimeException(ex);
+                        }
+                    },
                    timeout,
                    queueable,
                    resourceWeight);
@@ -128,108 +123,114 @@ public class AutoJobAspect {

        return jobExecutorService.runJobGeneric(
                async,
-                wrapWithMDC(
-                        () -> {
-                            // Use iterative approach instead of recursion to avoid stack overflow
-                            Throwable lastException = null;
+                () -> {
+                    // Use iterative approach instead of recursion to avoid stack overflow
+                    Throwable lastException = null;

-                            // Attempt counter starts at 1 for first try
-                            for (int currentAttempt = 1;
-                                    currentAttempt <= maxRetries;
-                                    currentAttempt++) {
-                                try {
-                                    if (trackProgress && async) {
-                                        // Get jobId for progress tracking in TaskManager
-                                        // This enables REST API progress queries, not WebSocket
-                                        if (jobIdRef.get() == null) {
-                                            jobIdRef.set(getJobIdFromContext());
-                                        }
-                                        String jobId = jobIdRef.get();
-                                        if (jobId != null) {
-                                            log.debug(
-                                                    "Tracking progress for job {} (attempt {}/{})",
-                                                    jobId,
-                                                    currentAttempt,
-                                                    maxRetries);
-                                            // Progress is tracked in TaskManager for REST API
-                                            // access
-                                            // No WebSocket notifications sent here
-                                        }
-                                    }
-
-                                    // Attempt to execute the operation
-                                    return joinPoint.proceed(args);
-
-                                } catch (Throwable ex) {
-                                    lastException = ex;
-                                    log.error(
-                                            "AutoJobAspect caught exception during job execution (attempt"
-                                                    + " {}/{}): {}",
+                    // Attempt counter starts at 1 for first try
+                    for (int currentAttempt = 1; currentAttempt <= maxRetries; currentAttempt++) {
+                        try {
+                            if (trackProgress && async) {
+                                // Get jobId for progress tracking in TaskManager
+                                // This enables REST API progress queries, not WebSocket
+                                if (jobIdRef.get() == null) {
+                                    jobIdRef.set(getJobIdFromContext());
+                                }
+                                String jobId = jobIdRef.get();
+                                if (jobId != null) {
+                                    log.debug(
+                                            "Tracking progress for job {} (attempt {}/{})",
+                                            jobId,
                                            currentAttempt,
-                                            maxRetries,
-                                            ex.getMessage(),
-                                            ex);
+                                            maxRetries);
+                                    // Progress is tracked in TaskManager for REST API access
+                                    // No WebSocket notifications sent here
+                                }
+                            }

-                                    // Check if we should retry
-                                    if (currentAttempt < maxRetries) {
-                                        log.info(
-                                                "Retrying operation, attempt {}/{}",
-                                                currentAttempt + 1,
-                                                maxRetries);
+                            // Attempt to execute the operation
+                            return joinPoint.proceed(args);

-                                        if (trackProgress && async) {
-                                            String jobId = jobIdRef.get();
-                                            if (jobId != null) {
-                                                log.debug(
-                                                        "Recording retry attempt for job {} in TaskManager",
-                                                        jobId);
-                                                // Retry info is tracked in TaskManager for REST API
-                                                // access
-                                            }
-                                        }
+                        } catch (Throwable ex) {
+                            lastException = ex;
+                            log.error(
+                                    "AutoJobAspect caught exception during job execution (attempt"
+                                            + " {}/{}): {}",
+                                    currentAttempt,
+                                    maxRetries,
+                                    ex.getMessage(),
+                                    ex);

-                                        // Use sleep for retry delay
-                                        // For sync jobs, both sleep and async are blocking at this
-                                        // point
-                                        // For async jobs, the delay occurs in the executor thread
-                                        long delayMs = RETRY_BASE_DELAY.toMillis() * currentAttempt;
+                            // Check if we should retry
+                            if (currentAttempt < maxRetries) {
+                                log.info(
+                                        "Retrying operation, attempt {}/{}",
+                                        currentAttempt + 1,
+                                        maxRetries);

-                                        try {
-                                            Thread.sleep(delayMs);
-                                        } catch (InterruptedException e) {
-                                            Thread.currentThread().interrupt();
-                                            log.debug(
-                                                    "Retry delay interrupted for attempt {}/{}",
-                                                    currentAttempt,
-                                                    maxRetries);
-                                            break;
-                                        }
-                                    } else {
-                                        // No more retries, we'll throw the exception after the loop
-                                        break;
+                                if (trackProgress && async) {
+                                    String jobId = jobIdRef.get();
+                                    if (jobId != null) {
+                                        log.debug(
+                                                "Recording retry attempt for job {} in TaskManager",
+                                                jobId);
+                                        // Retry info is tracked in TaskManager for REST API access
                                    }
                                }
-                            }

-                            // If we get here, all retries failed
-                            if (lastException != null) {
-                                // Rethrow RuntimeException as-is to preserve exception type
-                                if (lastException instanceof RuntimeException) {
-                                    throw (RuntimeException) lastException;
+                                // Use non-blocking delay for all retry attempts to avoid blocking
+                                // threads
+                                // For sync jobs this avoids starving the tomcat thread pool under
+                                // load
+                                long delayMs = RETRY_BASE_DELAY.toMillis() * currentAttempt;
+
+                                // Execute the retry after a delay through the JobExecutorService
+                                // rather than blocking the current thread with sleep
+                                CompletableFuture<Object> delayedRetry = new CompletableFuture<>();
+
+                                // Use a delayed executor for non-blocking delay
+                                CompletableFuture.delayedExecutor(delayMs, TimeUnit.MILLISECONDS)
+                                        .execute(
+                                                () -> {
+                                                    // Continue the retry loop in the next iteration
+                                                    // We can't return from here directly since
+                                                    // we're in a Runnable
+                                                    delayedRetry.complete(null);
+                                                });
+
+                                // Wait for the delay to complete before continuing
+                                try {
+                                    delayedRetry.join();
+                                } catch (Exception e) {
+                                    Thread.currentThread().interrupt();
+                                    break;
                                }
-                                // Wrap checked exceptions - GlobalExceptionHandler will unwrap
-                                // BaseAppException
-                                throw new RuntimeException(
-                                        "Job failed after "
-                                                + maxRetries
-                                                + " attempts: "
-                                                + lastException.getMessage(),
-                                        lastException);
+                            } else {
+                                // No more retries, we'll throw the exception after the loop
+                                break;
                            }
+                        }
+                    }

-                            // This should never happen if lastException is properly tracked
-                            throw new RuntimeException("Job failed but no exception was recorded");
-                        }),
+                    // If we get here, all retries failed
+                    if (lastException != null) {
+                        // Rethrow RuntimeException as-is to preserve exception type
+                        if (lastException instanceof RuntimeException) {
+                            throw (RuntimeException) lastException;
+                        }
+                        // Wrap checked exceptions - GlobalExceptionHandler will unwrap
+                        // BaseAppException
+                        throw new RuntimeException(
+                                "Job failed after "
+                                        + maxRetries
+                                        + " attempts: "
+                                        + lastException.getMessage(),
+                                lastException);
+                    }
+
+                    // This should never happen if lastException is properly tracked
+                    throw new RuntimeException("Job failed but no exception was recorded");
+                },
                timeout,
                queueable,
                resourceWeight);
@@ -298,32 +299,4 @@ public class AutoJobAspect {
            return null;
        }
    }
-
-    /**
-     * Wraps a supplier to propagate MDC context to background threads. Captures MDC on request
-     * thread and restores it in the background thread. Ensures proper cleanup to prevent context
-     * leakage across jobs in thread pools.
-     */
-    private <T> Supplier<T> wrapWithMDC(Supplier<T> supplier) {
-        final Map<String, String> captured = MDC.getCopyOfContextMap();
-        return () -> {
-            final Map<String, String> previous = MDC.getCopyOfContextMap();
-            try {
-                // Set the captured context (or clear if none was captured)
-                if (captured != null) {
-                    MDC.setContextMap(new HashMap<>(captured));
-                } else {
-                    MDC.clear();
-                }
-                return supplier.get();
-            } finally {
-                // Restore previous state (or clear if there was none)
-                if (previous != null) {
-                    MDC.setContextMap(previous);
-                } else {
-                    MDC.clear();
-                }
-            }
-        };
-    }
 }
@@ -365,11 +365,11 @@ public class ApplicationProperties {
            }

            public boolean isSettingsValid() {
-                return !ValidationUtils.isStringEmpty(this.issuer)
-                        && !ValidationUtils.isStringEmpty(this.clientId)
-                        && !ValidationUtils.isStringEmpty(this.clientSecret)
-                        && !ValidationUtils.isCollectionEmpty(this.scopes)
-                        && !ValidationUtils.isStringEmpty(this.useAsUsername);
+                return !ValidationUtils.isStringEmpty(this.getIssuer())
+                        && !ValidationUtils.isStringEmpty(this.getClientId())
+                        && !ValidationUtils.isStringEmpty(this.getClientSecret())
+                        && !ValidationUtils.isCollectionEmpty(this.getScopes())
+                        && !ValidationUtils.isStringEmpty(this.getUseAsUsername());
            }

            @Data
@@ -575,17 +575,19 @@ public class ApplicationProperties {
        }

        public boolean isAnalyticsEnabled() {
-            return this.enableAnalytics != null && this.enableAnalytics;
+            return this.getEnableAnalytics() != null && this.getEnableAnalytics();
        }

        public boolean isPosthogEnabled() {
            // Treat null as enabled when analytics is enabled
-            return this.isAnalyticsEnabled() && (this.enablePosthog == null || this.enablePosthog);
+            return this.isAnalyticsEnabled()
+                    && (this.getEnablePosthog() == null || this.getEnablePosthog());
        }

        public boolean isScarfEnabled() {
            // Treat null as enabled when analytics is enabled
-            return this.isAnalyticsEnabled() && (this.enableScarf == null || this.enableScarf);
+            return this.isAnalyticsEnabled()
+                    && (this.getEnableScarf() == null || this.getEnableScarf());
        }
    }

@@ -696,8 +698,7 @@ public class ApplicationProperties {

        @Override
        public String toString() {
-            return
-                    """
+            return """
            Driver {
              driverName='%s'
            }
@@ -713,7 +714,6 @@ public class ApplicationProperties {
        private String logoStyle = "classic"; // Options: "classic" (default) or "modern"
        private boolean defaultHideUnavailableTools = false;
        private boolean defaultHideUnavailableConversions = false;
-        private HideDisabledTools hideDisabledTools = new HideDisabledTools();

        public String getAppNameNavbar() {
            return appNameNavbar != null && !appNameNavbar.trim().isEmpty() ? appNameNavbar : null;
@@ -726,12 +726,6 @@ public class ApplicationProperties {
            }
            return "classic"; // default
        }
-
-        @Data
-        public static class HideDisabledTools {
-            private boolean googleDrive = false;
-            private boolean mobileQRScanner = false;
-        }
    }

    @Data
@@ -919,15 +913,6 @@ public class ApplicationProperties {
            private boolean ssoAutoLogin;
            private boolean database;
            private CustomMetadata customMetadata = new CustomMetadata();
-            private GoogleDrive googleDrive = new GoogleDrive();
-
-            @Data
-            public static class GoogleDrive {
-                private boolean enabled = false;
-                private String clientId = "";
-                private String apiKey = "";
-                private String appId = "";
-            }

            @Data
            public static class CustomMetadata {
@@ -977,12 +962,6 @@ public class ApplicationProperties {
                private boolean enabled = true;
                private int level = 2; // 0=OFF, 1=BASIC, 2=STANDARD, 3=VERBOSE
                private int retentionDays = 90;
-                private boolean captureFileHash =
-                        false; // Capture SHA-256 hash of files (increases processing time)
-                private boolean capturePdfAuthor =
-                        false; // Capture PDF author metadata (increases processing time)
-                private boolean captureOperationResults =
-                        false; // Capture operation return values (not recommended, high volume)
            }

            @Data
@@ -42,7 +42,7 @@ public enum Role {
        // Using the fromString method to get the Role enum based on the roleId
        Role role = fromString(roleId);
        // Return the roleName of the found Role enum
-        return role.roleName;
+        return role.getRoleName();
    }

    // Method to retrieve all role IDs and role names
@@ -50,14 +50,14 @@ public enum Role {
        // Using LinkedHashMap to preserve order
        Map<String, String> roleDetails = new LinkedHashMap<>();
        for (Role role : Role.values()) {
-            roleDetails.put(role.roleId, role.roleName);
+            roleDetails.put(role.getRoleId(), role.getRoleName());
        }
        return roleDetails;
    }

    public static Role fromString(String roleId) {
        for (Role role : Role.values()) {
-            if (role.roleId.equalsIgnoreCase(roleId)) {
+            if (role.getRoleId().equalsIgnoreCase(roleId)) {
                return role;
            }
        }
@@ -117,13 +117,13 @@ public class Provider {
                + ", clientName="
                + getClientName()
                + ", clientId="
-                + clientId
+                + getClientId()
                + ", clientSecret="
-                + (clientSecret != null && !clientSecret.isEmpty() ? "*****" : "NULL")
+                + (getClientSecret() != null && !getClientSecret().isEmpty() ? "*****" : "NULL")
                + ", scopes="
                + getScopes()
                + ", useAsUsername="
-                + useAsUsername
+                + getUseAsUsername()
                + "]";
    }
 }
@@ -1,8 +1,6 @@
 package stirling.software.common.service;

-import java.io.BufferedInputStream;
 import java.io.IOException;
-import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.UUID;
@@ -23,9 +21,6 @@ import lombok.extern.slf4j.Slf4j;
@Slf4j
 public class FileStorage {

-    /** Holds the result of a stream-to-disk store operation: the file ID and the bytes written. */
-    public record StoredFile(String fileId, long size) {}
-
    @Value("${stirling.tempDir:/tmp/stirling-files}")
    private String tempDirPath;

@@ -109,40 +104,6 @@ public class FileStorage {
        return Files.readAllBytes(filePath);
    }

-    /**
-     * Retrieve a file by its ID as a streaming InputStream. The caller is responsible for closing
-     * the returned stream.
-     *
-     * @param fileId The ID of the file to retrieve
-     * @return A buffered InputStream for the file
-     * @throws IOException If the file doesn't exist or can't be read
-     */
-    public InputStream retrieveInputStream(String fileId) throws IOException {
-        Path filePath = getFilePath(fileId);
-        // Let Files.newInputStream throw NoSuchFileException naturally — avoids TOCTOU race
-        // between exists-check and open when another thread may delete concurrently.
-        return new BufferedInputStream(Files.newInputStream(filePath));
-    }
-
-    /**
-     * Store data from an InputStream as a file and return its unique ID and byte count. Streams
-     * directly to disk without buffering the entire content in heap.
-     *
-     * @param inputStream The input stream to read from
-     * @param originalName The original name of the file (unused, kept for API symmetry)
-     * @return A {@link StoredFile} containing the file ID and the number of bytes written
-     * @throws IOException If there is an error storing the file
-     */
-    public StoredFile storeInputStream(InputStream inputStream, String originalName)
-            throws IOException {
-        String fileId = generateFileId();
-        Path filePath = getFilePath(fileId);
-        Files.createDirectories(filePath.getParent());
-        long size = Files.copy(inputStream, filePath);
-        log.debug("Stored input stream with ID: {}", fileId);
-        return new StoredFile(fileId, size);
-    }
-
    /**
     * Delete a file by its ID
     *
@@ -316,7 +316,7 @@ public class JobExecutorService {
                            filename =
                                    disposition.substring(
                                            disposition.indexOf("filename=") + 9,
-                                            disposition.lastIndexOf('"'));
+                                            disposition.lastIndexOf("\""));
                        }
                    }

@@ -129,7 +129,7 @@ public class MobileScannerService {
                        FILE_EXTENSION_PATTERN.matcher(safeFilename).replaceFirst("");
                String ext =
                        safeFilename.contains(".")
-                                ? safeFilename.substring(safeFilename.lastIndexOf('.'))
+                                ? safeFilename.substring(safeFilename.lastIndexOf("."))
                                : "";
                safeFilename = nameWithoutExt + "-" + counter + ext;
                filePath = sessionDir.resolve(safeFilename).normalize().toAbsolutePath();
@@ -1,8 +1,8 @@
 package stirling.software.common.service;

-import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.io.InputStream;
 import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
@@ -19,6 +19,7 @@ import java.util.zip.ZipInputStream;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;

 import io.github.pixee.security.ZipSecurity;

@@ -362,29 +363,39 @@ public class TaskManager {
            String zipFileId, String originalZipFileName) throws IOException {
        List<ResultFile> extractedFiles = new ArrayList<>();

-        try (InputStream fileStream = fileStorage.retrieveInputStream(zipFileId);
-                ZipInputStream zipIn =
-                        ZipSecurity.createHardenedInputStream(
-                                new BufferedInputStream(fileStream))) {
+        MultipartFile zipFile = fileStorage.retrieveFile(zipFileId);
+
+        try (ZipInputStream zipIn =
+                ZipSecurity.createHardenedInputStream(
+                        new ByteArrayInputStream(zipFile.getBytes()))) {
            ZipEntry entry;
            while ((entry = zipIn.getNextEntry()) != null) {
                if (!entry.isDirectory()) {
+                    // Use buffered reading for memory safety
+                    ByteArrayOutputStream out = new ByteArrayOutputStream();
+                    byte[] buffer = new byte[4096];
+                    int bytesRead;
+                    while ((bytesRead = zipIn.read(buffer)) != -1) {
+                        out.write(buffer, 0, bytesRead);
+                    }
+                    byte[] fileContent = out.toByteArray();
+
                    String contentType = determineContentType(entry.getName());
-                    // storeInputStream returns the fileId and byte count — no extra stat needed
-                    FileStorage.StoredFile stored =
-                            fileStorage.storeInputStream(zipIn, entry.getName());
+                    String individualFileId = fileStorage.storeBytes(fileContent, entry.getName());

                    ResultFile resultFile =
                            ResultFile.builder()
-                                    .fileId(stored.fileId())
+                                    .fileId(individualFileId)
                                    .fileName(entry.getName())
                                    .contentType(contentType)
-                                    .fileSize(stored.size())
+                                    .fileSize(fileContent.length)
                                    .build();

                    extractedFiles.add(resultFile);
                    log.debug(
-                            "Extracted file: {} (size: {} bytes)", entry.getName(), stored.size());
+                            "Extracted file: {} (size: {} bytes)",
+                            entry.getName(),
+                            fileContent.length);
                }
                zipIn.closeEntry();
            }
@@ -456,24 +467,4 @@ public class TaskManager {
        }
        return null;
    }
-
-    /**
-     * Find the job key that owns a given file ID.
-     *
-     * @param fileId file identifier to look up
-     * @return scoped job key if found, otherwise null
-     */
-    public String findJobKeyByFileId(String fileId) {
-        for (Map.Entry<String, JobResult> entry : jobResults.entrySet()) {
-            JobResult jobResult = entry.getValue();
-            if (jobResult.hasFiles()) {
-                for (ResultFile resultFile : jobResult.getAllResultFiles()) {
-                    if (fileId.equals(resultFile.getFileId())) {
-                        return entry.getKey();
-                    }
-                }
-            }
-        }
-        return null;
-    }
 }
@@ -4,7 +4,6 @@ import java.io.BufferedInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Enumeration;
@@ -31,7 +30,15 @@ import stirling.software.common.service.CustomPDFDocumentFactory;
@UtilityClass
 public class CbzUtils {

-    public TempFile convertCbzToPdf(
+    public byte[] convertCbzToPdf(
+            MultipartFile cbzFile,
+            CustomPDFDocumentFactory pdfDocumentFactory,
+            TempFileManager tempFileManager)
+            throws IOException {
+        return convertCbzToPdf(cbzFile, pdfDocumentFactory, tempFileManager, false);
+    }
+
+    public byte[] convertCbzToPdf(
            MultipartFile cbzFile,
            CustomPDFDocumentFactory pdfDocumentFactory,
            TempFileManager tempFileManager,
@@ -57,90 +64,70 @@ public class CbzUtils {

            try (PDDocument document = pdfDocumentFactory.createNewDocument();
                    ZipFile zipFile = new ZipFile(tempFile.getFile())) {
-
-                // Pass 1: collect sorted image names (cheap just strings, no image data)
-                List<String> sortedImageNames = new ArrayList<>();
                Enumeration<? extends ZipEntry> entries = zipFile.entries();
+                List<ImageEntryData> imageEntries = new ArrayList<>();
                while (entries.hasMoreElements()) {
                    ZipEntry entry = entries.nextElement();
                    if (!entry.isDirectory() && isImageFile(entry.getName())) {
-                        sortedImageNames.add(entry.getName());
+                        try (InputStream is = zipFile.getInputStream(entry)) {
+                            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                            is.transferTo(baos);
+                            imageEntries.add(
+                                    new ImageEntryData(entry.getName(), baos.toByteArray()));
+                        } catch (IOException e) {
+                            log.warn("Error reading image {}: {}", entry.getName(), e.getMessage());
+                        }
                    }
                }
-                sortedImageNames.sort(new NaturalOrderComparator());

-                if (sortedImageNames.isEmpty()) {
+                imageEntries.sort(
+                        Comparator.comparing(ImageEntryData::name, new NaturalOrderComparator()));
+
+                if (imageEntries.isEmpty()) {
                    throw ExceptionUtils.createCbzNoImagesException();
                }

-                // Pass 2: load ONE image at a time peak memory = max(single image)
-                for (String imageName : sortedImageNames) {
-                    ZipEntry entry = zipFile.getEntry(imageName);
-                    try (InputStream is = zipFile.getInputStream(entry)) {
-                        ByteArrayOutputStream imgBaos = new ByteArrayOutputStream();
-                        is.transferTo(imgBaos);
-                        byte[] imageBytes = imgBaos.toByteArray();
-                        try {
-                            PDImageXObject pdImage =
-                                    PDImageXObject.createFromByteArray(
-                                            document, imageBytes, imageName);
-                            PDPage page =
-                                    new PDPage(
-                                            new PDRectangle(
-                                                    pdImage.getWidth(), pdImage.getHeight()));
-                            document.addPage(page);
-                            try (PDPageContentStream contentStream =
-                                    new PDPageContentStream(
-                                            document,
-                                            page,
-                                            PDPageContentStream.AppendMode.OVERWRITE,
-                                            true,
-                                            true)) {
-                                contentStream.drawImage(pdImage, 0, 0);
-                            }
-                        } catch (IOException e) {
-                            log.warn("Error processing image {}: {}", imageName, e.getMessage());
+                for (ImageEntryData imageEntry : imageEntries) {
+                    try {
+                        PDImageXObject pdImage =
+                                PDImageXObject.createFromByteArray(
+                                        document, imageEntry.data(), imageEntry.name());
+                        PDPage page =
+                                new PDPage(
+                                        new PDRectangle(pdImage.getWidth(), pdImage.getHeight()));
+                        document.addPage(page);
+                        try (PDPageContentStream contentStream =
+                                new PDPageContentStream(
+                                        document,
+                                        page,
+                                        PDPageContentStream.AppendMode.OVERWRITE,
+                                        true,
+                                        true)) {
+                            contentStream.drawImage(pdImage, 0, 0);
                        }
-                        // imageBytes eligible for GC after each iteration
                    } catch (IOException e) {
-                        log.warn("Error reading image {}: {}", imageName, e.getMessage());
+                        log.warn(
+                                "Error processing image {}: {}", imageEntry.name(), e.getMessage());
                    }
                }

                if (document.getNumberOfPages() == 0) {
                    throw ExceptionUtils.createCbzCorruptedImagesException();
                }
+                ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                document.save(baos);
+                byte[] pdfBytes = baos.toByteArray();

-                // Write to TempFile (not BAOS)
-                TempFile pdfTempFile = new TempFile(tempFileManager, ".pdf");
-                try {
-                    document.save(pdfTempFile.getFile());
-
-                    if (optimizeForEbook) {
-                        try {
-                            byte[] pdfBytes = Files.readAllBytes(pdfTempFile.getPath());
-                            byte[] optimized = GeneralUtils.optimizePdfWithGhostscript(pdfBytes);
-                            pdfTempFile.close();
-                            TempFile optimizedFile = new TempFile(tempFileManager, ".pdf");
-                            try {
-                                Files.write(optimizedFile.getPath(), optimized);
-                                return optimizedFile;
-                            } catch (Exception e) {
-                                optimizedFile.close();
-                                throw e;
-                            }
-                        } catch (IOException e) {
-                            log.warn(
-                                    "Ghostscript optimization failed, returning unoptimized PDF",
-                                    e);
-                        }
+                // Apply Ghostscript optimization if requested
+                if (optimizeForEbook) {
+                    try {
+                        return GeneralUtils.optimizePdfWithGhostscript(pdfBytes);
+                    } catch (IOException e) {
+                        log.warn("Ghostscript optimization failed, returning unoptimized PDF", e);
                    }
-
-                    return pdfTempFile;
-                } catch (Exception e) {
-                    pdfTempFile.close();
-                    throw e;
                }
+
+                return pdfBytes;
            }
        }
    }
@@ -188,6 +175,8 @@ public class CbzUtils {
        return RegexPatternUtils.getInstance().getImageFilePattern().matcher(filename).matches();
    }

+    private record ImageEntryData(String name, byte[] data) {}
+
    private class NaturalOrderComparator implements Comparator<String> {
        @Override
        public int compare(String s1, String s2) {
@@ -341,8 +341,7 @@ public class EmlProcessingUtils {
    }

    private String getFallbackStyles() {
-        return
-        """
+        return """
            /* Minimal fallback - main CSS resource failed to load */
            body {
                font-family: var(--font-family, Helvetica, sans-serif);
@@ -44,7 +44,9 @@ public class FileToPdf {
                            sanitizeHtmlContent(
                                    new String(fileBytes, StandardCharsets.UTF_8),
                                    customHtmlSanitizer);
-                    Files.writeString(tempInputFile.getPath(), sanitizedHtml);
+                    Files.write(
+                            tempInputFile.getPath(),
+                            sanitizedHtml.getBytes(StandardCharsets.UTF_8));
                } else if (fileName.toLowerCase(Locale.ROOT).endsWith(".zip")) {
                    Files.write(tempInputFile.getPath(), fileBytes);
                    sanitizeHtmlFilesInZip(
@@ -113,7 +115,8 @@ public class FileToPdf {
                                    new String(zipIn.readAllBytes(), StandardCharsets.UTF_8);
                            String sanitizedContent =
                                    sanitizeHtmlContent(content, customHtmlSanitizer);
-                            Files.writeString(filePath, sanitizedContent);
+                            Files.write(
+                                    filePath, sanitizedContent.getBytes(StandardCharsets.UTF_8));
                        } else {
                            Files.copy(zipIn, filePath);
                        }
@@ -17,7 +17,6 @@ import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
-import java.util.regex.Pattern;

 import org.apache.pdfbox.cos.COSArray;
 import org.apache.pdfbox.cos.COSBase;
@@ -75,10 +74,6 @@ public class FormUtils {
     */
    private static final float SAME_LINE_THRESHOLD_PT = 10.0f;

-    private static final Pattern HEX_UUID_PATTERN =
-            Pattern.compile("^[0-9a-fA-F]{8}[0-9a-fA-F]{24,}$");
-    private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\s+");
-
    /**
     * Returns a normalized logical type string for the supplied PDFBox field instance. Centralized
     * so all callers share identical mapping logic.
@@ -1362,7 +1357,7 @@ public class FormUtils {
            if (da != null && !da.isBlank()) {
                // Standard DA looks like: /Helv 12 Tf 0 g
                // We want the number before 'Tf'
-                String[] tokens = WHITESPACE_PATTERN.split(da);
+                String[] tokens = da.split("\\s+");
                for (int i = 0; i < tokens.length; i++) {
                    if ("Tf".equals(tokens[i]) && i > 0) {
                        try {
@@ -1462,8 +1457,9 @@ public class FormUtils {
        // Detect UUID-like hex strings (e.g. "cdc47b7041524571 7b2d93017fe77bf7")
        // Standard UUIDs are 32 hex characters; require at least that to avoid
        // false positives on short hex-like field names.
-        String nospaces = WHITESPACE_PATTERN.matcher(simplified).replaceAll("");
-        if (nospaces.length() >= 32 && HEX_UUID_PATTERN.matcher(nospaces).matches()) return true;
+        String nospaces = simplified.replaceAll("\\s+", "");
+        if (nospaces.length() >= 32 && nospaces.matches("^[0-9a-fA-F]{8}[0-9a-fA-F]{24,}$"))
+            return true;

        return patterns.getGenericFieldNamePattern().matcher(simplified).matches()
                || patterns.getSimpleFormFieldPattern().matcher(simplified).matches()
@@ -873,36 +873,6 @@ public class GeneralUtils {
        settingsYaml.saveOverride(settingsPath);
    }

-    /**
-     * Updates multiple settings in a single transaction. This ensures that nested settings (e.g.,
-     * oauth2.client.google.*) don't lose sibling values when partial updates are made.
-     *
-     * <p>Instead of multiple read-update-write cycles (which could cause race conditions), this
-     * method loads the YAML once, applies all updates, and saves once.
-     *
-     * @param settingsMap Map of dotted-notation keys to values to update
-     * @throws IOException if file read/write fails
-     */
-    public void updateSettingsTransactional(Map<String, Object> settingsMap) throws IOException {
-        if (settingsMap == null || settingsMap.isEmpty()) {
-            return;
-        }
-
-        Path settingsPath = Paths.get(InstallationPathConfig.getSettingsPath());
-        YamlHelper settingsYaml = new YamlHelper(settingsPath);
-
-        // Apply all updates to the same YamlHelper instance
-        for (Map.Entry<String, Object> entry : settingsMap.entrySet()) {
-            String key = entry.getKey();
-            Object value = entry.getValue();
-            String[] keyArray = key.split("\\.");
-            settingsYaml.updateValue(Arrays.asList(keyArray), value);
-        }
-
-        // Save only once after all updates are applied
-        settingsYaml.saveOverride(settingsPath);
-    }
-
    /*
     * Machine fingerprint generation with better error logging and fallbacks.
     *
@@ -10,7 +10,6 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
-import java.util.regex.Pattern;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;

@@ -34,8 +33,6 @@ import stirling.software.common.util.ProcessExecutor.ProcessExecutorResult;
@Slf4j
 public class PDFToFile {

-    private static final Pattern PATTERN =
-            Pattern.compile("(!\\[.*?\\])\\((?!images/)([^/)][^)]*?)\\)");
    private final TempFileManager tempFileManager;
    private final RuntimePathConfig runtimePathConfig;

@@ -166,7 +163,7 @@ public class PDFToFile {
    private String updateImageReferences(String markdown) {
        // Match markdown image syntax: ![alt text](image.png)
        // Only update if the path doesn't already start with images/
-        return PATTERN.matcher(markdown).replaceAll("$1(images/$2)");
+        return markdown.replaceAll("(!\\[.*?\\])\\((?!images/)([^/)][^)]*?)\\)", "$1(images/$2)");
    }

    public ResponseEntity<byte[]> processPdfToHtml(MultipartFile inputFile)
@@ -1,8 +1,8 @@
 package stirling.software.common.util;

 import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.nio.file.Files;
 import java.util.Locale;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
@@ -22,11 +22,8 @@ import stirling.software.common.service.CustomPDFDocumentFactory;
@Slf4j
 public class PdfToCbzUtils {

-    public static TempFile convertPdfToCbz(
-            MultipartFile pdfFile,
-            int dpi,
-            CustomPDFDocumentFactory pdfDocumentFactory,
-            TempFileManager tempFileManager)
+    public static byte[] convertPdfToCbz(
+            MultipartFile pdfFile, int dpi, CustomPDFDocumentFactory pdfDocumentFactory)
            throws IOException {

        validatePdfFile(pdfFile);
@@ -36,7 +33,7 @@ public class PdfToCbzUtils {
                throw ExceptionUtils.createPdfNoPages();
            }

-            return createCbzFromPdf(document, dpi, tempFileManager);
+            return createCbzFromPdf(document, dpi);
        }
    }

@@ -56,49 +53,46 @@ public class PdfToCbzUtils {
        }
    }

-    private static TempFile createCbzFromPdf(
-            PDDocument document, int dpi, TempFileManager tempFileManager) throws IOException {
+    private static byte[] createCbzFromPdf(PDDocument document, int dpi) throws IOException {
        PDFRenderer pdfRenderer = new PDFRenderer(document);
        pdfRenderer.setSubsamplingAllowed(true); // Enable subsampling to reduce memory usage

-        TempFile cbzTempFile = new TempFile(tempFileManager, ".cbz");
-        try {
-            try (ZipOutputStream zipOut =
-                    new ZipOutputStream(Files.newOutputStream(cbzTempFile.getPath()))) {
+        try (ByteArrayOutputStream cbzOutputStream = new ByteArrayOutputStream();
+                ZipOutputStream zipOut = new ZipOutputStream(cbzOutputStream)) {

-                int totalPages = document.getNumberOfPages();
+            int totalPages = document.getNumberOfPages();

-                for (int pageIndex = 0; pageIndex < totalPages; pageIndex++) {
-                    final int currentPage = pageIndex;
-                    try {
-                        BufferedImage image =
-                                ExceptionUtils.handleOomRendering(
-                                        currentPage + 1,
-                                        dpi,
-                                        () ->
-                                                pdfRenderer.renderImageWithDPI(
-                                                        currentPage, dpi, ImageType.RGB));
+            for (int pageIndex = 0; pageIndex < totalPages; pageIndex++) {
+                final int currentPage = pageIndex;
+                try {
+                    BufferedImage image =
+                            ExceptionUtils.handleOomRendering(
+                                    currentPage + 1,
+                                    dpi,
+                                    () ->
+                                            pdfRenderer.renderImageWithDPI(
+                                                    currentPage, dpi, ImageType.RGB));

-                        String imageFilename =
-                                String.format(Locale.ROOT, "page_%03d.png", currentPage + 1);
-                        zipOut.putNextEntry(new ZipEntry(imageFilename));
-                        ImageIO.write(image, "PNG", zipOut);
-                        zipOut.closeEntry();
+                    String imageFilename =
+                            String.format(Locale.ROOT, "page_%03d.png", currentPage + 1);
+                    ZipEntry zipEntry = new ZipEntry(imageFilename);
+                    zipOut.putNextEntry(zipEntry);

-                    } catch (ExceptionUtils.OutOfMemoryDpiException e) {
-                        // Re-throw OOM exceptions without wrapping
-                        throw e;
-                    } catch (IOException e) {
-                        // Wrap other IOExceptions with context
-                        throw ExceptionUtils.createFileProcessingException(
-                                "CBZ creation for page " + (currentPage + 1), e);
-                    }
+                    ImageIO.write(image, "PNG", zipOut);
+                    zipOut.closeEntry();
+
+                } catch (ExceptionUtils.OutOfMemoryDpiException e) {
+                    // Re-throw OOM exceptions without wrapping
+                    throw e;
+                } catch (IOException e) {
+                    // Wrap other IOExceptions with context
+                    throw ExceptionUtils.createFileProcessingException(
+                            "CBZ creation for page " + (currentPage + 1), e);
                }
            }
-            return cbzTempFile;
-        } catch (Exception e) {
-            cbzTempFile.close();
-            throw e;
+
+            zipOut.finish();
+            return cbzOutputStream.toByteArray();
        }
    }

@@ -219,31 +219,58 @@ public class PdfUtils {
                    int maxWidth = 0;
                    int totalHeight = 0;

-                    // Using a map to store the calculated dimensions of each page size
+                    BufferedImage pdfSizeImage = null;
+                    int pdfSizeImageIndex = -1;
+
+                    // Using a map to store the rendered dimensions of each page size
+                    // to avoid rendering the same page sizes multiple times
                    HashMap<PdfRenderSettingsKey, PdfImageDimensionValue> pageSizes =
                            new HashMap<>();
                    for (int i = 0; i < pageCount; ++i) {
+                        final int pageIndex = i;
                        PDPage page = document.getPage(i);
-                        PDRectangle cropBox = page.getCropBox();
+                        PDRectangle mediaBox = page.getMediaBox();
                        int rotation = page.getRotation();
                        PdfRenderSettingsKey settings =
                                new PdfRenderSettingsKey(
-                                        cropBox.getWidth(), cropBox.getHeight(), rotation);
+                                        mediaBox.getWidth(), mediaBox.getHeight(), rotation);
                        PdfImageDimensionValue dimension = pageSizes.get(settings);
                        if (dimension == null) {
-                            float scale = DPI / 72f;
-                            int widthPx = (int) Math.max(Math.floor(cropBox.getWidth() * scale), 1);
-                            int heightPx =
-                                    (int) Math.max(Math.floor(cropBox.getHeight() * scale), 1);
-                            if (rotation == 90 || rotation == 270) {
-                                int tmp = widthPx;
-                                widthPx = heightPx;
-                                heightPx = tmp;
+                            // Render the image to get the dimensions
+                            try {
+                                // Validate dimensions before rendering
+                                ExceptionUtils.validateRenderingDimensions(
+                                        page, pageIndex + 1, DPI);
+
+                                pdfSizeImage =
+                                        ExceptionUtils.handleOomRendering(
+                                                pageIndex + 1,
+                                                DPI,
+                                                () ->
+                                                        pdfRenderer.renderImageWithDPI(
+                                                                pageIndex, DPI, colorType));
+                            } catch (IllegalArgumentException e) {
+                                if (e.getMessage() != null
+                                        && e.getMessage()
+                                                .contains("Maximum size of image exceeded")) {
+                                    throw ExceptionUtils.createIllegalArgumentException(
+                                            "error.pageTooBigExceedsArray",
+                                            "PDF page {0} is too large to render at {1} DPI. The"
+                                                    + " resulting image would exceed Java's maximum"
+                                                    + " array size. Please try a lower DPI value"
+                                                    + " (recommended: 150 or less).",
+                                            i + 1,
+                                            DPI);
+                                }
+                                throw e;
                            }
-                            dimension = new PdfImageDimensionValue(widthPx, heightPx);
+                            pdfSizeImageIndex = i;
+                            dimension =
+                                    new PdfImageDimensionValue(
+                                            pdfSizeImage.getWidth(), pdfSizeImage.getHeight());
                            pageSizes.put(settings, dimension);
-                            if (widthPx > maxWidth) {
-                                maxWidth = widthPx;
+                            if (pdfSizeImage.getWidth() > maxWidth) {
+                                maxWidth = pdfSizeImage.getWidth();
                            }
                        }
                        totalHeight += dimension.height();
@@ -257,32 +284,40 @@ public class PdfUtils {
                    int currentHeight = 0;
                    BufferedImage pageImage;

+                    // Check if the first image is the last rendered image
+                    boolean firstImageAlreadyRendered = pdfSizeImageIndex == 0;
+
                    for (int i = 0; i < pageCount; ++i) {
                        final int pageIndex = i;
-                        try {
-                            // Validate dimensions before rendering
-                            ExceptionUtils.validateRenderingDimensions(
-                                    document.getPage(pageIndex), pageIndex + 1, DPI);
+                        if (firstImageAlreadyRendered && i == 0) {
+                            pageImage = pdfSizeImage;
+                        } else {
+                            try {
+                                // Validate dimensions before rendering
+                                ExceptionUtils.validateRenderingDimensions(
+                                        document.getPage(pageIndex), pageIndex + 1, DPI);

-                            pageImage =
-                                    ExceptionUtils.handleOomRendering(
-                                            pageIndex + 1,
-                                            DPI,
-                                            () ->
-                                                    pdfRenderer.renderImageWithDPI(
-                                                            pageIndex, DPI, colorType));
-                        } catch (IllegalArgumentException e) {
-                            if (e.getMessage() != null
-                                    && e.getMessage().contains("Maximum size of image exceeded")) {
-                                throw ExceptionUtils.createIllegalArgumentException(
-                                        "error.pageTooBigForDpi",
-                                        "PDF page {0} is too large to render at {1} DPI. Please"
-                                                + " try a lower DPI value (recommended: 150 or"
-                                                + " less).",
-                                        i + 1,
-                                        DPI);
+                                pageImage =
+                                        ExceptionUtils.handleOomRendering(
+                                                pageIndex + 1,
+                                                DPI,
+                                                () ->
+                                                        pdfRenderer.renderImageWithDPI(
+                                                                pageIndex, DPI, colorType));
+                            } catch (IllegalArgumentException e) {
+                                if (e.getMessage() != null
+                                        && e.getMessage()
+                                                .contains("Maximum size of image exceeded")) {
+                                    throw ExceptionUtils.createIllegalArgumentException(
+                                            "error.pageTooBigForDpi",
+                                            "PDF page {0} is too large to render at {1} DPI. Please"
+                                                    + " try a lower DPI value (recommended: 150 or"
+                                                    + " less).",
+                                            i + 1,
+                                            DPI);
+                                }
+                                throw e;
                            }
-                            throw e;
                        }

                        // Calculate the x-coordinate to center the image
@@ -191,7 +191,7 @@ public class YamlHelper {
            mappingNode.getValue().clear();
            mappingNode.getValue().addAll(updatedTuples);
        }
-        updatedRootNode = node;
+        setNewNode(node);

        return updated;
    }
@@ -19,7 +19,7 @@ public abstract class ReplaceAndInvertColorStrategy extends PDFFile {

    public ReplaceAndInvertColorStrategy(MultipartFile file, ReplaceAndInvert replaceAndInvert) {
        setFileInput(file);
-        this.replaceAndInvert = replaceAndInvert;
+        setReplaceAndInvert(replaceAndInvert);
    }

    public abstract InputStreamResource replace() throws IOException;
@@ -12,10 +12,11 @@ configurations {
 spotless {
    java {
        target 'src/**/java/**/*.java'
-        targetExclude 'src/main/resources/static/**', 'src/main/java/org/apache/**'
+        targetExclude 'src/main/resources/static/**'
        googleJavaFormat(googleJavaFormatVersion).aosp().reorderImports(false)

        importOrder("java", "javax", "org", "com", "net", "io", "jakarta", "lombok", "me", "stirling")
+        toggleOffOn()
        trimTrailingWhitespace()
        leadingTabsToSpaces()
        endWithNewline()
@@ -81,7 +82,7 @@ dependencies {
    // veraPDF still uses javax.xml.bind, not the new jakarta namespace
    implementation 'javax.xml.bind:jaxb-api:2.3.1'
    implementation 'com.sun.xml.bind:jaxb-impl:2.3.9'
-    implementation 'com.sun.xml.bind:jaxb-core:4.0.6'
+    implementation 'com.sun.xml.bind:jaxb-core:2.3.0.1'
    implementation 'org.apache.poi:poi-ooxml:5.5.1'

    // https://mvnrepository.com/artifact/technology.tabula/tabula
@@ -90,7 +91,7 @@ dependencies {
        exclude group: 'org.bouncycastle', module: 'bcprov-jdk15on'
        exclude group: 'com.google.code.gson', module: 'gson'
    }
-    // CVE-2022-25647: Explicit gson 2.13.2 to prevent unsafe deserialization (tabula would pull 2.8.7)
+    // CVE-2022-25647: Explicit gson 2.8.9 to prevent unsafe deserialization (tabula would pull 2.8.7)
    implementation 'com.google.code.gson:gson:2.13.2'
    implementation 'org.apache.pdfbox:jbig2-imageio:3.0.4'
    implementation 'com.opencsv:opencsv:5.12.0' // https://mvnrepository.com/artifact/com.opencsv/opencsv
@@ -99,8 +100,6 @@ dependencies {
    // Batik only bridge module needed (transitively pulls anim, gvt, util, css, dom, svg-dom)
    // Replaces batik-all which included unused codec, svggen, transcoder, script modules
    implementation 'org.apache.xmlgraphics:batik-bridge:1.19'
-    // Required by TwelveMonkeys imageio-batik SPI (SVGImageReaderSpi) during ImageIO init
-    runtimeOnly 'org.apache.xmlgraphics:batik-transcoder:1.19'

    // PDFBox Graphics2D bridge for Batik SVG to PDF conversion
    implementation 'de.rototor.pdfbox:graphics2d:3.0.5'
@@ -88,10 +88,10 @@ public abstract class CreateSignatureBase implements SignatureInterface {
        Certificate cert = null;
        while (cert == null && aliases.hasMoreElements()) {
            alias = aliases.nextElement();
-            privateKey = (PrivateKey) keystore.getKey(alias, pin);
+            setPrivateKey((PrivateKey) keystore.getKey(alias, pin));
            Certificate[] certChain = keystore.getCertificateChain(alias);
            if (certChain != null) {
-                certificateChain = certChain;
+                setCertificateChain(certChain);
                cert = certChain[0];
                if (cert instanceof X509Certificate) {
                    // avoid expired certificate
@@ -134,7 +134,7 @@ public class SPDFApplication {
        baseUrlStatic = normalizeBackendUrl(backendUrl, serverPort);
        contextPathStatic = contextPath;
        serverPortStatic = serverPort;
-        String url = buildFullUrl(baseUrlStatic, serverPortStatic, contextPathStatic);
+        String url = buildFullUrl(baseUrlStatic, getStaticPort(), contextPathStatic);

        // Log Tauri mode information
        if (Boolean.parseBoolean(System.getProperty("STIRLING_PDF_TAURI_MODE", "false"))) {
@@ -188,7 +188,7 @@ public class SPDFApplication {

    private static void printStartupLogs() {
        log.info("Stirling-PDF Started.");
-        String url = buildFullUrl(baseUrlStatic, serverPortStatic, contextPathStatic);
+        String url = buildFullUrl(baseUrlStatic, getStaticPort(), contextPathStatic);
        log.info("Navigate to {}", url);
    }

@@ -104,7 +104,7 @@ public class EndpointInspector implements ApplicationListener<ContextRefreshedEv
            String infoString = mappingInfo.toString();
            if (infoString.contains("{")) {
                String patternsSection =
-                        infoString.substring(infoString.indexOf('{') + 1, infoString.indexOf('}'));
+                        infoString.substring(infoString.indexOf("{") + 1, infoString.indexOf("}"));

                for (String pattern : patternsSection.split(",")) {
                    pattern = pattern.trim();
@@ -24,7 +24,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.model.api.general.CropPdfForm;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
@@ -119,12 +118,6 @@ public class CropController {
        return r >= threshold && g >= threshold && b >= threshold;
    }

-    private final EndpointConfiguration endpointConfiguration;
-
-    private boolean isGhostscriptEnabled() {
-        return endpointConfiguration.isGroupEnabled("Ghostscript");
-    }
-
    @AutoJobPostMapping(value = "/crop", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    @Operation(
            summary = "Crops a PDF document",
@@ -144,7 +137,7 @@ public class CropController {
                    "Crop coordinates (x, y, width, height) are required when auto-crop is not enabled");
        }

-        if (request.isRemoveDataOutsideCrop() && isGhostscriptEnabled()) {
+        if (request.isRemoveDataOutsideCrop()) {
            return cropWithGhostscript(request);
        } else {
            return cropWithPDFBox(request);
@@ -1,7 +1,7 @@
 package stirling.software.SPDF.controller.api;

+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.nio.file.Files;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.zip.ZipEntry;
@@ -14,10 +14,10 @@ import org.apache.pdfbox.pdmodel.PDPageContentStream;
 import org.apache.pdfbox.pdmodel.common.PDRectangle;
 import org.apache.pdfbox.pdmodel.graphics.form.PDFormXObject;
 import org.apache.pdfbox.util.Matrix;
+import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

 import io.swagger.v3.oas.annotations.Operation;

@@ -31,8 +31,6 @@ import stirling.software.common.annotations.api.GeneralApi;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
-import stirling.software.common.util.TempFile;
-import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;

@GeneralApi
@@ -41,9 +39,10 @@ import stirling.software.common.util.WebResponseUtils;
 public class PosterPdfController {

    private final CustomPDFDocumentFactory pdfDocumentFactory;
-    private final TempFileManager tempFileManager;

-    @AutoJobPostMapping(value = "/split-for-poster-print", consumes = "multipart/form-data")
+    @AutoJobPostMapping(
+            value = "/split-for-poster-print",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    @MultiFileResponse
    @Operation(
            summary = "Split large PDF pages into smaller printable chunks",
@@ -52,7 +51,7 @@ public class PosterPdfController {
                            + "suitable for printing on standard paper sizes (e.g., A4, Letter). "
                            + "Divides each page into a grid of smaller pages using Apache PDFBox. "
                            + "Input: PDF Output: ZIP-PDF Type: SISO")
-    public ResponseEntity<StreamingResponseBody> posterPdf(@ModelAttribute PosterPdfRequest request)
+    public ResponseEntity<byte[]> posterPdf(@ModelAttribute PosterPdfRequest request)
            throws Exception {

        log.debug("Starting PDF poster split process with request: {}", request);
@@ -61,187 +60,184 @@ public class PosterPdfController {
        String filename = GeneralUtils.generateFilename(file.getOriginalFilename(), "");
        log.debug("Base filename for output: {}", filename);

-        TempFile zipTempFile = new TempFile(tempFileManager, ".zip");
-        try {
-            try (PDDocument sourceDocument = pdfDocumentFactory.load(file);
-                    PDDocument outputDocument =
-                            pdfDocumentFactory.createNewDocumentBasedOnOldDocument(sourceDocument);
-                    TempFile pdfTempFile = new TempFile(tempFileManager, ".pdf")) {
+        try (PDDocument sourceDocument = pdfDocumentFactory.load(file);
+                PDDocument outputDocument =
+                        pdfDocumentFactory.createNewDocumentBasedOnOldDocument(sourceDocument);
+                ByteArrayOutputStream pdfOutputStream = new ByteArrayOutputStream();
+                ByteArrayOutputStream zipOutputStream = new ByteArrayOutputStream()) {

-                // Get target page size
-                PDRectangle targetPageSize = getTargetPageSize(request.getPageSize());
-                log.debug(
-                        "Target page size: {} ({}x{})",
-                        request.getPageSize(),
-                        targetPageSize.getWidth(),
-                        targetPageSize.getHeight());
+            // Get target page size
+            PDRectangle targetPageSize = getTargetPageSize(request.getPageSize());
+            log.debug(
+                    "Target page size: {} ({}x{})",
+                    request.getPageSize(),
+                    targetPageSize.getWidth(),
+                    targetPageSize.getHeight());

-                // Create LayerUtility for importing pages as forms
-                LayerUtility layerUtility = new LayerUtility(outputDocument);
+            // Create LayerUtility for importing pages as forms
+            LayerUtility layerUtility = new LayerUtility(outputDocument);

-                int totalPages = sourceDocument.getNumberOfPages();
-                int xFactor = request.getXFactor();
-                int yFactor = request.getYFactor();
-                boolean rightToLeft = request.isRightToLeft();
+            int totalPages = sourceDocument.getNumberOfPages();
+            int xFactor = request.getXFactor();
+            int yFactor = request.getYFactor();
+            boolean rightToLeft = request.isRightToLeft();
+
+            log.debug(
+                    "Processing {} pages with grid {}x{}, RTL={}",
+                    totalPages,
+                    xFactor,
+                    yFactor,
+                    rightToLeft);
+
+            // Process each page
+            for (int pageIndex = 0; pageIndex < totalPages; pageIndex++) {
+                PDPage sourcePage = sourceDocument.getPage(pageIndex);
+
+                // Get both MediaBox and CropBox
+                PDRectangle mediaBox = sourcePage.getMediaBox();
+                PDRectangle cropBox = sourcePage.getCropBox();
+
+                // If no CropBox is set, use MediaBox
+                if (cropBox == null) {
+                    cropBox = mediaBox;
+                }
+
+                // Save original boxes for restoration
+                PDRectangle originalMediaBox = sourcePage.getMediaBox();
+                PDRectangle originalCropBox = sourcePage.getCropBox();
+
+                // Normalize the page: set MediaBox to CropBox
+                // This ensures the form's coordinate space starts at (0, 0)
+                // instead of having an offset from the original MediaBox
+                sourcePage.setMediaBox(cropBox);
+                sourcePage.setCropBox(cropBox);
+
+                // Handle page rotation
+                int rotation = sourcePage.getRotation();
+                float sourceWidth = cropBox.getWidth();
+                float sourceHeight = cropBox.getHeight();
+
+                // Swap dimensions if rotated 90 or 270 degrees
+                if (rotation == 90 || rotation == 270) {
+                    float temp = sourceWidth;
+                    sourceWidth = sourceHeight;
+                    sourceHeight = temp;
+                }

                log.debug(
-                        "Processing {} pages with grid {}x{}, RTL={}",
-                        totalPages,
-                        xFactor,
-                        yFactor,
-                        rightToLeft);
+                        "Page {}: Normalized to CropBox dimensions {}x{}, rotation {}",
+                        pageIndex,
+                        sourceWidth,
+                        sourceHeight,
+                        rotation);

-                // Process each page
-                for (int pageIndex = 0; pageIndex < totalPages; pageIndex++) {
-                    PDPage sourcePage = sourceDocument.getPage(pageIndex);
+                // Import source page as form (now with normalized coordinate space)
+                PDFormXObject form = layerUtility.importPageAsForm(sourceDocument, pageIndex);

-                    // Get both MediaBox and CropBox
-                    PDRectangle mediaBox = sourcePage.getMediaBox();
-                    PDRectangle cropBox = sourcePage.getCropBox();
+                // Restore original boxes
+                sourcePage.setMediaBox(originalMediaBox);
+                sourcePage.setCropBox(originalCropBox);

-                    // If no CropBox is set, use MediaBox
-                    if (cropBox == null) {
-                        cropBox = mediaBox;
-                    }
+                // Calculate cell dimensions in source page coordinates
+                float cellWidth = sourceWidth / xFactor;
+                float cellHeight = sourceHeight / yFactor;

-                    // Save original boxes for restoration
-                    PDRectangle originalMediaBox = sourcePage.getMediaBox();
-                    PDRectangle originalCropBox = sourcePage.getCropBox();
+                // Create grid cells (rows × columns)
+                for (int row = 0; row < yFactor; row++) {
+                    for (int col = 0; col < xFactor; col++) {
+                        // Apply RTL ordering for columns if enabled
+                        int actualCol = rightToLeft ? (xFactor - 1 - col) : col;

-                    // Normalize the page: set MediaBox to CropBox
-                    // This ensures the form's coordinate space starts at (0, 0)
-                    // instead of having an offset from the original MediaBox
-                    sourcePage.setMediaBox(cropBox);
-                    sourcePage.setCropBox(cropBox);
+                        // Calculate crop rectangle in source coordinates
+                        // PDF coordinates start at bottom-left
+                        float cropX = actualCol * cellWidth;
+                        // For Y: invert so row 0 shows TOP (following SplitPdfBySectionsController
+                        // pattern)
+                        float cropY = (yFactor - 1 - row) * cellHeight;

-                    // Handle page rotation
-                    int rotation = sourcePage.getRotation();
-                    float sourceWidth = cropBox.getWidth();
-                    float sourceHeight = cropBox.getHeight();
+                        // Create new output page with target size
+                        PDPage outputPage = new PDPage(targetPageSize);
+                        outputDocument.addPage(outputPage);

-                    // Swap dimensions if rotated 90 or 270 degrees
-                    if (rotation == 90 || rotation == 270) {
-                        float temp = sourceWidth;
-                        sourceWidth = sourceHeight;
-                        sourceHeight = temp;
-                    }
+                        try (PDPageContentStream contentStream =
+                                new PDPageContentStream(
+                                        outputDocument,
+                                        outputPage,
+                                        PDPageContentStream.AppendMode.APPEND,
+                                        true,
+                                        true)) {

-                    log.debug(
-                            "Page {}: Normalized to CropBox dimensions {}x{}, rotation {}",
-                            pageIndex,
-                            sourceWidth,
-                            sourceHeight,
-                            rotation);
+                            // Calculate uniform scale to fit cell into target page
+                            // Scale UP if cell is smaller than target, scale DOWN if larger
+                            float scaleX = targetPageSize.getWidth() / cellWidth;
+                            float scaleY = targetPageSize.getHeight() / cellHeight;
+                            float scale = Math.min(scaleX, scaleY);

-                    // Import source page as form (now with normalized coordinate space)
-                    PDFormXObject form = layerUtility.importPageAsForm(sourceDocument, pageIndex);
+                            // Center the scaled content on the target page
+                            float scaledCellWidth = cellWidth * scale;
+                            float scaledCellHeight = cellHeight * scale;
+                            float offsetX = (targetPageSize.getWidth() - scaledCellWidth) / 2;
+                            float offsetY = (targetPageSize.getHeight() - scaledCellHeight) / 2;

-                    // Restore original boxes
-                    sourcePage.setMediaBox(originalMediaBox);
-                    sourcePage.setCropBox(originalCropBox);
+                            // Apply transformations
+                            contentStream.saveGraphicsState();

-                    // Calculate cell dimensions in source page coordinates
-                    float cellWidth = sourceWidth / xFactor;
-                    float cellHeight = sourceHeight / yFactor;
+                            // Translate to center position
+                            contentStream.transform(Matrix.getTranslateInstance(offsetX, offsetY));

-                    // Create grid cells (rows × columns)
-                    for (int row = 0; row < yFactor; row++) {
-                        for (int col = 0; col < xFactor; col++) {
-                            // Apply RTL ordering for columns if enabled
-                            int actualCol = rightToLeft ? (xFactor - 1 - col) : col;
+                            // Scale uniformly
+                            contentStream.transform(Matrix.getScaleInstance(scale, scale));

-                            // Calculate crop rectangle in source coordinates
-                            // PDF coordinates start at bottom-left
-                            float cropX = actualCol * cellWidth;
-                            // For Y: invert so row 0 shows TOP (following
-                            // SplitPdfBySectionsController
-                            // pattern)
-                            float cropY = (yFactor - 1 - row) * cellHeight;
+                            // Translate to show only the desired grid cell
+                            // IMPORTANT: The PDFormXObject's BBox already matches the CropBox
+                            // (including its offset), so we only need to translate by cropX/cropY
+                            // relative to the CropBox origin, NOT the MediaBox origin
+                            contentStream.transform(Matrix.getTranslateInstance(-cropX, -cropY));

-                            // Create new output page with target size
-                            PDPage outputPage = new PDPage(targetPageSize);
-                            outputDocument.addPage(outputPage);
+                            // Draw the form
+                            contentStream.drawForm(form);

-                            try (PDPageContentStream contentStream =
-                                    new PDPageContentStream(
-                                            outputDocument,
-                                            outputPage,
-                                            PDPageContentStream.AppendMode.APPEND,
-                                            true,
-                                            true)) {
-
-                                // Calculate uniform scale to fit cell into target page
-                                // Scale UP if cell is smaller than target, scale DOWN if larger
-                                float scaleX = targetPageSize.getWidth() / cellWidth;
-                                float scaleY = targetPageSize.getHeight() / cellHeight;
-                                float scale = Math.min(scaleX, scaleY);
-
-                                // Center the scaled content on the target page
-                                float scaledCellWidth = cellWidth * scale;
-                                float scaledCellHeight = cellHeight * scale;
-                                float offsetX = (targetPageSize.getWidth() - scaledCellWidth) / 2;
-                                float offsetY = (targetPageSize.getHeight() - scaledCellHeight) / 2;
-
-                                // Apply transformations
-                                contentStream.saveGraphicsState();
-
-                                // Translate to center position
-                                contentStream.transform(
-                                        Matrix.getTranslateInstance(offsetX, offsetY));
-
-                                // Scale uniformly
-                                contentStream.transform(Matrix.getScaleInstance(scale, scale));
-
-                                // Translate to show only the desired grid cell
-                                // IMPORTANT: The PDFormXObject's BBox already matches the CropBox
-                                // (including its offset), so we only need to translate by
-                                // cropX/cropY
-                                // relative to the CropBox origin, NOT the MediaBox origin
-                                contentStream.transform(
-                                        Matrix.getTranslateInstance(-cropX, -cropY));
-
-                                // Draw the form
-                                contentStream.drawForm(form);
-
-                                contentStream.restoreGraphicsState();
-                            }
-
-                            log.trace(
-                                    "Created output page for grid cell [{},{}] of page {}: cropX={}, cropY={}, translate=({}, {})",
-                                    row,
-                                    actualCol,
-                                    pageIndex,
-                                    cropX,
-                                    cropY,
-                                    -cropX,
-                                    -cropY);
+                            contentStream.restoreGraphicsState();
                        }
+
+                        log.trace(
+                                "Created output page for grid cell [{},{}] of page {}: cropX={}, cropY={}, translate=({}, {})",
+                                row,
+                                actualCol,
+                                pageIndex,
+                                cropX,
+                                cropY,
+                                -cropX,
+                                -cropY);
                    }
                }
-
-                // Save output PDF to intermediate TempFile
-                outputDocument.save(pdfTempFile.getFile());
-                log.debug("Generated output PDF with {} pages", outputDocument.getNumberOfPages());
-
-                // Create ZIP from the PDF TempFile, streaming directly to zip TempFile
-                try (ZipOutputStream zipOut =
-                        new ZipOutputStream(Files.newOutputStream(zipTempFile.getPath()))) {
-                    zipOut.putNextEntry(new ZipEntry(filename + "_poster.pdf"));
-                    Files.copy(pdfTempFile.getPath(), zipOut);
-                    zipOut.closeEntry();
-                }
-                // pdfTempFile auto-closed and deleted here (end of inner try-with-resources)
            }

-            log.debug("Successfully created ZIP");
-            return WebResponseUtils.zipFileToWebResponse(zipTempFile, filename + "_poster.zip");
+            // Save output PDF
+            outputDocument.save(pdfOutputStream);
+            byte[] pdfData = pdfOutputStream.toByteArray();
+
+            log.debug(
+                    "Generated output PDF with {} pages ({} bytes)",
+                    outputDocument.getNumberOfPages(),
+                    pdfData.length);
+
+            // Create ZIP file with the result
+            try (ZipOutputStream zipOut = new ZipOutputStream(zipOutputStream)) {
+                ZipEntry zipEntry = new ZipEntry(filename + "_poster.pdf");
+                zipOut.putNextEntry(zipEntry);
+                zipOut.write(pdfData);
+                zipOut.closeEntry();
+            }
+
+            byte[] zipData = zipOutputStream.toByteArray();
+            log.debug("Successfully created ZIP with {} bytes", zipData.length);
+
+            return WebResponseUtils.bytesToWebResponse(
+                    zipData, filename + "_poster.zip", MediaType.APPLICATION_OCTET_STREAM);

        } catch (IOException e) {
            ExceptionUtils.logException("PDF poster split process", e);
-            zipTempFile.close();
-            throw e;
-        } catch (Exception e) {
-            zipTempFile.close();
            throw e;
        }
    }
@@ -1,5 +1,6 @@
 package stirling.software.SPDF.controller.api;

+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.ArrayList;
@@ -9,11 +10,11 @@ import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;

 import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

 import io.swagger.v3.oas.annotations.Operation;

@@ -48,60 +49,83 @@ public class SplitPDFController {
                            + " specified page numbers or ranges. Users can specify pages using"
                            + " individual numbers, ranges, or 'all' for every page. Input:PDF"
                            + " Output:PDF Type:SIMO")
-    public ResponseEntity<StreamingResponseBody> splitPdf(@ModelAttribute PDFWithPageNums request)
+    public ResponseEntity<byte[]> splitPdf(@ModelAttribute PDFWithPageNums request)
            throws IOException {

        MultipartFile file = request.getFileInput();
-        TempFile outputTempFile = new TempFile(tempFileManager, ".zip");
-        try {
-            try (PDDocument document = pdfDocumentFactory.load(file)) {
-                int totalPages = document.getNumberOfPages();
-                List<Integer> pageNumbers = request.getPageNumbersList(document, false);
-                if (!pageNumbers.contains(totalPages - 1)) {
-                    pageNumbers = new ArrayList<>(pageNumbers);
-                    pageNumbers.add(totalPages - 1);
-                }

-                log.debug(
-                        "Splitting PDF into pages: {}",
-                        pageNumbers.stream().map(String::valueOf).collect(Collectors.joining(",")));
+        try (TempFile outputTempFile = new TempFile(tempFileManager, ".zip");
+                PDDocument document = pdfDocumentFactory.load(file)) {

-                String baseFilename = GeneralUtils.removeExtension(file.getOriginalFilename());
-                try (ZipOutputStream zipOut =
-                        new ZipOutputStream(Files.newOutputStream(outputTempFile.getPath()))) {
-                    int previousPageNumber = 0;
-                    for (int splitIndex = 0; splitIndex < pageNumbers.size(); splitIndex++) {
-                        int splitPoint = pageNumbers.get(splitIndex);
-                        try (PDDocument splitDocument =
-                                pdfDocumentFactory.createNewDocumentBasedOnOldDocument(document)) {
-                            for (int i = previousPageNumber; i <= splitPoint; i++) {
-                                splitDocument.addPage(document.getPage(i));
-                                log.debug("Adding page {} to split document", i);
-                            }
-                            previousPageNumber = splitPoint + 1;
+            List<ByteArrayOutputStream> splitDocumentsBoas = new ArrayList<>();

-                            String fileName = baseFilename + "_" + (splitIndex + 1) + ".pdf";
-                            zipOut.putNextEntry(new ZipEntry(fileName));
-                            splitDocument.save(zipOut);
-                            zipOut.closeEntry();
-                            log.debug("Wrote split document {} to zip file", fileName);
-                        } catch (Exception e) {
-                            ExceptionUtils.logException("document splitting and saving", e);
-                            throw e;
-                        }
+            int totalPages = document.getNumberOfPages();
+            List<Integer> pageNumbers = request.getPageNumbersList(document, false);
+            if (!pageNumbers.contains(totalPages - 1)) {
+                // Create a mutable ArrayList so we can add to it
+                pageNumbers = new ArrayList<>(pageNumbers);
+                pageNumbers.add(totalPages - 1);
+            }
+
+            log.debug(
+                    "Splitting PDF into pages: {}",
+                    pageNumbers.stream().map(String::valueOf).collect(Collectors.joining(",")));
+
+            splitDocumentsBoas = new ArrayList<>(pageNumbers.size());
+            int previousPageNumber = 0;
+            for (int splitPoint : pageNumbers) {
+                try (PDDocument splitDocument =
+                                pdfDocumentFactory.createNewDocumentBasedOnOldDocument(document);
+                        ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
+                    for (int i = previousPageNumber; i <= splitPoint; i++) {
+                        PDPage page = document.getPage(i);
+                        splitDocument.addPage(page);
+                        log.debug("Adding page {} to split document", i);
                    }
+                    previousPageNumber = splitPoint + 1;
+
+                    // Transfer metadata to split pdf
+                    // PdfMetadataService.setMetadataToPdf(splitDocument, metadata);
+
+                    splitDocument.save(baos);
+                    splitDocumentsBoas.add(baos);
+                } catch (Exception e) {
+                    ExceptionUtils.logException("document splitting and saving", e);
+                    throw e;
+                }
+            }
+
+            String baseFilename = GeneralUtils.removeExtension(file.getOriginalFilename());
+
+            try (ZipOutputStream zipOut =
+                    new ZipOutputStream(Files.newOutputStream(outputTempFile.getPath()))) {
+                int splitDocumentsSize = splitDocumentsBoas.size();
+                for (int i = 0; i < splitDocumentsSize; i++) {
+                    StringBuilder sb = new StringBuilder(baseFilename.length() + 10);
+                    sb.append(baseFilename).append('_').append(i + 1).append(".pdf");
+                    String fileName = sb.toString();
+
+                    ByteArrayOutputStream baos = splitDocumentsBoas.get(i);
+                    byte[] pdf = baos.toByteArray();
+
+                    ZipEntry pdfEntry = new ZipEntry(fileName);
+                    zipOut.putNextEntry(pdfEntry);
+                    zipOut.write(pdf);
+                    zipOut.closeEntry();
+
+                    log.debug("Wrote split document {} to zip file", fileName);
                }
            }

            log.debug(
                    "Successfully created zip file with split documents: {}",
                    outputTempFile.getPath().toString());
+            byte[] data = Files.readAllBytes(outputTempFile.getPath());
+
            String zipFilename =
                    GeneralUtils.generateFilename(file.getOriginalFilename(), "_split.zip");
-            return WebResponseUtils.zipFileToWebResponse(outputTempFile, zipFilename);
-        } catch (Exception e) {
-            outputTempFile.close();
-            throw e;
+            return WebResponseUtils.bytesToWebResponse(
+                    data, zipFilename, MediaType.APPLICATION_OCTET_STREAM);
        }
    }
 }
@@ -1,6 +1,8 @@
 package stirling.software.SPDF.controller.api;

+import java.io.ByteArrayOutputStream;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
@@ -15,7 +17,6 @@ import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

 import io.swagger.v3.oas.annotations.Operation;

@@ -35,8 +36,6 @@ import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.service.PdfMetadataService;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
-import stirling.software.common.util.TempFile;
-import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;

@GeneralApi
@@ -48,8 +47,6 @@ public class SplitPdfByChaptersController {

    private final CustomPDFDocumentFactory pdfDocumentFactory;

-    private final TempFileManager tempFileManager;
-
    private static List<Bookmark> extractOutlineItems(
            PDDocument sourceDocument,
            PDOutlineItem current,
@@ -125,19 +122,22 @@ public class SplitPdfByChaptersController {
    @Operation(
            summary = "Split PDFs by Chapters",
            description = "Splits a PDF into chapters and returns a ZIP file.")
-    public ResponseEntity<StreamingResponseBody> splitPdf(
-            @ModelAttribute SplitPdfByChaptersRequest request) throws Exception {
+    public ResponseEntity<byte[]> splitPdf(@ModelAttribute SplitPdfByChaptersRequest request)
+            throws Exception {
        MultipartFile file = request.getFileInput();
+        PDDocument sourceDocument = null;
+        Path zipFile = null;

-        boolean includeMetadata = Boolean.TRUE.equals(request.getIncludeMetadata());
-        Integer bookmarkLevel =
-                request.getBookmarkLevel(); // levels start from 0 (top most bookmarks)
-        if (bookmarkLevel < 0) {
-            throw ExceptionUtils.createIllegalArgumentException(
-                    "error.invalidArgument", "Invalid argument: {0}", "bookmark level");
-        }
+        try {
+            boolean includeMetadata = Boolean.TRUE.equals(request.getIncludeMetadata());
+            Integer bookmarkLevel =
+                    request.getBookmarkLevel(); // levels start from 0 (top most bookmarks)
+            if (bookmarkLevel < 0) {
+                throw ExceptionUtils.createIllegalArgumentException(
+                        "error.invalidArgument", "Invalid argument: {0}", "bookmark level");
+            }
+            sourceDocument = pdfDocumentFactory.load(file);

-        try (PDDocument sourceDocument = pdfDocumentFactory.load(file)) {
            PDDocumentOutline outline = sourceDocument.getDocumentCatalog().getDocumentOutline();

            if (outline == null) {
@@ -157,10 +157,12 @@ public class SplitPdfByChaptersController {
                                bookmarkLevel);
                // to handle last page edge case
                bookmarks.get(bookmarks.size() - 1).setEndPage(sourceDocument.getNumberOfPages());
+                Bookmark lastBookmark = bookmarks.get(bookmarks.size() - 1);

            } catch (Exception e) {
                ExceptionUtils.logException("outline extraction", e);
-                throw e;
+                return ResponseEntity.internalServerError()
+                        .body("Unable to extract outline items".getBytes());
            }

            boolean allowDuplicates = Boolean.TRUE.equals(request.getAllowDuplicates());
@@ -179,10 +181,29 @@ public class SplitPdfByChaptersController {
                        bookmark.getStartPage(),
                        bookmark.getEndPage());
            }
+            List<ByteArrayOutputStream> splitDocumentsBoas =
+                    getSplitDocumentsBoas(sourceDocument, bookmarks, includeMetadata);
+
+            zipFile = createZipFile(bookmarks, splitDocumentsBoas);
+
+            byte[] data = Files.readAllBytes(zipFile);
+            Files.deleteIfExists(zipFile);

-            TempFile zipTempFile = createZipFile(sourceDocument, bookmarks, includeMetadata);
            String filename = GeneralUtils.generateFilename(file.getOriginalFilename(), "");
-            return WebResponseUtils.zipFileToWebResponse(zipTempFile, filename + ".zip");
+            sourceDocument.close();
+            return WebResponseUtils.bytesToWebResponse(
+                    data, filename + ".zip", MediaType.APPLICATION_OCTET_STREAM);
+        } finally {
+            try {
+                if (sourceDocument != null) {
+                    sourceDocument.close();
+                }
+                if (zipFile != null) {
+                    Files.deleteIfExists(zipFile);
+                }
+            } catch (Exception e) {
+                log.error("Error while cleaning up resources", e);
+            }
        }
    }

@@ -211,55 +232,72 @@ public class SplitPdfByChaptersController {
        return bookmarks;
    }

-    private TempFile createZipFile(
-            PDDocument sourceDocument, List<Bookmark> bookmarks, boolean includeMetadata)
+    private Path createZipFile(
+            List<Bookmark> bookmarks, List<ByteArrayOutputStream> splitDocumentsBoas)
            throws Exception {
-        PdfMetadata metadata =
-                includeMetadata ? pdfMetadataService.extractMetadataFromPdf(sourceDocument) : null;
+        Path zipFile = Files.createTempFile("split_documents", ".zip");
        String fileNumberFormatter = "%0" + (Integer.toString(bookmarks.size()).length()) + "d ";
-        TempFile zipTempFile = new TempFile(tempFileManager, ".zip");
-        try {
-            try (ZipOutputStream zipOut =
-                    new ZipOutputStream(Files.newOutputStream(zipTempFile.getPath()))) {
-                for (int i = 0; i < bookmarks.size(); i++) {
-                    Bookmark bookmark = bookmarks.get(i);
-                    try (PDDocument splitDocument = new PDDocument()) {
-                        boolean isSinglePage = (bookmark.getStartPage() == bookmark.getEndPage());
+        try (ZipOutputStream zipOut = new ZipOutputStream(Files.newOutputStream(zipFile))) {
+            for (int i = 0; i < splitDocumentsBoas.size(); i++) {

-                        for (int pg = bookmark.getStartPage();
-                                pg < bookmark.getEndPage() + (isSinglePage ? 1 : 0);
-                                pg++) {
-                            PDPage page = sourceDocument.getPage(pg);
-                            splitDocument.addPage(page);
-                            log.debug("Adding page {} to split document", pg);
-                        }
-                        if (includeMetadata) {
-                            pdfMetadataService.setMetadataToPdf(splitDocument, metadata);
-                        }
+                // split files will be named as "[FILE_NUMBER] [BOOKMARK_TITLE].pdf"

-                        // split files will be named as "[FILE_NUMBER] [BOOKMARK_TITLE].pdf"
-                        String fileName =
-                                String.format(Locale.ROOT, fileNumberFormatter, i)
-                                        + bookmark.getTitle()
-                                        + ".pdf";
-                        zipOut.putNextEntry(new ZipEntry(fileName));
-                        splitDocument.save(zipOut);
-                        zipOut.closeEntry();
-                        log.debug("Wrote split document {} to zip file", fileName);
-                    } catch (Exception e) {
-                        ExceptionUtils.logException("document splitting and saving", e);
-                        throw e;
-                    }
-                }
+                String fileName =
+                        String.format(Locale.ROOT, fileNumberFormatter, i)
+                                + bookmarks.get(i).getTitle()
+                                + ".pdf";
+                ByteArrayOutputStream baos = splitDocumentsBoas.get(i);
+                byte[] pdf = baos.toByteArray();
+
+                ZipEntry pdfEntry = new ZipEntry(fileName);
+                zipOut.putNextEntry(pdfEntry);
+                zipOut.write(pdf);
+                zipOut.closeEntry();
+
+                log.debug("Wrote split document {} to zip file", fileName);
            }
-            log.info(
-                    "Successfully created zip file with split documents: {}",
-                    zipTempFile.getPath());
-            return zipTempFile;
        } catch (Exception e) {
-            zipTempFile.close();
+            log.error("Failed writing to zip", e);
            throw e;
        }
+
+        log.info("Successfully created zip file with split documents: {}", zipFile);
+        return zipFile;
+    }
+
+    public List<ByteArrayOutputStream> getSplitDocumentsBoas(
+            PDDocument sourceDocument, List<Bookmark> bookmarks, boolean includeMetadata)
+            throws Exception {
+        List<ByteArrayOutputStream> splitDocumentsBoas = new ArrayList<>();
+        PdfMetadata metadata = null;
+        if (includeMetadata) {
+            metadata = pdfMetadataService.extractMetadataFromPdf(sourceDocument);
+        }
+        for (Bookmark bookmark : bookmarks) {
+            try (PDDocument splitDocument = new PDDocument()) {
+                boolean isSinglePage = (bookmark.getStartPage() == bookmark.getEndPage());
+
+                for (int i = bookmark.getStartPage();
+                        i < bookmark.getEndPage() + (isSinglePage ? 1 : 0);
+                        i++) {
+                    PDPage page = sourceDocument.getPage(i);
+                    splitDocument.addPage(page);
+                    log.debug("Adding page {} to split document", i);
+                }
+                ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                if (includeMetadata) {
+                    pdfMetadataService.setMetadataToPdf(splitDocument, metadata);
+                }
+
+                splitDocument.save(baos);
+
+                splitDocumentsBoas.add(baos);
+            } catch (Exception e) {
+                ExceptionUtils.logException("document splitting and saving", e);
+                throw e;
+            }
+        }
+        return splitDocumentsBoas;
    }
 }

@@ -3,6 +3,7 @@ package stirling.software.SPDF.controller.api;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;

@@ -12,11 +13,9 @@ import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

 import io.swagger.v3.oas.annotations.Operation;

-import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;

@@ -51,8 +50,8 @@ public class SplitPdfBySizeController {
                            + " if 10MB and each page is 1MB and you enter 2MB then 5 docs each 2MB"
                            + " (rounded so that it accepts 1.9MB but not 2.1MB) Input:PDF"
                            + " Output:ZIP-PDF Type:SISO")
-    public ResponseEntity<StreamingResponseBody> autoSplitPdf(
-            @ModelAttribute SplitPdfBySizeOrCountRequest request) throws Exception {
+    public ResponseEntity<byte[]> autoSplitPdf(@ModelAttribute SplitPdfBySizeOrCountRequest request)
+            throws Exception {

        log.debug("Starting PDF split process with request: {}", request);
        MultipartFile file = request.getFileInput();
@@ -60,51 +59,63 @@ public class SplitPdfBySizeController {
        String filename = GeneralUtils.generateFilename(file.getOriginalFilename(), "");
        log.debug("Base filename for output: {}", filename);

-        TempFile zipTempFile = new TempFile(tempFileManager, ".zip");
-        try {
-            log.debug("Created temporary managed zip file: {}", zipTempFile.getPath());
-            log.debug("Creating ZIP output stream");
-            try (ZipOutputStream zipOut =
-                            new ZipOutputStream(Files.newOutputStream(zipTempFile.getPath()));
-                    PDDocument sourceDocument = pdfDocumentFactory.load(file)) {
-                log.debug(
-                        "Successfully loaded PDF with {} pages", sourceDocument.getNumberOfPages());
+        try (TempFile zipTempFile = new TempFile(tempFileManager, ".zip")) {
+            Path managedZipPath = zipTempFile.getPath();
+            log.debug("Created temporary managed zip file: {}", managedZipPath);
+            try {
+                log.debug("Reading input file bytes");
+                byte[] pdfBytes = file.getBytes();
+                log.debug("Successfully read {} bytes from input file", pdfBytes.length);

-                int type = request.getSplitType();
-                String value = request.getSplitValue();
-                log.debug("Split type: {}, Split value: {}", type, value);
+                log.debug("Creating ZIP output stream");
+                try (ZipOutputStream zipOut =
+                        new ZipOutputStream(Files.newOutputStream(managedZipPath))) {
+                    log.debug("Loading PDF document");
+                    try (PDDocument sourceDocument = pdfDocumentFactory.load(pdfBytes)) {
+                        log.debug(
+                                "Successfully loaded PDF with {} pages",
+                                sourceDocument.getNumberOfPages());

-                if (type == 0) {
-                    log.debug("Processing split by size");
-                    long maxBytes = GeneralUtils.convertSizeToBytes(value);
-                    log.debug("Max bytes per document: {}", maxBytes);
-                    handleSplitBySize(sourceDocument, maxBytes, zipOut, filename);
-                } else if (type == 1) {
-                    log.debug("Processing split by page count");
-                    int pageCount = Integer.parseInt(value);
-                    log.debug("Pages per document: {}", pageCount);
-                    handleSplitByPageCount(sourceDocument, pageCount, zipOut, filename);
-                } else if (type == 2) {
-                    log.debug("Processing split by document count");
-                    int documentCount = Integer.parseInt(value);
-                    log.debug("Total number of documents: {}", documentCount);
-                    handleSplitByDocCount(sourceDocument, documentCount, zipOut, filename);
-                } else {
-                    log.error("Invalid split type: {}", type);
-                    throw ExceptionUtils.createIllegalArgumentException(
-                            "error.invalidArgument",
-                            "Invalid argument: {0}",
-                            "split type: " + type);
+                        int type = request.getSplitType();
+                        String value = request.getSplitValue();
+                        log.debug("Split type: {}, Split value: {}", type, value);
+
+                        if (type == 0) {
+                            log.debug("Processing split by size");
+                            long maxBytes = GeneralUtils.convertSizeToBytes(value);
+                            log.debug("Max bytes per document: {}", maxBytes);
+                            handleSplitBySize(sourceDocument, maxBytes, zipOut, filename);
+                        } else if (type == 1) {
+                            log.debug("Processing split by page count");
+                            int pageCount = Integer.parseInt(value);
+                            log.debug("Pages per document: {}", pageCount);
+                            handleSplitByPageCount(sourceDocument, pageCount, zipOut, filename);
+                        } else if (type == 2) {
+                            log.debug("Processing split by document count");
+                            int documentCount = Integer.parseInt(value);
+                            log.debug("Total number of documents: {}", documentCount);
+                            handleSplitByDocCount(sourceDocument, documentCount, zipOut, filename);
+                        } else {
+                            log.error("Invalid split type: {}", type);
+                            throw ExceptionUtils.createIllegalArgumentException(
+                                    "error.invalidArgument",
+                                    "Invalid argument: {0}",
+                                    "split type: " + type);
+                        }
+                        log.debug("PDF splitting completed successfully");
+                    }
                }
-                log.debug("PDF splitting completed successfully");
-            }

-            log.debug("Returning streaming response for zip file");
-            return WebResponseUtils.zipFileToWebResponse(zipTempFile, filename + ".zip");
-        } catch (Exception e) {
-            ExceptionUtils.logException("PDF splitting process", e);
-            zipTempFile.close();
-            throw e;
+                byte[] data = Files.readAllBytes(managedZipPath);
+                log.debug("Successfully read {} bytes from ZIP file", data.length);
+
+                log.debug("Returning response with {} bytes of data", data.length);
+                return WebResponseUtils.bytesToWebResponse(
+                        data, filename + ".zip", MediaType.APPLICATION_OCTET_STREAM);
+            } catch (Exception e) {
+                ExceptionUtils.logException("PDF splitting process", e);
+                throw e; // Re-throw to ensure proper error response
+            }
        }
    }

@@ -113,7 +124,6 @@ public class SplitPdfBySizeController {
            throws IOException {
        log.debug("Starting handleSplitBySize with maxBytes={}", maxBytes);

-        @Getter
        class DocHolder implements AutoCloseable {
            private PDDocument doc;

@@ -121,6 +131,10 @@ public class SplitPdfBySizeController {
                this.doc = doc;
            }

+            public PDDocument getDoc() {
+                return doc;
+            }
+
            public void setDoc(PDDocument doc) {
                if (this.doc != null) {
                    try {
@@ -168,7 +168,8 @@ public class UIDataController {
    public ResponseEntity<SignData> getSignData() {
        String username = "";
        if (userService != null) {
-            username = userService.getCurrentUsername();
+            String currentUsername = userService.getCurrentUsername();
+            username = currentUsername != null ? currentUsername : "";
        }

        List<SignatureFile> signatures = signatureService.getAvailableSignatures(username);
@@ -22,7 +22,6 @@ import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

 import io.swagger.v3.oas.annotations.Operation;

@@ -52,7 +51,6 @@ import stirling.software.common.util.PdfUtils;
 import stirling.software.common.util.ProcessExecutor;
 import stirling.software.common.util.ProcessExecutor.ProcessExecutorResult;
 import stirling.software.common.util.RegexPatternUtils;
-import stirling.software.common.util.TempFile;
 import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;

@@ -80,7 +78,7 @@ public class ConvertImgPDFController {
                    "This endpoint converts a PDF file to image(s) with the specified image format,"
                            + " color type, and DPI. Users can choose to get a single image or multiple"
                            + " images.  Input:PDF Output:Image Type:SI-Conditional")
-    public ResponseEntity<?> convertToImage(@ModelAttribute ConvertToImageRequest request)
+    public ResponseEntity<byte[]> convertToImage(@ModelAttribute ConvertToImageRequest request)
            throws Exception {
        MultipartFile file = request.getFileInput();
        String imageFormat = request.getImageFormat();
@@ -182,33 +180,28 @@ public class ConvertImgPDFController {
                            "No WebP files were created. " + resultProcess.getMessages());
                }

+                byte[] bodyBytes = new byte[0];
+
                if (webpFiles.size() == 1) {
+                    // Return the single WebP file directly
                    Path webpFilePath = webpFiles.get(0);
-                    byte[] webpBytes = Files.readAllBytes(webpFilePath);
-                    Files.deleteIfExists(tempFile);
-                    tempFile = null;
-                    FileUtils.deleteDirectory(tempOutputDir.toFile());
-                    tempOutputDir = null;
-                    String docName = filename + "." + imageFormat;
-                    MediaType mediaType = MediaType.parseMediaType(getMediaType(imageFormat));
-                    return WebResponseUtils.bytesToWebResponse(webpBytes, docName, mediaType);
+                    bodyBytes = Files.readAllBytes(webpFilePath);
                } else {
-                    ByteArrayOutputStream zipBAOS = new ByteArrayOutputStream();
-                    try (ZipOutputStream zos = new ZipOutputStream(zipBAOS)) {
+                    // Create a ZIP file containing all WebP images
+                    try (ByteArrayOutputStream zipOutputStream = new ByteArrayOutputStream();
+                            ZipOutputStream zos = new ZipOutputStream(zipOutputStream)) {
                        for (Path webpFile : webpFiles) {
                            zos.putNextEntry(new ZipEntry(webpFile.getFileName().toString()));
                            Files.copy(webpFile, zos);
                            zos.closeEntry();
                        }
+                        bodyBytes = zipOutputStream.toByteArray();
                    }
-                    Files.deleteIfExists(tempFile);
-                    tempFile = null;
-                    FileUtils.deleteDirectory(tempOutputDir.toFile());
-                    tempOutputDir = null;
-                    String zipFilename = filename + "_convertedToImages.zip";
-                    return WebResponseUtils.bytesToWebResponse(
-                            zipBAOS.toByteArray(), zipFilename, MediaType.APPLICATION_OCTET_STREAM);
                }
+                // Clean up the temporary files
+                Files.deleteIfExists(tempFile);
+                if (tempOutputDir != null) FileUtils.deleteDirectory(tempOutputDir.toFile());
+                result = bodyBytes;
            }

            if (singleImage) {
@@ -274,8 +267,8 @@ public class ConvertImgPDFController {
            description =
                    "This endpoint converts a CBZ (ZIP) comic book archive to a PDF file. "
                            + "Input:CBZ Output:PDF Type:SISO")
-    public ResponseEntity<StreamingResponseBody> convertCbzToPdf(
-            @ModelAttribute ConvertCbzToPdfRequest request) throws IOException {
+    public ResponseEntity<?> convertCbzToPdf(@ModelAttribute ConvertCbzToPdfRequest request)
+            throws IOException {
        MultipartFile file = request.getFileInput();
        boolean optimizeForEbook = request.isOptimizeForEbook();

@@ -285,13 +278,13 @@ public class ConvertImgPDFController {
            optimizeForEbook = false;
        }

-        TempFile pdfFile =
+        byte[] pdfBytes =
                CbzUtils.convertCbzToPdf(
                        file, pdfDocumentFactory, tempFileManager, optimizeForEbook);

        String filename = createConvertedFilename(file.getOriginalFilename(), "_converted.pdf");

-        return WebResponseUtils.pdfFileToWebResponse(pdfFile, filename);
+        return WebResponseUtils.bytesToWebResponse(pdfBytes, filename);
    }

    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/cbz")
@@ -300,8 +293,8 @@ public class ConvertImgPDFController {
            description =
                    "This endpoint converts a PDF file to a CBZ (ZIP) comic book archive. "
                            + "Input:PDF Output:CBZ Type:SISO")
-    public ResponseEntity<StreamingResponseBody> convertPdfToCbz(
-            @ModelAttribute ConvertPdfToCbzRequest request) throws IOException {
+    public ResponseEntity<?> convertPdfToCbz(@ModelAttribute ConvertPdfToCbzRequest request)
+            throws IOException {
        MultipartFile file = request.getFileInput();
        int dpi = request.getDpi();

@@ -309,12 +302,12 @@ public class ConvertImgPDFController {
            dpi = 300;
        }

-        TempFile cbzFile =
-                PdfToCbzUtils.convertPdfToCbz(file, dpi, pdfDocumentFactory, tempFileManager);
+        byte[] cbzBytes = PdfToCbzUtils.convertPdfToCbz(file, dpi, pdfDocumentFactory);

        String filename = createConvertedFilename(file.getOriginalFilename(), "_converted.cbz");

-        return WebResponseUtils.zipFileToWebResponse(cbzFile, filename);
+        return WebResponseUtils.bytesToWebResponse(
+                cbzBytes, filename, MediaType.APPLICATION_OCTET_STREAM);
    }

    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/cbr/pdf")
@@ -54,12 +54,6 @@ public class ConvertPDFToEpubController {
        command.add(inputPath.toString());
        command.add(outputPath.toString());

-        // Use pdftohtml engine (poppler) for PDF input instead of calibre's Qt-based engine.
-        // This avoids the Qt WebEngine dependency for PDF parsing and uses the lighter
-        // poppler-utils pdftohtml binary which is already available in the container.
-        command.add("--pdf-engine");
-        command.add("pdftohtml");
-
        // Golden defaults
        command.add("--enable-heuristics");
        command.add("--insert-blank-line");
@@ -39,8 +39,6 @@ import stirling.software.common.util.WebResponseUtils;
 public class ConvertPdfJsonController {

    private static final Pattern FILE_EXTENSION_PATTERN = Pattern.compile("[.][^.]+$");
-    private static final Pattern WHITESPACE_PATTERN = Pattern.compile("[\\r\\n\\t]+");
-    private static final Pattern NON_PRINTABLE_PATTERN = Pattern.compile("[^\\x20-\\x7E]");
    private final PdfJsonConversionService pdfJsonConversionService;

    @Autowired(required = false)
@@ -261,10 +259,7 @@ public class ConvertPdfJsonController {
            if (length > 0) {
                int start = Math.max(0, length - 64);
                tail = new String(jsonBytes, start, length - start, StandardCharsets.UTF_8);
-                tail =
-                        NON_PRINTABLE_PATTERN
-                                .matcher(WHITESPACE_PATTERN.matcher(tail).replaceAll(" "))
-                                .replaceAll("?");
+                tail = tail.replaceAll("[\\r\\n\\t]+", " ").replaceAll("[^\\x20-\\x7E]", "?");
            }
            log.debug(
                    "Returning {} JSON response ({} bytes, endsWithJson={}, tail='{}')",
@@ -426,9 +421,9 @@ public class ConvertPdfJsonController {
    private String truncateForLog(String value) {
        int max = 64;
        if (value.length() <= max) {
-            return WHITESPACE_PATTERN.matcher(value).replaceAll(" ");
+            return value.replaceAll("[\\r\\n\\t]+", " ");
        }
-        return WHITESPACE_PATTERN.matcher(value.substring(0, max)).replaceAll(" ") + "...";
+        return value.substring(0, max).replaceAll("[\\r\\n\\t]+", " ") + "...";
    }

    /**
@@ -159,24 +159,6 @@ public class ConfigController {
                    "defaultHideUnavailableConversions",
                    applicationProperties.getUi().isDefaultHideUnavailableConversions());

-            // Hide disabled tools settings
-            configData.put(
-                    "hideDisabledToolsGoogleDrive",
-                    applicationProperties.getUi().getHideDisabledTools().isGoogleDrive());
-            configData.put(
-                    "hideDisabledToolsMobileQRScanner",
-                    applicationProperties.getUi().getHideDisabledTools().isMobileQRScanner());
-
-            // Google Drive backend settings (only if enabled)
-            ApplicationProperties.Premium.ProFeatures.GoogleDrive googleDrive =
-                    applicationProperties.getPremium().getProFeatures().getGoogleDrive();
-            if (googleDrive.isEnabled()) {
-                configData.put("googleDriveEnabled", true);
-                configData.put("googleDriveClientId", googleDrive.getClientId());
-                configData.put("googleDriveApiKey", googleDrive.getApiKey());
-                configData.put("googleDriveAppId", googleDrive.getAppId());
-            }
-
            // Security settings
            // enableLogin requires both the config flag AND proprietary features to be loaded
            // If userService is null, proprietary module isn't loaded
@@ -67,7 +67,7 @@ public class ExtractImageScansController {
        MultipartFile inputFile = request.getFileInput();

        String fileName = inputFile.getOriginalFilename();
-        String extension = fileName.substring(fileName.lastIndexOf('.') + 1);
+        String extension = fileName.substring(fileName.lastIndexOf(".") + 1);

        List<String> images = new ArrayList<>();

@@ -5,7 +5,6 @@ import java.awt.image.BufferedImage;
 import java.awt.image.RenderedImage;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.nio.file.Files;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Arrays;
@@ -29,7 +28,6 @@ import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

 import io.swagger.v3.oas.annotations.Operation;

@@ -44,8 +42,6 @@ import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.ImageProcessingUtils;
-import stirling.software.common.util.TempFile;
-import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;

@MiscApi
@@ -54,7 +50,6 @@ import stirling.software.common.util.WebResponseUtils;
 public class ExtractImagesController {

    private final CustomPDFDocumentFactory pdfDocumentFactory;
-    private final TempFileManager tempFileManager;

    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/extract-images")
    @MultiFileResponse
@@ -64,115 +59,111 @@ public class ExtractImagesController {
                    "This endpoint extracts images from a given PDF file and returns them in a zip"
                            + " file. Users can specify the output image format. Input:PDF"
                            + " Output:IMAGE/ZIP Type:SIMO")
-    public ResponseEntity<StreamingResponseBody> extractImages(
-            @ModelAttribute PDFExtractImagesRequest request)
+    public ResponseEntity<byte[]> extractImages(@ModelAttribute PDFExtractImagesRequest request)
            throws IOException, InterruptedException, ExecutionException {
        MultipartFile file = request.getFileInput();
        String format = request.getFormat();
        boolean allowDuplicates = Boolean.TRUE.equals(request.getAllowDuplicates());
+        PDDocument document = pdfDocumentFactory.load(file);
+
+        // Determine if multithreading should be used based on PDF size or number of pages
+        boolean useMultithreading = shouldUseMultithreading(file, document);
+
+        // Create ByteArrayOutputStream to write zip file to byte array
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+        // Create ZipOutputStream to create zip file
+        ZipOutputStream zos = new ZipOutputStream(baos);
+
+        // Set compression level
+        zos.setLevel(Deflater.BEST_COMPRESSION);

        String filename = GeneralUtils.removeExtension(file.getOriginalFilename());
        Set<byte[]> processedImages = new HashSet<>();

-        TempFile zipTempFile = new TempFile(tempFileManager, ".zip");
-        try (ZipOutputStream zos =
-                        new ZipOutputStream(Files.newOutputStream(zipTempFile.getPath()));
-                PDDocument document = pdfDocumentFactory.load(file)) {
+        if (useMultithreading) {
+            // Virtual thread executor — lightweight threads ideal for I/O-bound image extraction
+            ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
+            Set<Future<Void>> futures = new HashSet<>();

-            // Set compression level
-            zos.setLevel(Deflater.BEST_COMPRESSION);
+            // Safely iterate over each page, handling corrupt PDFs where page count might be wrong
+            try {
+                int pageCount = document.getPages().getCount();
+                log.debug("Document reports {} pages", pageCount);

-            // Determine if multithreading should be used based on PDF size or number of pages
-            boolean useMultithreading = shouldUseMultithreading(file, document);
+                int consecutiveFailures = 0;

-            if (useMultithreading) {
-                ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
-                Set<Future<Void>> futures = new HashSet<>();
+                for (int pgNum = 0; pgNum < pageCount; pgNum++) {
+                    try {
+                        PDPage page = document.getPage(pgNum);
+                        consecutiveFailures = 0; // Reset on success
+                        final int currentPageNum = pgNum + 1; // Convert to 1-based page numbering
+                        Future<Void> future =
+                                executor.submit(
+                                        () -> {
+                                            try {
+                                                // Call the image extraction method for each page
+                                                extractImagesFromPage(
+                                                        page,
+                                                        format,
+                                                        filename,
+                                                        currentPageNum,
+                                                        processedImages,
+                                                        zos,
+                                                        allowDuplicates);
+                                            } catch (Exception e) {
+                                                // Log the error and continue processing other pages
+                                                ExceptionUtils.logException(
+                                                        "image extraction from page "
+                                                                + currentPageNum,
+                                                        e);
+                                            }

-                try {
-                    int pageCount = document.getPages().getCount();
-                    log.debug("Document reports {} pages", pageCount);
+                                            return null; // Callable requires a return type
+                                        });

-                    int consecutiveFailures = 0;
+                        // Add the Future object to the list to track completion
+                        futures.add(future);
+                    } catch (Exception e) {
+                        consecutiveFailures++;
+                        ExceptionUtils.logException("page access for page " + (pgNum + 1), e);

-                    for (int pgNum = 0; pgNum < pageCount; pgNum++) {
-                        try {
-                            PDPage page = document.getPage(pgNum);
-                            consecutiveFailures = 0; // Reset on success
-                            final int currentPageNum =
-                                    pgNum + 1; // Convert to 1-based page numbering
-                            Future<Void> future =
-                                    executor.submit(
-                                            () -> {
-                                                try {
-                                                    // Call the image extraction method for each
-                                                    // page
-                                                    extractImagesFromPage(
-                                                            page,
-                                                            format,
-                                                            filename,
-                                                            currentPageNum,
-                                                            processedImages,
-                                                            zos,
-                                                            allowDuplicates);
-                                                } catch (Exception e) {
-                                                    // Log the error and continue processing other
-                                                    // pages
-                                                    ExceptionUtils.logException(
-                                                            "image extraction from page "
-                                                                    + currentPageNum,
-                                                            e);
-                                                }
-
-                                                return null; // Callable requires a return type
-                                            });
-
-                            // Add the Future object to the list to track completion
-                            futures.add(future);
-                        } catch (Exception e) {
-                            consecutiveFailures++;
-                            ExceptionUtils.logException("page access for page " + (pgNum + 1), e);
-
-                            if (consecutiveFailures >= 3) {
-                                log.warn("Stopping page iteration after 3 consecutive failures");
-                                break;
-                            }
+                        if (consecutiveFailures >= 3) {
+                            log.warn("Stopping page iteration after 3 consecutive failures");
+                            break;
                        }
                    }
-                } catch (Exception e) {
-                    ExceptionUtils.logException("page count determination", e);
-                    throw e;
-                }
-
-                // Wait for all tasks to complete
-                for (Future<Void> future : futures) {
-                    future.get();
-                }
-
-                // Close executor service
-                executor.shutdown();
-            } else {
-                // Single-threaded extraction
-                for (int pgNum = 0; pgNum < document.getPages().getCount(); pgNum++) {
-                    PDPage page = document.getPage(pgNum);
-                    extractImagesFromPage(
-                            page,
-                            format,
-                            filename,
-                            pgNum + 1,
-                            processedImages,
-                            zos,
-                            allowDuplicates);
                }
+            } catch (Exception e) {
+                ExceptionUtils.logException("page count determination", e);
+                throw e;
+            }
+
+            // Wait for all tasks to complete
+            for (Future<Void> future : futures) {
+                future.get();
+            }
+
+            // Close executor service
+            executor.shutdown();
+        } else {
+            // Single-threaded extraction
+            for (int pgNum = 0; pgNum < document.getPages().getCount(); pgNum++) {
+                PDPage page = document.getPage(pgNum);
+                extractImagesFromPage(
+                        page, format, filename, pgNum + 1, processedImages, zos, allowDuplicates);
            }
-            // document and zos closed by try-with-resources
-        } catch (Exception e) {
-            zipTempFile.close();
-            throw e;
        }

-        return WebResponseUtils.zipFileToWebResponse(
-                zipTempFile, filename + "_extracted-images.zip");
+        // Close PDDocument and ZipOutputStream
+        document.close();
+        zos.close();
+
+        // Create ByteArrayResource from byte array
+        byte[] zipContents = baos.toByteArray();
+
+        return WebResponseUtils.baosToWebResponse(
+                baos, filename + "_extracted-images.zip", MediaType.APPLICATION_OCTET_STREAM);
    }

    private boolean shouldUseMultithreading(MultipartFile file, PDDocument document) {
@@ -223,17 +214,13 @@ public class ExtractImagesController {
                    // Convert to standard RGB colorspace if needed
                    BufferedImage bufferedImage = convertToRGB(renderedImage, format);

-                    // Encode image outside the lock to allow parallel encoding across threads
+                    // Write image to zip file
                    String imageName = filename + "_page_" + pageNum + "_" + count++ + "." + format;
-                    ByteArrayOutputStream imageBaos = new ByteArrayOutputStream();
-                    ImageIO.write(bufferedImage, format, imageBaos);
-                    byte[] imageData = imageBaos.toByteArray();
-
-                    // Write encoded bytes to zip under lock (ZipOutputStream requires
-                    // serialization)
                    synchronized (zos) {
                        zos.putNextEntry(new ZipEntry(imageName));
-                        zos.write(imageData);
+                        ByteArrayOutputStream imageBaos = new ByteArrayOutputStream();
+                        ImageIO.write(bufferedImage, format, imageBaos);
+                        zos.write(imageBaos.toByteArray());
                        zos.closeEntry();
                    }
                }
@@ -94,7 +94,7 @@ public class OCRController {
            throws IOException, InterruptedException {
        MultipartFile inputFile = request.getFileInput();
        List<String> selectedLanguages = request.getLanguages();
-        boolean sidecar = request.isSidecar();
+        Boolean sidecar = request.isSidecar();
        Boolean deskew = request.isDeskew();
        Boolean clean = request.isClean();
        Boolean cleanFinal = request.isCleanFinal();
@@ -233,7 +233,7 @@ public class StampController {
                };

        ClassPathResource classPathResource = new ClassPathResource(resourceDir);
-        String fileExtension = resourceDir.substring(resourceDir.lastIndexOf('.'));
+        String fileExtension = resourceDir.substring(resourceDir.lastIndexOf("."));

        // Use TempFile with try-with-resources for automatic cleanup
        try (TempFile tempFileWrapper = new TempFile(tempFileManager, fileExtension)) {
@@ -1,7 +1,7 @@
 package stirling.software.SPDF.controller.api.pipeline;

+import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
-import java.nio.file.Files;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -13,7 +13,6 @@ import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

 import io.swagger.v3.oas.annotations.Operation;

@@ -29,8 +28,6 @@ import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.PipelineApi;
 import stirling.software.common.service.PostHogService;
 import stirling.software.common.util.GeneralUtils;
-import stirling.software.common.util.TempFile;
-import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;

 import tools.jackson.core.JacksonException;
@@ -48,8 +45,6 @@ public class PipelineController {

    private final PostHogService postHogService;

-    private final TempFileManager tempFileManager;
-
    @AutoJobPostMapping(value = "/handleData", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    @MultiFileResponse
    @Operation(
@@ -58,8 +53,8 @@ public class PipelineController {
                    "This endpoint processes multiple PDF files through a configurable pipeline of operations. "
                            + "Users provide files and a JSON configuration defining the sequence of operations to perform. "
                            + "Input:PDF Output:PDF/ZIP Type:MIMO")
-    public ResponseEntity<StreamingResponseBody> handleData(
-            @ModelAttribute HandleDataRequest request) throws DatabindException, JacksonException {
+    public ResponseEntity<byte[]> handleData(@ModelAttribute HandleDataRequest request)
+            throws DatabindException, JacksonException {
        MultipartFile[] files = request.getFileInput();
        String jsonString = request.getJson();
        if (files == null) {
@@ -85,56 +80,51 @@ public class PipelineController {
            PipelineResult result = processor.runPipelineAgainstFiles(inputFiles, config);
            List<Resource> outputFiles = result.getOutputFiles();
            if (outputFiles != null && outputFiles.size() == 1) {
-                // If there is only one file, return it directly — stream without int-overflow
+                // If there is only one file, return it directly
                Resource singleFile = outputFiles.get(0);
-                TempFile singleTempFile = new TempFile(tempFileManager, ".out");
-                try {
-                    try (InputStream is = singleFile.getInputStream()) {
-                        is.transferTo(Files.newOutputStream(singleTempFile.getPath()));
-                    }
-                    log.info("Returning single file response...");
-                    return WebResponseUtils.fileToWebResponse(
-                            singleTempFile,
-                            singleFile.getFilename(),
-                            MediaType.APPLICATION_OCTET_STREAM);
-                } catch (Exception e) {
-                    singleTempFile.close();
-                    throw e;
-                }
+                InputStream is = singleFile.getInputStream();
+                byte[] bytes = new byte[(int) singleFile.contentLength()];
+                is.read(bytes);
+                is.close();
+                log.info("Returning single file response...");
+                return WebResponseUtils.bytesToWebResponse(
+                        bytes, singleFile.getFilename(), MediaType.APPLICATION_OCTET_STREAM);
            } else if (outputFiles == null) {
                return null;
            }
-            // Multiple files: stream into a zip TempFile
-            TempFile zipTempFile = new TempFile(tempFileManager, ".zip");
-            try {
-                Map<String, Integer> filenameCount = new HashMap<>();
-                try (ZipOutputStream zipOut =
-                        new ZipOutputStream(Files.newOutputStream(zipTempFile.getPath()))) {
-                    for (Resource file : outputFiles) {
-                        String originalFilename = file.getFilename();
-                        String filename = originalFilename;
-                        if (filenameCount.containsKey(originalFilename)) {
-                            int count = filenameCount.get(originalFilename);
-                            filename =
-                                    GeneralUtils.generateFilename(
-                                            originalFilename, "(" + count + ")");
-                            filenameCount.put(originalFilename, count + 1);
-                        } else {
-                            filenameCount.put(originalFilename, 1);
-                        }
-                        zipOut.putNextEntry(new ZipEntry(filename));
-                        try (InputStream is = file.getInputStream()) {
-                            is.transferTo(zipOut);
-                        }
-                        zipOut.closeEntry();
-                    }
+            // Create a ByteArrayOutputStream to hold the zip
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            ZipOutputStream zipOut = new ZipOutputStream(baos);
+            // A map to keep track of filenames and their counts
+            Map<String, Integer> filenameCount = new HashMap<>();
+            // Loop through each file and add it to the zip
+            for (Resource file : outputFiles) {
+                String originalFilename = file.getFilename();
+                String filename = originalFilename;
+                // Check if the filename already exists, and modify it if necessary
+                if (filenameCount.containsKey(originalFilename)) {
+                    int count = filenameCount.get(originalFilename);
+                    assert originalFilename != null;
+                    filename = GeneralUtils.generateFilename(originalFilename, "(" + count + ")");
+                    filenameCount.put(originalFilename, count + 1);
+                } else {
+                    filenameCount.put(originalFilename, 1);
                }
-                log.info("Returning zipped file response...");
-                return WebResponseUtils.zipFileToWebResponse(zipTempFile, "output.zip");
-            } catch (Exception e) {
-                zipTempFile.close();
-                throw e;
+                ZipEntry zipEntry = new ZipEntry(filename);
+                zipOut.putNextEntry(zipEntry);
+                // Read the file into a byte array
+                InputStream is = file.getInputStream();
+                byte[] bytes = new byte[(int) file.contentLength()];
+                is.read(bytes);
+                // Write the bytes of the file to the zip
+                zipOut.write(bytes, 0, bytes.length);
+                zipOut.closeEntry();
+                is.close();
            }
+            zipOut.close();
+            log.info("Returning zipped file response...");
+            return WebResponseUtils.baosToWebResponse(
+                    baos, "output.zip", MediaType.APPLICATION_OCTET_STREAM);
        } catch (Exception e) {
            log.error("Error handling data: ", e);
            return null;
@@ -254,7 +254,7 @@ public class PipelineDirectoryProcessor {
                                        String extension =
                                                filename.contains(".")
                                                        ? filename.substring(
-                                                                        filename.lastIndexOf('.')
+                                                                        filename.lastIndexOf(".")
                                                                                + 1)
                                                                .toLowerCase(Locale.ROOT)
                                                        : "";
@@ -67,7 +67,7 @@ public class PipelineProcessor {

    public static String removeTrailingNaming(String filename) {
        // Splitting filename into name and extension
-        int dotIndex = filename.lastIndexOf('.');
+        int dotIndex = filename.lastIndexOf(".");
        if (dotIndex == -1) {
            // No extension found
            return filename;
@@ -75,7 +75,7 @@ public class PipelineProcessor {
        String name = filename.substring(0, dotIndex);
        String extension = filename.substring(dotIndex);
        // Finding the last underscore
-        int underscoreIndex = name.lastIndexOf('_');
+        int underscoreIndex = name.lastIndexOf("_");
        if (underscoreIndex == -1) {
            // No underscore found
            return filename;
@@ -173,7 +173,7 @@ public class PipelineProcessor {
                        String providedExtension = "no extension";
                        if (filename != null && filename.contains(".")) {
                            providedExtension =
-                                    filename.substring(filename.lastIndexOf('.'))
+                                    filename.substring(filename.lastIndexOf("."))
                                            .toLowerCase(Locale.ROOT);
                        }

@@ -248,7 +248,7 @@ public class PipelineProcessor {
                                                String filename = file.getFilename();
                                                if (filename != null && filename.contains(".")) {
                                                    return filename.substring(
-                                                                    filename.lastIndexOf('.'))
+                                                                    filename.lastIndexOf("."))
                                                            .toLowerCase(Locale.ROOT);
                                                }
                                                return "no extension";
@@ -450,21 +450,7 @@ public class PipelineProcessor {
        return isZip(data, null);
    }

-    private static final int MAX_UNZIP_DEPTH = 10;
-
    private List<Resource> unzip(Resource data, PipelineResult result) throws IOException {
-        return unzip(data, result, 0);
-    }
-
-    private List<Resource> unzip(Resource data, PipelineResult result, int depth)
-            throws IOException {
-        if (depth > MAX_UNZIP_DEPTH) {
-            log.warn(
-                    "ZIP nesting depth {} exceeds limit {}, treating as file",
-                    depth,
-                    MAX_UNZIP_DEPTH);
-            return List.of(data);
-        }
        log.info("Unzipping data of length: {}", data.contentLength());
        List<Resource> unzippedFiles = new ArrayList<>();
        try (InputStream bais = data.getInputStream();
@@ -495,7 +481,7 @@ public class PipelineProcessor {
                // If the unzipped file is a zip file, unzip it
                if (isZip(fileResource, filename)) {
                    log.info("File {} is a zip file. Unzipping...", filename);
-                    unzippedFiles.addAll(unzip(fileResource, result, depth + 1));
+                    unzippedFiles.addAll(unzip(fileResource, result));
                } else {
                    unzippedFiles.add(fileResource);
                }
@@ -188,7 +188,7 @@ public class WatermarkController {
                };

        ClassPathResource classPathResource = new ClassPathResource(resourceDir);
-        String fileExtension = resourceDir.substring(resourceDir.lastIndexOf('.'));
+        String fileExtension = resourceDir.substring(resourceDir.lastIndexOf("."));
        File tempFile = Files.createTempFile("NotoSansFont", fileExtension).toFile();
        try (InputStream is = classPathResource.getInputStream();
                FileOutputStream os = new FileOutputStream(tempFile)) {
@@ -51,19 +51,9 @@ public class MetricsController {
            description =
                    "This endpoint returns the status of the application and its version number.")
    public ResponseEntity<?> getStatus() {
-        return getApplicationStatus();
-    }
-
-    @GetMapping("/health")
-    @Operation(
-            summary = "Application health check",
-            description =
-                    "This endpoint returns the health status of the application and its version number. Mirrors /api/v1/info/status.")
-    public ResponseEntity<?> getHealth() {
-        return getApplicationStatus();
-    }
-
-    private ResponseEntity<?> getApplicationStatus() {
+        if (!metricsEnabled) {
+            return ResponseEntity.status(HttpStatus.FORBIDDEN).body("This endpoint is disabled.");
+        }
        Map<String, String> status = new HashMap<>();
        status.put("status", "UP");
        String version = getClass().getPackage().getImplementationVersion();
@@ -178,8 +178,7 @@ public class ReactRoutingController {
        String escapedBaseUrlJs = JavaScriptUtils.javaScriptEscape(baseUrl);

        String serverUrl = "(window.location.origin + '" + escapedBaseUrlJs + "')";
-        return
-                """
+        return """
                <!doctype html>
                <html>
                  <head>
@@ -238,8 +237,7 @@ public class ReactRoutingController {
        String escapedBaseUrlJs = JavaScriptUtils.javaScriptEscape(baseUrl);

        String serverUrl = "(window.location.origin + '" + escapedBaseUrlJs + "')";
-        return
-                """
+        return """
                <!doctype html>
                <html>
                  <head>
@@ -3,7 +3,6 @@ package stirling.software.SPDF.exception;
 import java.io.IOException;
 import java.net.URI;
 import java.time.Instant;
-import java.util.LinkedHashMap;
 import java.util.List;

 import org.springframework.context.MessageSource;
@@ -24,6 +23,8 @@ import org.springframework.web.multipart.MaxUploadSizeExceededException;
 import org.springframework.web.multipart.support.MissingServletRequestPartException;
 import org.springframework.web.servlet.NoHandlerFoundException;

+import com.fasterxml.jackson.databind.ObjectMapper;
+
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;

@@ -34,8 +35,6 @@ import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.ExceptionUtils.*;
 import stirling.software.common.util.RegexPatternUtils;

-import tools.jackson.databind.ObjectMapper;
-
 /**
 * Returns RFC 7807 Problem Details for HTTP APIs, ensuring consistent error responses across the
 * application.
@@ -871,7 +870,7 @@ public class GlobalExceptionHandler {

        // Use ObjectMapper to properly escape JSON values and prevent XSS
        ObjectMapper mapper = new ObjectMapper();
-        java.util.Map<String, Object> errorMap = new LinkedHashMap<>();
+        java.util.Map<String, Object> errorMap = new java.util.LinkedHashMap<>();
        errorMap.put("type", "about:blank");
        errorMap.put("title", "Not Acceptable");
        errorMap.put("status", 406);
@@ -25,9 +25,8 @@ public class ApiEndpoint {
    }

    public boolean areParametersValid(Map<String, Object> providedParams) {
-        for (Map.Entry<String, JsonNode> entry : parameters.entrySet()) {
-            boolean isRequired = entry.getValue().path("required").asBoolean(false);
-            if (isRequired && !providedParams.containsKey(entry.getKey())) {
+        for (String requiredParam : parameters.keySet()) {
+            if (!providedParams.containsKey(requiredParam)) {
                return false;
            }
        }
@@ -1,5 +1,7 @@
 package stirling.software.SPDF.model.json;

+import java.util.List;
+
 import com.fasterxml.jackson.annotation.JsonInclude;

 import lombok.AllArgsConstructor;
@@ -25,13 +27,13 @@ public class PdfJsonAnnotation {
    private String contents;

    /** Annotation rectangle [x1, y1, x2, y2] */
-    private float[] rect;
+    private List<Float> rect;

    /** Annotation appearance characteristics */
    private String appearanceState;

    /** Color components (e.g., [r, g, b] for RGB) */
-    private float[] color;
+    private List<Float> color;

    /** Annotation flags (print, hidden, etc.) */
    private Integer flags;
@@ -14,7 +14,7 @@ import lombok.NoArgsConstructor;
@Builder
@NoArgsConstructor
@AllArgsConstructor
-@JsonInclude(JsonInclude.Include.NON_DEFAULT)
+@JsonInclude(JsonInclude.Include.NON_NULL)
 public class PdfJsonDocument {

    private PdfJsonMetadata metadata;
@@ -23,7 +23,7 @@ public class PdfJsonDocument {
    private String xmpMetadata;

    /** Indicates that images should be loaded lazily via API rather than embedded in the JSON. */
-    private boolean lazyImages;
+    private Boolean lazyImages;

    @Builder.Default private List<PdfJsonFont> fonts = new ArrayList<>();

@@ -1,5 +1,7 @@
 package stirling.software.SPDF.model.json;

+import java.util.List;
+
 import com.fasterxml.jackson.annotation.JsonInclude;

 import lombok.AllArgsConstructor;
@@ -63,5 +65,5 @@ public class PdfJsonFontConversionCandidate {
    private String diagnostics;

    /** Known unicode/codepoint coverage derived from the conversion strategy. */
-    private int[] glyphCoverage;
+    private List<Integer> glyphCoverage;
 }
@@ -45,13 +45,13 @@ public class PdfJsonFormField {
    private Integer pageNumber;

    /** Field rectangle [x1, y1, x2, y2] on the page */
-    private float[] rect;
+    private List<Float> rect;

    /** For choice fields: list of options */
    private List<String> options;

    /** For choice fields: selected indices */
-    private int[] selectedIndices;
+    private List<Integer> selectedIndices;

    /** For button fields: whether it's checked */
    private Boolean checked;
@@ -1,5 +1,8 @@
 package stirling.software.SPDF.model.json;

+import java.util.ArrayList;
+import java.util.List;
+
 import com.fasterxml.jackson.annotation.JsonInclude;

 import lombok.AllArgsConstructor;
@@ -27,7 +30,7 @@ public class PdfJsonImageElement {
    private Float right;
    private Float top;
    private Float bottom;
-    private float[] transform;
+    @Builder.Default private List<Float> transform = new ArrayList<>();
    private Integer zOrder;
    private String imageData;
    private String imageFormat;
@@ -11,10 +11,10 @@ import lombok.NoArgsConstructor;
@Builder
@NoArgsConstructor
@AllArgsConstructor
-@JsonInclude(JsonInclude.Include.NON_DEFAULT)
+@JsonInclude(JsonInclude.Include.NON_NULL)
 public class PdfJsonPageDimension {
-    private int pageNumber;
-    private float width;
-    private float height;
-    private int rotation;
+    private Integer pageNumber;
+    private Float width;
+    private Float height;
+    private Integer rotation;
 }
@@ -1,5 +1,7 @@
 package stirling.software.SPDF.model.json;

+import java.util.List;
+
 import com.fasterxml.jackson.annotation.JsonInclude;

 import lombok.AllArgsConstructor;
@@ -15,5 +17,5 @@ import lombok.NoArgsConstructor;
 public class PdfJsonTextColor {

    private String colorSpace;
-    private float[] components;
+    private List<Float> components;
 }
@@ -1,5 +1,7 @@
 package stirling.software.SPDF.model.json;

+import java.util.List;
+
 import com.fasterxml.jackson.annotation.JsonInclude;

 import lombok.AllArgsConstructor;
@@ -30,10 +32,10 @@ public class PdfJsonTextElement {
    private Float y;
    private Float width;
    private Float height;
-    private float[] textMatrix;
+    private List<Float> textMatrix;
    private PdfJsonTextColor fillColor;
    private PdfJsonTextColor strokeColor;
    private Integer renderingMode;
    private Boolean fallbackUsed;
-    private int[] charCodes;
+    private List<Integer> charCodes;
 }
@@ -42,10 +42,9 @@ public class LanguageService {
                            languageCode -> {
                                Set<String> allowedLanguages =
                                        new HashSet<>(applicationProperties.getUi().getLanguages());
-                                // Empty list means all languages are allowed (no filtering)
-                                // Non-empty list acts as a strict whitelist
                                return allowedLanguages.isEmpty()
-                                        || allowedLanguages.contains(languageCode);
+                                        || allowedLanguages.contains(languageCode)
+                                        || "en_GB".equals(languageCode);
                            })
                    .collect(Collectors.toSet());

@@ -273,11 +273,11 @@ public class PdfJsonConversionService {

        // Get job ID from request context if running in async mode
        String contextJobId = getJobIdFromRequest();
-        boolean useLazyImages = (contextJobId != null && !contextJobId.isEmpty());
+        boolean isRealJobId = (contextJobId != null && !contextJobId.isEmpty());

        // Generate synthetic jobId for synchronous conversions to prevent cache collisions
        final String jobId;
-        if (!useLazyImages) {
+        if (!isRealJobId) {
            jobId = "pdf2json:" + java.util.UUID.randomUUID().toString();
            log.debug("Generated synthetic jobId for synchronous conversion: {}", jobId);
        } else {
@@ -302,7 +302,7 @@ public class PdfJsonConversionService {
                                            : "");
                            progressCallback.accept(p);
                        }
-                        : useLazyImages
+                        : isRealJobId
                                ? (p) -> {
                                    log.debug(
                                            "Progress: [{}%] {} - {}{}",
@@ -369,6 +369,7 @@ public class PdfJsonConversionService {
                int totalPages = document.getNumberOfPages();
                // Always enable lazy mode for real async jobs so cache is available regardless of
                // page count. Synchronous calls with synthetic jobId still do full extraction.
+                boolean useLazyImages = isRealJobId;
                Map<COSBase, FontModelCacheEntry> fontCache = new IdentityHashMap<>();
                Map<COSBase, EncodedImage> imageCache = new IdentityHashMap<>();
                log.debug(
@@ -376,7 +377,7 @@ public class PdfJsonConversionService {
                        totalPages,
                        useLazyImages ? "lazy image" : "standard",
                        jobId,
-                        useLazyImages);
+                        isRealJobId);
                Map<String, PdfJsonFont> fonts = new LinkedHashMap<>();
                Map<Integer, List<PdfJsonTextElement>> textByPage = new LinkedHashMap<>();
                Map<Integer, Map<PDFont, String>> pageFontResources = new HashMap<>();
@@ -430,7 +431,7 @@ public class PdfJsonConversionService {
                progress.accept(
                        PdfJsonConversionProgress.of(
                                80, "annotations", "Collecting annotations and form fields"));
-                boolean includeAnnotationRawData = !(lightweight && useLazyImages);
+                boolean includeAnnotationRawData = !(lightweight && isRealJobId);
                Map<Integer, List<PdfJsonAnnotation>> annotationsByPage =
                        collectAnnotations(
                                document, totalPages, progress, includeAnnotationRawData);
@@ -462,8 +463,8 @@ public class PdfJsonConversionService {
                                textByPage,
                                imagesByPage,
                                annotationsByPage,
-                                lightweight && useLazyImages));
-                if (lightweight && useLazyImages) {
+                                lightweight && isRealJobId));
+                if (lightweight && isRealJobId) {
                    // Lightweight async editor flow does not use form fields and this payload can
                    // be
                    // very large due nested raw dictionaries.
@@ -473,11 +474,12 @@ public class PdfJsonConversionService {
                }

                // Only cache for real async jobIds, not synthetic synchronous ones
-                if (useLazyImages) {
+                if (useLazyImages && isRealJobId) {
                    log.debug(
-                            "Creating cache for jobId: {} (useLazyImages={})",
+                            "Creating cache for jobId: {} (useLazyImages={}, isRealJobId={})",
                            jobId,
-                            useLazyImages);
+                            useLazyImages,
+                            isRealJobId);
                    PdfJsonDocumentMetadata docMetadata = new PdfJsonDocumentMetadata();
                    docMetadata.setMetadata(pdfJson.getMetadata());
                    docMetadata.setXmpMetadata(pdfJson.getXmpMetadata());
@@ -527,15 +529,16 @@ public class PdfJsonConversionService {
                    scheduleDocumentCleanup(jobId);
                } else {
                    log.warn(
-                            "Skipping cache creation: useLazyImages={}, jobId={}",
+                            "Skipping cache creation: useLazyImages={}, isRealJobId={}, jobId={}",
                            useLazyImages,
+                            isRealJobId,
                            jobId);
                }

                if (lightweight) {
                    applyLightweightTransformations(pdfJson);
                }
-                if (lightweight && useLazyImages) {
+                if (lightweight && isRealJobId) {
                    stripFontProgramPayloads(responseFonts);
                    stripFontCosStreamData(responseFonts);
                }
@@ -2500,12 +2503,11 @@ public class PdfJsonConversionService {
                    PDRectangle rect = annotation.getRectangle();
                    if (rect != null) {
                        ann.setRect(
-                                new float[] {
-                                    rect.getLowerLeftX(),
-                                    rect.getLowerLeftY(),
-                                    rect.getUpperRightX(),
-                                    rect.getUpperRightY()
-                                });
+                                List.of(
+                                        rect.getLowerLeftX(),
+                                        rect.getLowerLeftY(),
+                                        rect.getUpperRightX(),
+                                        rect.getUpperRightY()));
                    }

                    COSName appearanceState = annotation.getAppearanceState();
@@ -2514,7 +2516,12 @@ public class PdfJsonConversionService {
                    }

                    if (annotation.getColor() != null) {
-                        ann.setColor(annotation.getColor().getComponents());
+                        float[] colorComponents = annotation.getColor().getComponents();
+                        List<Float> colorList = new ArrayList<>(colorComponents.length);
+                        for (float c : colorComponents) {
+                            colorList.add(c);
+                        }
+                        ann.setColor(colorList);
                    }

                    COSDictionary annotDict = annotation.getCOSObject();
@@ -2629,12 +2636,11 @@ public class PdfJsonConversionService {
                            PDRectangle rect = widget.getRectangle();
                            if (rect != null) {
                                formField.setRect(
-                                        new float[] {
-                                            rect.getLowerLeftX(),
-                                            rect.getLowerLeftY(),
-                                            rect.getUpperRightX(),
-                                            rect.getUpperRightY()
-                                        });
+                                        List.of(
+                                                rect.getLowerLeftX(),
+                                                rect.getLowerLeftY(),
+                                                rect.getUpperRightX(),
+                                                rect.getUpperRightY()));
                            }
                        }
                    }
@@ -3345,7 +3351,7 @@ public class PdfJsonConversionService {
        PDFont currentFont = baseFont;
        String currentFontId = baseFontId;

-        int[] elementCodes = element.getCharCodes();
+        List<Integer> elementCodes = element.getCharCodes();
        int codeIndex = 0;
        boolean rawType3CodesUsed = false;
        int rawType3GlyphCount = 0;
@@ -3357,8 +3363,8 @@ public class PdfJsonConversionService {
            PDFont targetFont = baseFont;
            String targetFontId = baseFontId;
            Integer rawCode = null;
-            if (elementCodes != null && codeIndex < elementCodes.length) {
-                rawCode = elementCodes[codeIndex];
+            if (elementCodes != null && codeIndex < elementCodes.size()) {
+                rawCode = elementCodes.get(codeIndex);
            }
            codeIndex++;

@@ -3661,7 +3667,10 @@ public class PdfJsonConversionService {
        if (color == null || color.getComponents() == null) {
            return;
        }
-        float[] components = color.getComponents();
+        float[] components = new float[color.getComponents().size()];
+        for (int i = 0; i < components.length; i++) {
+            components[i] = color.getComponents().get(i);
+        }
        String space = color.getColorSpace();
        if (space == null) {
            // Infer color space from component count
@@ -4278,11 +4287,8 @@ public class PdfJsonConversionService {
        List<Integer> combinedCodes = new ArrayList<>();
        for (PdfJsonTextElement element : elements) {
            builder.append(Objects.toString(element.getText(), ""));
-            int[] codes = element.getCharCodes();
-            if (codes != null && codes.length > 0) {
-                for (int code : codes) {
-                    combinedCodes.add(code);
-                }
+            if (element.getCharCodes() != null && !element.getCharCodes().isEmpty()) {
+                combinedCodes.addAll(element.getCharCodes());
            }
        }
        return new MergedText(builder.toString(), combinedCodes.isEmpty() ? null : combinedCodes);
@@ -4348,9 +4354,9 @@ public class PdfJsonConversionService {
        }

        private int countGlyphs(PdfJsonTextElement element) {
-            int[] codes = element.getCharCodes();
-            if (codes != null && codes.length > 0) {
-                return codes.length;
+            List<Integer> codes = element.getCharCodes();
+            if (codes != null && !codes.isEmpty()) {
+                return codes.size();
            }
            String text = element.getText();
            if (text != null && !text.isEmpty()) {
@@ -4914,15 +4920,15 @@ public class PdfJsonConversionService {

    private void applyTextMatrix(PDPageContentStream contentStream, PdfJsonTextElement element)
            throws IOException {
-        float[] matrix = element.getTextMatrix();
-        if (matrix != null && matrix.length == 6) {
+        List<Float> matrix = element.getTextMatrix();
+        if (matrix != null && matrix.size() == 6) {
            float fontScale = resolveFontMatrixSize(element);
-            float a = matrix[0];
-            float b = matrix[1];
-            float c = matrix[2];
-            float d = matrix[3];
-            float e = matrix[4];
-            float f = matrix[5];
+            float a = matrix.get(0);
+            float b = matrix.get(1);
+            float c = matrix.get(2);
+            float d = matrix.get(3);
+            float e = matrix.get(4);
+            float f = matrix.get(5);

            if (fontScale != 0f) {
                a /= fontScale;
@@ -4944,12 +4950,12 @@ public class PdfJsonConversionService {
        if (fromElement != null && fromElement > 0f) {
            return fromElement;
        }
-        float[] matrix = element.getTextMatrix();
-        if (matrix != null && matrix.length >= 4) {
-            float a = matrix[0];
-            float b = matrix[1];
-            float c = matrix[2];
-            float d = matrix[3];
+        List<Float> matrix = element.getTextMatrix();
+        if (matrix != null && matrix.size() >= 4) {
+            float a = matrix.get(0);
+            float b = matrix.get(1);
+            float c = matrix.get(2);
+            float d = matrix.get(3);
            float verticalScale = (float) Math.hypot(b, d);
            if (verticalScale > 0f) {
                return verticalScale;
@@ -5042,7 +5048,7 @@ public class PdfJsonConversionService {
            }
            Matrix ctm = getGraphicsState().getCurrentTransformationMatrix();
            Bounds bounds = computeBounds(ctm);
-            float[] matrixValues = toMatrixValues(ctm);
+            List<Float> matrixValues = toMatrixValues(ctm);

            PdfJsonImageElement element =
                    PdfJsonImageElement.builder()
@@ -5216,15 +5222,15 @@ public class PdfJsonConversionService {

    private record EncodedImage(String base64, String format) {}

-    private float[] toMatrixValues(Matrix matrix) {
-        return new float[] {
-            matrix.getValue(0, 0),
-            matrix.getValue(0, 1),
-            matrix.getValue(1, 0),
-            matrix.getValue(1, 1),
-            matrix.getValue(2, 0),
-            matrix.getValue(2, 1)
-        };
+    private List<Float> toMatrixValues(Matrix matrix) {
+        List<Float> values = new ArrayList<>(6);
+        values.add(matrix.getValue(0, 0));
+        values.add(matrix.getValue(0, 1));
+        values.add(matrix.getValue(1, 0));
+        values.add(matrix.getValue(1, 1));
+        values.add(matrix.getValue(2, 0));
+        values.add(matrix.getValue(2, 1));
+        return values;
    }

    private EncodedImage encodeImage(PDImage image) {
@@ -5335,16 +5341,16 @@ public class PdfJsonConversionService {
            cache.put(cacheKey, image);
        }

-        float[] transform = element.getTransform();
-        if (transform != null && transform.length == 6) {
+        List<Float> transform = element.getTransform();
+        if (transform != null && transform.size() == 6) {
            Matrix matrix =
                    new Matrix(
-                            safeFloat(transform[0], 1f),
-                            safeFloat(transform[1], 0f),
-                            safeFloat(transform[2], 0f),
-                            safeFloat(transform[3], 1f),
-                            safeFloat(transform[4], 0f),
-                            safeFloat(transform[5], 0f));
+                            safeFloat(transform.get(0), 1f),
+                            safeFloat(transform.get(1), 0f),
+                            safeFloat(transform.get(2), 0f),
+                            safeFloat(transform.get(3), 1f),
+                            safeFloat(transform.get(4), 0f),
+                            safeFloat(transform.get(5), 0f));
            contentStream.drawImage(image, matrix);
            return;
        }
@@ -5510,17 +5516,14 @@ public class PdfJsonConversionService {
            if (pdfont instanceof PDType3Font) {
                int[] codes = position.getCharacterCodes();
                if (codes != null && codes.length > 0) {
-                    int count = 0;
+                    List<Integer> codeList = new ArrayList<>(codes.length);
                    for (int code : codes) {
-                        if (code >= 0) count++;
-                    }
-                    if (count > 0) {
-                        int[] filtered = new int[count];
-                        int idx = 0;
-                        for (int code : codes) {
-                            if (code >= 0) filtered[idx++] = code;
+                        if (code >= 0) {
+                            codeList.add(code);
                        }
-                        element.setCharCodes(filtered);
+                    }
+                    if (!codeList.isEmpty()) {
+                        element.setCharCodes(codeList);
                    }
                }
            }
@@ -5549,11 +5552,11 @@ public class PdfJsonConversionService {
                return;
            }

-            float[] matrix = element.getTextMatrix();
+            List<Float> matrix = element.getTextMatrix();
            if (matrix != null) {
-                if (matrix.length == 0) {
+                if (matrix.isEmpty()) {
                    element.setTextMatrix(null);
-                } else if (matrix.length == 6) {
+                } else if (matrix.size() == 6) {
                    element.setX(null);
                    element.setY(null);
                }
@@ -5594,29 +5597,29 @@ public class PdfJsonConversionService {
            if (color == null || color.getComponents() == null) {
                return true;
            }
-            float[] components = color.getComponents();
-            if (components.length == 0) {
+            List<Float> components = color.getComponents();
+            if (components.isEmpty()) {
                return true;
            }
            String space = color.getColorSpace();
            if (space == null || "DeviceRGB".equals(space)) {
-                if (components.length < 3) {
+                if (components.size() < 3) {
                    return false;
                }
-                return Math.abs(components[0]) < FLOAT_EPSILON
-                        && Math.abs(components[1]) < FLOAT_EPSILON
-                        && Math.abs(components[2]) < FLOAT_EPSILON;
+                return Math.abs(components.get(0)) < FLOAT_EPSILON
+                        && Math.abs(components.get(1)) < FLOAT_EPSILON
+                        && Math.abs(components.get(2)) < FLOAT_EPSILON;
            }
            if ("DeviceGray".equals(space)) {
-                return Math.abs(components[0]) < FLOAT_EPSILON;
+                return Math.abs(components.get(0)) < FLOAT_EPSILON;
            }
            return false;
        }

        private Float baselineFrom(PdfJsonTextElement element) {
-            float[] matrix = element.getTextMatrix();
-            if (matrix != null && matrix.length >= 6) {
-                return matrix[5];
+            List<Float> matrix = element.getTextMatrix();
+            if (matrix != null && matrix.size() >= 6) {
+                return matrix.get(5);
            }
            return element.getY();
        }
@@ -5645,12 +5648,11 @@ public class PdfJsonConversionService {
            private final float orientationC;
            private final float orientationD;
            private final Float baseline;
-            private final float[] baseMatrix;
+            private final List<Float> baseMatrix;
            private final float startXCoord;
            private final float startYCoord;
            private final StringBuilder textBuilder = new StringBuilder();
-            private int[] charCodeBuf = new int[16];
-            private int charCodeLen = 0;
+            private final List<Integer> charCodeBuffer = new ArrayList<>();
            private float totalWidth;
            private float maxHeight;
            private float endXCoord;
@@ -5658,15 +5660,17 @@ public class PdfJsonConversionService {
            TextRunAccumulator(PdfJsonTextElement element, TextPosition position) {
                this.baseElement = element;
                this.styleKey = buildStyleKey(element);
-                float[] tm = element.getTextMatrix();
-                this.baseMatrix = tm != null ? tm.clone() : null;
-                if (baseMatrix != null && baseMatrix.length >= 6) {
-                    orientationA = baseMatrix[0];
-                    orientationB = baseMatrix[1];
-                    orientationC = baseMatrix[2];
-                    orientationD = baseMatrix[3];
-                    startXCoord = baseMatrix[4];
-                    startYCoord = baseMatrix[5];
+                this.baseMatrix =
+                        element.getTextMatrix() != null
+                                ? new ArrayList<>(element.getTextMatrix())
+                                : null;
+                if (baseMatrix != null && baseMatrix.size() >= 6) {
+                    orientationA = baseMatrix.get(0);
+                    orientationB = baseMatrix.get(1);
+                    orientationC = baseMatrix.get(2);
+                    orientationD = baseMatrix.get(3);
+                    startXCoord = baseMatrix.get(4);
+                    startYCoord = baseMatrix.get(5);
                } else {
                    orientationA = 1f;
                    orientationB = 0f;
@@ -5680,23 +5684,25 @@ public class PdfJsonConversionService {
                this.maxHeight = element.getHeight() != null ? element.getHeight() : 0f;
                this.endXCoord = position.getXDirAdj() + position.getWidthDirAdj();
                this.textBuilder.append(element.getText());
-                appendCharCodes(element.getCharCodes());
+                if (element.getCharCodes() != null) {
+                    charCodeBuffer.addAll(element.getCharCodes());
+                }
            }

            boolean canAppend(PdfJsonTextElement element, TextPosition position) {
                if (!styleKey.equals(buildStyleKey(element))) {
                    return false;
                }
-                float[] matrix = element.getTextMatrix();
+                List<Float> matrix = element.getTextMatrix();
                float a = 1f;
                float b = 0f;
                float c = 0f;
                float d = 1f;
-                if (matrix != null && matrix.length >= 4) {
-                    a = matrix[0];
-                    b = matrix[1];
-                    c = matrix[2];
-                    d = matrix[3];
+                if (matrix != null && matrix.size() >= 4) {
+                    a = matrix.get(0);
+                    b = matrix.get(1);
+                    c = matrix.get(2);
+                    d = matrix.get(3);
                }
                if (Math.abs(a - orientationA) > ORIENTATION_TOLERANCE
                        || Math.abs(b - orientationB) > ORIENTATION_TOLERANCE
@@ -5728,19 +5734,9 @@ public class PdfJsonConversionService {
                    maxHeight = height;
                }
                endXCoord = position.getXDirAdj() + position.getWidthDirAdj();
-                appendCharCodes(element.getCharCodes());
-            }
-
-            private void appendCharCodes(int[] codes) {
-                if (codes == null) return;
-                int needed = charCodeLen + codes.length;
-                if (needed > charCodeBuf.length) {
-                    charCodeBuf =
-                            java.util.Arrays.copyOf(
-                                    charCodeBuf, Math.max(needed, charCodeBuf.length * 2));
+                if (element.getCharCodes() != null) {
+                    charCodeBuffer.addAll(element.getCharCodes());
                }
-                System.arraycopy(codes, 0, charCodeBuf, charCodeLen, codes.length);
-                charCodeLen += codes.length;
            }

            PdfJsonTextElement build() {
@@ -5752,21 +5748,22 @@ public class PdfJsonConversionService {
                }
                result.setWidth(totalWidth);
                result.setHeight(maxHeight);
-                if (baseMatrix != null && baseMatrix.length == 6) {
-                    float[] matrix =
-                            new float[] {
-                                orientationA, orientationB,
-                                orientationC, orientationD,
-                                startXCoord, startYCoord
-                            };
+                if (baseMatrix != null && baseMatrix.size() == 6) {
+                    List<Float> matrix = new ArrayList<>(baseMatrix);
+                    matrix.set(0, orientationA);
+                    matrix.set(1, orientationB);
+                    matrix.set(2, orientationC);
+                    matrix.set(3, orientationD);
+                    matrix.set(4, startXCoord);
+                    matrix.set(5, startYCoord);
                    result.setTextMatrix(matrix);
                    result.setX(null);
                    result.setY(null);
                }
-                if (charCodeLen == 0) {
+                if (charCodeBuffer.isEmpty()) {
                    result.setCharCodes(null);
                } else {
-                    result.setCharCodes(java.util.Arrays.copyOf(charCodeBuf, charCodeLen));
+                    result.setCharCodes(new ArrayList<>(charCodeBuffer));
                }
                compactTextElement(result);
                return result;
@@ -5787,25 +5784,29 @@ public class PdfJsonConversionService {
                Integer renderingMode,
                Float spaceWidth) {}

-        private float[] extractMatrix(TextPosition position) {
-            return new float[] {
-                position.getTextMatrix().getValue(0, 0),
-                position.getTextMatrix().getValue(0, 1),
-                position.getTextMatrix().getValue(1, 0),
-                position.getTextMatrix().getValue(1, 1),
-                position.getTextMatrix().getValue(2, 0),
-                position.getTextMatrix().getValue(2, 1)
-            };
+        private List<Float> extractMatrix(TextPosition position) {
+            float[] values = new float[6];
+            values[0] = position.getTextMatrix().getValue(0, 0);
+            values[1] = position.getTextMatrix().getValue(0, 1);
+            values[2] = position.getTextMatrix().getValue(1, 0);
+            values[3] = position.getTextMatrix().getValue(1, 1);
+            values[4] = position.getTextMatrix().getValue(2, 0);
+            values[5] = position.getTextMatrix().getValue(2, 1);
+            List<Float> matrix = new ArrayList<>(6);
+            for (float value : values) {
+                matrix.add(value);
+            }
+            return matrix;
        }

-        private Float computeFontMatrixSize(float[] matrix) {
-            if (matrix == null || matrix.length < 4) {
+        private Float computeFontMatrixSize(List<Float> matrix) {
+            if (matrix == null || matrix.size() < 4) {
                return null;
            }
-            float a = matrix[0];
-            float b = matrix[1];
-            float c = matrix[2];
-            float d = matrix[3];
+            float a = matrix.get(0);
+            float b = matrix.get(1);
+            float c = matrix.get(2);
+            float d = matrix.get(3);
            float scaleX = (float) Math.hypot(a, c);
            float scaleY = (float) Math.hypot(b, d);
            float scale = Math.max(scaleX, scaleY);
@@ -5849,10 +5850,11 @@ public class PdfJsonConversionService {
                        colorSpaceName,
                        ex.getMessage());
            }
-            return PdfJsonTextColor.builder()
-                    .colorSpace(colorSpaceName)
-                    .components(effective)
-                    .build();
+            List<Float> values = new ArrayList<>(effective.length);
+            for (float component : effective) {
+                values.add(component);
+            }
+            return PdfJsonTextColor.builder().colorSpace(colorSpaceName).components(values).build();
        }

        private String sanitizeForLog(String value) {
@@ -6239,12 +6241,11 @@ public class PdfJsonConversionService {
                    PDRectangle rect = annotation.getRectangle();
                    if (rect != null) {
                        ann.setRect(
-                                new float[] {
-                                    rect.getLowerLeftX(),
-                                    rect.getLowerLeftY(),
-                                    rect.getUpperRightX(),
-                                    rect.getUpperRightY()
-                                });
+                                List.of(
+                                        rect.getLowerLeftX(),
+                                        rect.getLowerLeftY(),
+                                        rect.getUpperRightX(),
+                                        rect.getUpperRightY()));
                    }

                    COSName appearanceState = annotation.getAppearanceState();
@@ -6253,7 +6254,12 @@ public class PdfJsonConversionService {
                    }

                    if (annotation.getColor() != null) {
-                        ann.setColor(annotation.getColor().getComponents());
+                        float[] colorComponents = annotation.getColor().getComponents();
+                        List<Float> colorList = new ArrayList<>(colorComponents.length);
+                        for (float c : colorComponents) {
+                            colorList.add(c);
+                        }
+                        ann.setColor(colorList);
                    }

                    COSDictionary annotDict = annotation.getCOSObject();
@@ -581,10 +581,9 @@ public class PdfJsonFallbackFontService {

        Character.UnicodeScript script = Character.UnicodeScript.of(codePoint);
        return switch (script) {
-                // HAN script is used by both Simplified and Traditional Chinese
-                // Default to Simplified (mainland China, 1.4B speakers) as it's more common
-                // Traditional Chinese PDFs are detected via font name aliases (MingLiU, PMingLiU,
-                // etc.)
+            // HAN script is used by both Simplified and Traditional Chinese
+            // Default to Simplified (mainland China, 1.4B speakers) as it's more common
+            // Traditional Chinese PDFs are detected via font name aliases (MingLiU, PMingLiU, etc.)
            case HAN -> FALLBACK_FONT_CJK_ID;
            case HIRAGANA, KATAKANA -> FALLBACK_FONT_JP_ID;
            case HANGUL -> FALLBACK_FONT_KR_ID;
@@ -30,7 +30,7 @@ public class SharedSignatureService {

    private static final Pattern FILENAME_VALIDATION_PATTERN = Pattern.compile("^[a-zA-Z0-9_.-]+$");
    private final String SIGNATURE_BASE_PATH;
-    private static final String ALL_USERS_FOLDER = "ALL_USERS";
+    private final String ALL_USERS_FOLDER = "ALL_USERS";
    private final ObjectMapper objectMapper;

    public SharedSignatureService(ObjectMapper objectMapper) {
@@ -159,12 +159,12 @@ public class SharedSignatureService {
        String dataUrl = request.getDataUrl();
        if (dataUrl != null && dataUrl.startsWith("data:image/")) {
            // Extract base64 data
-            String base64Data = dataUrl.substring(dataUrl.indexOf(',') + 1);
+            String base64Data = dataUrl.substring(dataUrl.indexOf(",") + 1);
            byte[] imageBytes = Base64.getDecoder().decode(base64Data);

            // Determine and validate file extension from data URL
-            String mimeType = dataUrl.substring(dataUrl.indexOf(':') + 1, dataUrl.indexOf(';'));
-            String rawExtension = mimeType.substring(mimeType.indexOf('/') + 1);
+            String mimeType = dataUrl.substring(dataUrl.indexOf(":") + 1, dataUrl.indexOf(";"));
+            String rawExtension = mimeType.substring(mimeType.indexOf("/") + 1);
            String extension = validateAndNormalizeExtension(rawExtension);

            // Save image file only
@@ -134,16 +134,16 @@ public class PdfJsonImageService {
            cache.put(cacheKey, image);
        }

-        float[] transform = element.getTransform();
-        if (transform != null && transform.length == 6) {
+        List<Float> transform = element.getTransform();
+        if (transform != null && transform.size() == 6) {
            Matrix matrix =
                    new Matrix(
-                            safeFloat(transform[0], 1f),
-                            safeFloat(transform[1], 0f),
-                            safeFloat(transform[2], 0f),
-                            safeFloat(transform[3], 1f),
-                            safeFloat(transform[4], 0f),
-                            safeFloat(transform[5], 0f));
+                            safeFloat(transform.get(0), 1f),
+                            safeFloat(transform.get(1), 0f),
+                            safeFloat(transform.get(2), 0f),
+                            safeFloat(transform.get(3), 1f),
+                            safeFloat(transform.get(4), 0f),
+                            safeFloat(transform.get(5), 0f));
            contentStream.drawImage(image, matrix);
            return;
        }
@@ -269,18 +269,18 @@ public class PdfJsonImageService {
        return 0f;
    }

-    private float[] toMatrixValues(Matrix matrix) {
-        return new float[] {
-            matrix.getValue(0, 0),
-            matrix.getValue(0, 1),
-            matrix.getValue(1, 0),
-            matrix.getValue(1, 1),
-            matrix.getValue(2, 0),
-            matrix.getValue(2, 1)
-        };
+    private List<Float> toMatrixValues(Matrix matrix) {
+        List<Float> values = new ArrayList<>(6);
+        values.add(matrix.getValue(0, 0));
+        values.add(matrix.getValue(0, 1));
+        values.add(matrix.getValue(1, 0));
+        values.add(matrix.getValue(1, 1));
+        values.add(matrix.getValue(2, 0));
+        values.add(matrix.getValue(2, 1));
+        return values;
    }

-    private static float safeFloat(Float value, float defaultValue) {
+    private float safeFloat(Float value, float defaultValue) {
        if (value == null || Float.isNaN(value) || Float.isInfinite(value)) {
            return defaultValue;
        }
@@ -324,7 +324,7 @@ public class PdfJsonImageService {
            }
            Matrix ctm = getGraphicsState().getCurrentTransformationMatrix();
            Bounds bounds = computeBounds(ctm);
-            float[] matrixValues = toMatrixValues(ctm);
+            List<Float> matrixValues = toMatrixValues(ctm);

            PdfJsonImageElement element =
                    PdfJsonImageElement.builder()
@@ -110,12 +110,7 @@ public class Type3LibraryStrategy implements Type3ConversionStrategy {
                .webProgramFormat(toFormat(entry.getWebProgram()))
                .pdfProgram(toBase64(entry.getPdfProgram()))
                .pdfProgramFormat(toFormat(entry.getPdfProgram()))
-                .glyphCoverage(
-                        entry.getGlyphCoverage() != null
-                                ? entry.getGlyphCoverage().stream()
-                                        .mapToInt(Integer::intValue)
-                                        .toArray()
-                                : null)
+                .glyphCoverage(entry.getGlyphCoverage())
                .message(message)
                .build();
    }
@@ -262,30 +262,17 @@ public class JobController {
    @Operation(summary = "Get file metadata")
    public ResponseEntity<?> getFileMetadata(@PathVariable("fileId") String fileId) {
        try {
-            String jobKey = taskManager.findJobKeyByFileId(fileId);
-            if (jobKey == null) {
+            // Verify file exists
+            if (!fileStorage.fileExists(fileId)) {
                return ResponseEntity.notFound().build();
            }

-            if (!validateJobAccess(jobKey)) {
-                log.warn("Unauthorized attempt to access file metadata: {}", fileId);
-                return ResponseEntity.status(403)
-                        .body(Map.of("message", "You are not authorized to access this file"));
-            }
-
            // Find the file metadata from any job that contains this file
            ResultFile resultFile = taskManager.findResultFileByFileId(fileId);

            if (resultFile != null) {
                return ResponseEntity.ok(resultFile);
-            }
-
-            if (!isSecurityEnabled()) {
-                // Backwards compatibility when ownership service is unavailable
-                if (!fileStorage.fileExists(fileId)) {
-                    return ResponseEntity.notFound().build();
-                }
-
+            } else {
                // File exists but no metadata found, get basic info efficiently
                long fileSize = fileStorage.getFileSize(fileId);
                return ResponseEntity.ok(
@@ -299,8 +286,6 @@ public class JobController {
                                "fileSize",
                                fileSize));
            }
-
-            return ResponseEntity.notFound().build();
        } catch (Exception e) {
            log.error("Error retrieving file metadata {}: {}", fileId, e.getMessage(), e);
            return ResponseEntity.internalServerError()
@@ -318,17 +303,11 @@ public class JobController {
    @Operation(summary = "Download a file")
    public ResponseEntity<?> downloadFile(@PathVariable("fileId") String fileId) {
        try {
-            String jobKey = taskManager.findJobKeyByFileId(fileId);
-            if (jobKey == null) {
+            // Verify file exists
+            if (!fileStorage.fileExists(fileId)) {
                return ResponseEntity.notFound().build();
            }

-            if (!validateJobAccess(jobKey)) {
-                log.warn("Unauthorized attempt to download file: {}", fileId);
-                return ResponseEntity.status(403)
-                        .body(Map.of("message", "You are not authorized to access this file"));
-            }
-
            // Retrieve file content
            byte[] fileContent = fileStorage.retrieveBytes(fileId);

@@ -348,14 +327,11 @@ public class JobController {
                    .body(fileContent);
        } catch (Exception e) {
            log.error("Error retrieving file {}: {}", fileId, e.getMessage(), e);
-            return ResponseEntity.internalServerError().body("Error retrieving file");
+            return ResponseEntity.internalServerError()
+                    .body("Error retrieving file: " + e.getMessage());
        }
    }

-    private boolean isSecurityEnabled() {
-        return jobOwnershipService != null;
-    }
-
    /**
     * Create Content-Disposition header with UTF-8 filename support
     *
@@ -1,9 +1,4 @@
 multipart.enabled=true
-
-# Jackson 3 defaults FAIL_ON_NULL_FOR_PRIMITIVES to true (was false in Jackson 2).
-# Restore Jackson 2 behaviour so absent/null JSON fields map to Java primitive defaults.
-spring.jackson.deserialization.fail-on-null-for-primitives=false
-
 logging.level.org.springframework=WARN
 logging.level.org.springframework.security=WARN
 logging.level.org.hibernate=WARN
@@ -30,16 +25,14 @@ server.compression.enabled=true
 server.compression.min-response-size=1024
 server.compression.mime-types=application/json,application/xml,text/html,text/plain,text/css,application/javascript

-spring.web.error.path=/error
-spring.web.error.whitelabel.enabled=false
-spring.web.error.include-stacktrace=always
-spring.web.error.include-exception=true
-spring.web.error.include-message=always
+server.error.path=/error
+server.error.whitelabel.enabled=false
+server.error.include-stacktrace=always
+server.error.include-exception=true
+server.error.include-message=always

-# Disable Spring's built-in ProblemDetailsExceptionHandler (@Order(0)) so that
-# GlobalExceptionHandler runs first and provides detailed, logged error responses.
-# GlobalExceptionHandler already produces RFC 7807 ProblemDetail objects.
-spring.mvc.problemdetails.enabled=false
+# Enable RFC 7807 Problem Details for HTTP APIs
+spring.mvc.problemdetails.enabled=true

 #logging.level.org.springframework.web=DEBUG
 #logging.level.org.springframework=DEBUG
@@ -96,19 +96,11 @@ premium:
      author: username
      creator: Stirling-PDF
      producer: Stirling-PDF
-    googleDrive:
-      enabled: false # Enable Google Drive file picker integration
-      clientId: "" # Google OAuth 2.0 client ID (obtain from Google Cloud Console)
-      apiKey: "" # Google API key for Google Picker API (obtain from Google Cloud Console)
-      appId: "" # Google Drive app ID
  enterpriseFeatures:
    audit:
-      enabled: true # Enable audit logging for security and compliance tracking
-      level: 2 # Audit logging level: 0=OFF, 1=BASIC (compress/split/merge/etc and settings), 2=STANDARD (BASIC + user actions, excludes polling), 3=VERBOSE (everything including polling).
-      retentionDays: 90 # Number of days to retain audit logs (0 or negative = infinite retention)
-      captureFileHash: false # Capture SHA-256 hash of uploaded/processed files. Warning: adds 50-200ms per file depending on size. Only enabled independently of audit level.
-      capturePdfAuthor: false # Capture author metadata from PDF documents. Warning: requires PDF parsing which increases processing time. Only enabled independently of audit level.
-      captureOperationResults: false # Capture operation return values and responses in audit log. Warning: not recommended, significantly increases log volume and disk usage. Use only for debugging.
+      enabled: true # Enable audit logging
+      level: 2 # Audit logging level: 0=OFF, 1=BASIC, 2=STANDARD, 3=VERBOSE
+      retentionDays: 90 # Number of days to retain audit logs
    databaseNotifications:
      backups:
        successful: false # set to 'true' to enable email notifications for successful database backups
@@ -181,7 +173,7 @@ system:
  corsAllowedOrigins: [] # List of allowed origins for CORS (e.g. ['http://localhost:5173', 'https://app.example.com']). Leave empty to disable CORS. For local development with frontend on port 5173, add 'http://localhost:5173'
  backendUrl: "" # Backend base URL for SAML/OAuth/API callbacks (e.g. 'http://localhost:8080' for dev, 'https://api.example.com' for production). REQUIRED for SSO authentication to work correctly. This is where your IdP will send SAML responses and OAuth callbacks. Leave empty to default to 'http://localhost:8080' in development.
  frontendUrl: "" # Frontend URL for invite email links (e.g. 'https://app.example.com'). Optional - if not set, will use backendUrl. This is the URL users click in invite emails.
-  enableMobileScanner: true # Enable mobile phone QR code upload feature. Requires frontendUrl to be configured.
+  enableMobileScanner: false # Enable mobile phone QR code upload feature. Requires frontendUrl to be configured.
  mobileScannerSettings:
    convertToPdf: true # Automatically convert uploaded images to PDF format. If false, images are kept as-is.
    imageResolution: full # Image resolution for mobile uploads: 'full' (original size) or 'reduced' (max 1200px on longest side). Only applies when convertToPdf is true.
@@ -240,12 +232,9 @@ system:
 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 restrict to specific languages, use a whitelist like ["de_DE", "pl_PL", "sv_SE"]. Empty list or not restricting any languages will enable all available languages.
+  languages: [] # If empty, all languages are enabled. To display only German and Polish ["de_DE", "pl_PL"]. British English is always enabled.
  defaultHideUnavailableTools: false # Default user preference: hide disabled tools instead of greying them out
  defaultHideUnavailableConversions: false # Default user preference: hide disabled conversion options instead of greying them out
-  hideDisabledTools:
-    googleDrive: false # Hide Google Drive button when not enabled
-    mobileQRScanner: false # Hide mobile QR scanner button when not enabled

 endpoints:
  toRemove: [] # list endpoints to disable (e.g. ['img-to-pdf', 'remove-pages'])
@@ -25,7 +25,6 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.mock.web.MockMultipartFile;
-import org.springframework.web.multipart.MultipartFile;

 import stirling.software.SPDF.model.api.general.SplitPdfBySizeOrCountRequest;
 import stirling.software.common.service.CustomPDFDocumentFactory;
@@ -70,15 +69,16 @@ class SplitPdfBySizeControllerTest {
        request.setSplitType(1); // Page count
        request.setSplitValue("2");

-        when(pdfDocumentFactory.load(any(MultipartFile.class)))
-                .thenAnswer(inv -> Loader.loadPDF(((MultipartFile) inv.getArgument(0)).getBytes()));
+        when(pdfDocumentFactory.load(any(byte[].class)))
+                .thenAnswer(inv -> Loader.loadPDF((byte[]) inv.getArgument(0)));

        when(pdfDocumentFactory.createNewDocumentBasedOnOldDocument(any(PDDocument.class)))
                .thenAnswer(inv -> new PDDocument());

-        ResponseEntity<?> response = controller.autoSplitPdf(request);
+        ResponseEntity<byte[]> response = controller.autoSplitPdf(request);

        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
+        assertThat(response.getBody()).isNotEmpty();
        assertThat(response.getHeaders().getContentType())
                .isEqualTo(MediaType.APPLICATION_OCTET_STREAM);
    }
@@ -104,19 +104,15 @@ class SplitPdfBySizeControllerTest {
        request.setSplitType(2); // Document count
        request.setSplitValue("3"); // Split into 3 docs (2 pages each)

-        when(pdfDocumentFactory.load(any(org.springframework.web.multipart.MultipartFile.class)))
-                .thenAnswer(
-                        inv ->
-                                Loader.loadPDF(
-                                        ((org.springframework.web.multipart.MultipartFile)
-                                                        inv.getArgument(0))
-                                                .getBytes()));
+        when(pdfDocumentFactory.load(any(byte[].class)))
+                .thenAnswer(inv -> Loader.loadPDF((byte[]) inv.getArgument(0)));

        when(pdfDocumentFactory.createNewDocumentBasedOnOldDocument(any(PDDocument.class)))
                .thenAnswer(inv -> new PDDocument());

-        ResponseEntity<?> response = controller.autoSplitPdf(request);
+        ResponseEntity<byte[]> response = controller.autoSplitPdf(request);

        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
+        assertThat(response.getBody()).isNotEmpty();
    }
 }
@@ -113,12 +113,10 @@ class ConvertPDFToEpubControllerTest {
            ResponseEntity<byte[]> response = controller.convertPdfToEpub(request);

            List<String> command = commandCaptor.getValue();
-            assertEquals(13, command.size());
+            assertEquals(11, command.size());
            assertEquals("ebook-convert", command.get(0));
            assertEquals(expectedInput.toString(), command.get(1));
            assertEquals(expectedOutput.toString(), command.get(2));
-            assertTrue(command.contains("--pdf-engine"));
-            assertTrue(command.contains("pdftohtml"));
            assertTrue(command.contains("--enable-heuristics"));
            assertTrue(command.contains("--insert-blank-line"));
            assertTrue(command.contains("--filter-css"));
@@ -208,13 +206,11 @@ class ConvertPDFToEpubControllerTest {
            assertTrue(command.stream().noneMatch(arg -> "--chapter".equals(arg)));
            assertTrue(command.contains("--output-profile"));
            assertTrue(command.contains(TargetDevice.KINDLE_EINK_TEXT.getCalibreProfile()));
-            assertTrue(command.contains("--pdf-engine"));
-            assertTrue(command.contains("pdftohtml"));
            assertTrue(command.contains("--filter-css"));
            assertTrue(
                    command.contains(
                            "font-family,color,background-color,margin-left,margin-right"));
-            assertTrue(command.size() >= 11);
+            assertTrue(command.size() >= 9);

            assertEquals(EPUB_MEDIA_TYPE, response.getHeaders().getContentType());
            assertEquals(
@@ -293,8 +289,6 @@ class ConvertPDFToEpubControllerTest {
            assertEquals("ebook-convert", command.get(0));
            assertEquals(expectedInput.toString(), command.get(1));
            assertEquals(expectedOutput.toString(), command.get(2));
-            assertTrue(command.contains("--pdf-engine"));
-            assertTrue(command.contains("pdftohtml"));
            assertTrue(command.contains("--enable-heuristics"));
            assertTrue(command.contains("--insert-blank-line"));
            assertTrue(command.contains("--filter-css"));
@@ -13,12 +13,10 @@ import org.springframework.mock.web.MockMultipartFile;

 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.PdfToCbzUtils;
-import stirling.software.common.util.TempFileManager;

 public class PdfToCbzUtilsTest {

    @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
-    @Mock private TempFileManager tempFileManager;

    @BeforeEach
    public void setUp() {
@@ -44,9 +42,7 @@ public class PdfToCbzUtilsTest {
        IllegalArgumentException exception =
                Assertions.assertThrows(
                        IllegalArgumentException.class,
-                        () ->
-                                PdfToCbzUtils.convertPdfToCbz(
-                                        null, 300, pdfDocumentFactory, tempFileManager));
+                        () -> PdfToCbzUtils.convertPdfToCbz(null, 300, pdfDocumentFactory));
        Assertions.assertEquals("File cannot be null or empty", exception.getMessage());
    }

@@ -58,9 +54,7 @@ public class PdfToCbzUtilsTest {
        IllegalArgumentException exception =
                Assertions.assertThrows(
                        IllegalArgumentException.class,
-                        () ->
-                                PdfToCbzUtils.convertPdfToCbz(
-                                        emptyFile, 300, pdfDocumentFactory, tempFileManager));
+                        () -> PdfToCbzUtils.convertPdfToCbz(emptyFile, 300, pdfDocumentFactory));
        Assertions.assertEquals("File cannot be null or empty", exception.getMessage());
    }

@@ -72,9 +66,7 @@ public class PdfToCbzUtilsTest {
        IllegalArgumentException exception =
                Assertions.assertThrows(
                        IllegalArgumentException.class,
-                        () ->
-                                PdfToCbzUtils.convertPdfToCbz(
-                                        nonPdfFile, 300, pdfDocumentFactory, tempFileManager));
+                        () -> PdfToCbzUtils.convertPdfToCbz(nonPdfFile, 300, pdfDocumentFactory));
        Assertions.assertEquals("File must be in PDF format", exception.getMessage());
    }

@@ -92,9 +84,7 @@ public class PdfToCbzUtilsTest {
        // structure
        Assertions.assertThrows(
                Exception.class,
-                () ->
-                        PdfToCbzUtils.convertPdfToCbz(
-                                pdfFile, 300, pdfDocumentFactory, tempFileManager));
+                () -> PdfToCbzUtils.convertPdfToCbz(pdfFile, 300, pdfDocumentFactory));

        // Verify that load was called
        Mockito.verify(pdfDocumentFactory).load(pdfFile);
@@ -18,10 +18,6 @@ class ApiEndpointTest {
    private final ObjectMapper mapper = JsonMapper.builder().build();

    private JsonNode postNodeWithParams(String description, String... names) {
-        return postNodeWithParams(description, true, names);
-    }
-
-    private JsonNode postNodeWithParams(String description, boolean required, String... names) {
        ObjectNode post = mapper.createObjectNode();
        post.put("description", description);
        ArrayNode params = mapper.createArrayNode();
@@ -30,7 +26,6 @@ class ApiEndpointTest {
            if (n != null) {
                p.put("name", n);
            }
-            p.put("required", required);
            params.add(p);
        }
        post.set("parameters", params);
@@ -97,75 +92,6 @@ class ApiEndpointTest {
        assertTrue(endpoint.areParametersValid(Map.of("", 42)));
    }

-    @Test
-    void optional_parameters_can_be_omitted() {
-        JsonNode post = postNodeWithParams("desc", false, "fileOrder");
-        ApiEndpoint endpoint = new ApiEndpoint("merge", post);
-
-        assertTrue(
-                endpoint.areParametersValid(Map.of()),
-                "Should be valid when optional param is omitted");
-    }
-
-    @Test
-    void mixed_required_and_optional_validates_only_required() {
-        ObjectNode post = mapper.createObjectNode();
-        post.put("description", "merge pdfs");
-        ArrayNode params = mapper.createArrayNode();
-
-        ObjectNode required = mapper.createObjectNode();
-        required.put("name", "sortType");
-        required.put("required", true);
-        params.add(required);
-
-        ObjectNode optional = mapper.createObjectNode();
-        optional.put("name", "fileOrder");
-        optional.put("required", false);
-        params.add(optional);
-
-        post.set("parameters", params);
-        ApiEndpoint endpoint = new ApiEndpoint("/api/v1/general/merge-pdfs", post);
-
-        Map<String, Object> provided = new HashMap<>();
-        provided.put("sortType", "byFileName");
-
-        assertTrue(
-                endpoint.areParametersValid(provided),
-                "Should pass when required params present and optional omitted");
-
-        provided.put("fileOrder", "0,1,2");
-        assertTrue(
-                endpoint.areParametersValid(provided),
-                "Should also pass when optional param is provided");
-    }
-
-    @Test
-    void missing_required_param_with_optional_present_still_fails() {
-        ObjectNode post = mapper.createObjectNode();
-        post.put("description", "desc");
-        ArrayNode params = mapper.createArrayNode();
-
-        ObjectNode required = mapper.createObjectNode();
-        required.put("name", "file");
-        required.put("required", true);
-        params.add(required);
-
-        ObjectNode optional = mapper.createObjectNode();
-        optional.put("name", "fileOrder");
-        optional.put("required", false);
-        params.add(optional);
-
-        post.set("parameters", params);
-        ApiEndpoint endpoint = new ApiEndpoint("x", post);
-
-        Map<String, Object> provided = new HashMap<>();
-        provided.put("fileOrder", "0,1");
-
-        assertFalse(
-                endpoint.areParametersValid(provided),
-                "Should fail when required param is missing even if optional is present");
-    }
-
    @Test
    void toString_contains_name_and_parameter_names() {
        JsonNode post = postNodeWithParams("desc", "file", "mode");
@@ -74,37 +74,15 @@ class ApiDocServiceTest {
    @Test
    void isValidOperationChecksRequiredParameters() throws Exception {
        String json =
-                "{\"description\": \"desc\", \"parameters\": [{\"name\":\"param1\", \"required\": true}, {\"name\":\"param2\", \"required\": true}]}";
+                "{\"description\": \"desc\", \"parameters\": [{\"name\":\"param1\"}, {\"name\":\"param2\"}]}";
        JsonNode postNode = mapper.readTree(json);
        ApiEndpoint endpoint = new ApiEndpoint("/op", postNode);

        setApiDocumentation(Map.of("/op", endpoint));
        setApiDocsJsonRootNode();

-        // All required params provided - valid
        assertTrue(apiDocService.isValidOperation("/op", Map.of("param1", "a", "param2", "b")));
-        // Missing required param2 - invalid
        assertFalse(apiDocService.isValidOperation("/op", Map.of("param1", "a")));
-        // Missing required param1 - invalid
-        assertFalse(apiDocService.isValidOperation("/op", Map.of("param2", "b")));
-    }
-
-    @Test
-    void isValidOperationAllowsOptionalParameters() throws Exception {
-        String json =
-                "{\"description\": \"desc\", \"parameters\": [{\"name\":\"param1\", \"required\": false}, {\"name\":\"param2\", \"required\": false}]}";
-        JsonNode postNode = mapper.readTree(json);
-        ApiEndpoint endpoint = new ApiEndpoint("/op", postNode);
-
-        setApiDocumentation(Map.of("/op", endpoint));
-        setApiDocsJsonRootNode();
-
-        // All optional params provided - valid
-        assertTrue(apiDocService.isValidOperation("/op", Map.of("param1", "a", "param2", "b")));
-        // Only one optional param provided - valid
-        assertTrue(apiDocService.isValidOperation("/op", Map.of("param1", "a")));
-        // No optional params provided - valid
-        assertTrue(apiDocService.isValidOperation("/op", Map.of()));
    }

    @Test
@@ -93,7 +93,7 @@ class LanguageServiceBasicTest {
        // Configure the test service
        ((LanguageServiceForTest) languageService).setMockResources(mockResources);

-        // Allow only specific languages - strict whitelist
+        // Allow only specific languages (en_GB is always included)
        when(applicationProperties.getUi().getLanguages())
                .thenReturn(Arrays.asList("en_US", "fr_FR"));

@@ -103,9 +103,7 @@ class LanguageServiceBasicTest {
        // Verify filtering by restrictions
        assertTrue(supportedLanguages.contains("en_US"), "Allowed language should be included");
        assertTrue(supportedLanguages.contains("fr_FR"), "Allowed language should be included");
-        assertFalse(
-                supportedLanguages.contains("en_GB"),
-                "en_GB should NOT be included when not in whitelist");
+        assertTrue(supportedLanguages.contains("en_GB"), "en_GB should always be included");
        assertFalse(supportedLanguages.contains("de_DE"), "Restricted language should be excluded");
    }

@@ -69,28 +69,25 @@ class LanguageServiceTest {
        // Setup
        Set<String> expectedLanguages =
                new HashSet<>(Arrays.asList("en_US", "fr_FR", "de_DE", "en_GB"));
-        Set<String> allowedLanguages = new HashSet<>(Arrays.asList("en_US", "fr_FR"));
+        Set<String> allowedLanguages = new HashSet<>(Arrays.asList("en_US", "fr_FR", "en_GB"));

        // Mock the resource resolver response
        Resource[] mockResources = createMockResources(expectedLanguages);
        ((LanguageServiceForTest) languageService).setMockResources(mockResources);

-        // Set language restrictions in properties - strict whitelist only
+        // Set language restrictions in properties
        when(applicationProperties.getUi().getLanguages())
-                .thenReturn(Arrays.asList("en_US", "fr_FR"));
+                .thenReturn(Arrays.asList("en_US", "fr_FR")); // en_GB is always allowed

        // Test
        Set<String> supportedLanguages = languageService.getSupportedLanguages();

        // Verify
        assertEquals(
-                allowedLanguages, supportedLanguages, "Should return only whitelisted languages");
-        assertFalse(
-                supportedLanguages.contains("en_GB"),
-                "en_GB should NOT be included when not in whitelist");
-        assertFalse(
-                supportedLanguages.contains("de_DE"),
-                "de_DE should NOT be included when not in whitelist");
+                allowedLanguages,
+                supportedLanguages,
+                "Should return only allowed languages, plus en_GB which is always allowed");
+        assertTrue(supportedLanguages.contains("en_GB"), "en_GB should always be included");
    }

    @Test
@@ -27,7 +27,7 @@ import stirling.software.common.service.UserServiceInterface;
 class PdfMetadataServiceBasicTest {

    private PdfMetadataService pdfMetadataService;
-    private static final String STIRLING_PDF_LABEL = "Stirling PDF";
+    private final String STIRLING_PDF_LABEL = "Stirling PDF";

    @BeforeEach
    void setUp() {
@@ -33,7 +33,7 @@ class PdfMetadataServiceTest {
    @Mock private ApplicationProperties applicationProperties;
    @Mock private UserServiceInterface userService;
    private PdfMetadataService pdfMetadataService;
-    private static final String STIRLING_PDF_LABEL = "Stirling PDF";
+    private final String STIRLING_PDF_LABEL = "Stirling PDF";

    @BeforeEach
    void setUp() {
@@ -191,6 +191,30 @@ class PdfMetadataServiceTest {
        // We don't verify setProducer here to avoid the "Too many actual invocations" error
    }

+    @Test
+    void testSetMetadataToPdf_WithProFeaturesAndMissingUsername() {
+        PDDocument testDocument = mock(PDDocument.class);
+        PDDocumentInformation testInfo = mock(PDDocumentInformation.class);
+        when(testDocument.getDocumentInformation()).thenReturn(testInfo);
+
+        PdfMetadataService proService =
+                new PdfMetadataService(
+                        applicationProperties, STIRLING_PDF_LABEL, true, userService);
+
+        PdfMetadata testMetadata = PdfMetadata.builder().author("Original Author").build();
+
+        CustomMetadata customMetadata =
+                applicationProperties.getPremium().getProFeatures().getCustomMetadata();
+        when(customMetadata.isAutoUpdateMetadata()).thenReturn(true);
+        when(customMetadata.getAuthor()).thenReturn("Pro Author username");
+        when(userService.getCurrentUsername()).thenReturn(null);
+
+        proService.setMetadataToPdf(testDocument, testMetadata, false);
+
+        // When username is null, the "username" placeholder should not be replaced
+        verify(testInfo).setAuthor("Pro Author username");
+    }
+
    @Test
    void testSetMetadataToPdf_ExistingDocument() {
        // Create a fresh document
@@ -28,8 +28,8 @@ class SignatureServiceTest {
    private SharedSignatureService signatureService;
    private Path personalSignatureFolder;
    private Path sharedSignatureFolder;
-    private static final String ALL_USERS_FOLDER = "ALL_USERS";
-    private static final String TEST_USER = "testUser";
+    private final String ALL_USERS_FOLDER = "ALL_USERS";
+    private final String TEST_USER = "testUser";

    @BeforeEach
    void setUp() throws IOException {
@@ -15,13 +15,11 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.mock.web.MockHttpSession;
-import org.springframework.test.util.ReflectionTestUtils;

 import jakarta.servlet.http.HttpServletRequest;

 import stirling.software.common.model.job.JobResult;
 import stirling.software.common.service.FileStorage;
-import stirling.software.common.service.JobOwnershipService;
 import stirling.software.common.service.JobQueue;
 import stirling.software.common.service.TaskManager;

@@ -35,8 +33,6 @@ class JobControllerTest {

    @Mock private HttpServletRequest request;

-    @Mock private JobOwnershipService jobOwnershipService;
-
    private MockHttpSession session;

    @InjectMocks private JobController controller;
@@ -408,32 +404,4 @@ class JobControllerTest {

        verify(taskManager).setError(jobId, "Job was cancelled by user");
    }
-
-    @Test
-    void testDownloadFile_ForbiddenWhenFileOwnedByAnotherUser() throws Exception {
-        String fileId = "file-id";
-
-        ReflectionTestUtils.setField(controller, "jobOwnershipService", jobOwnershipService);
-        when(taskManager.findJobKeyByFileId(fileId)).thenReturn("other-user:job-id");
-        when(jobOwnershipService.validateJobAccess("other-user:job-id")).thenReturn(false);
-
-        ResponseEntity<?> response = controller.downloadFile(fileId);
-
-        assertEquals(HttpStatus.FORBIDDEN, response.getStatusCode());
-        verify(fileStorage, never()).retrieveBytes(eq(fileId));
-    }
-
-    @Test
-    void testGetFileMetadata_ForbiddenWhenFileOwnedByAnotherUser() throws Exception {
-        String fileId = "file-id";
-
-        ReflectionTestUtils.setField(controller, "jobOwnershipService", jobOwnershipService);
-        when(taskManager.findJobKeyByFileId(fileId)).thenReturn("other-user:job-id");
-        when(jobOwnershipService.validateJobAccess("other-user:job-id")).thenReturn(false);
-
-        ResponseEntity<?> response = controller.getFileMetadata(fileId);
-
-        assertEquals(HttpStatus.FORBIDDEN, response.getStatusCode());
-        verify(fileStorage, never()).getFileSize(eq(fileId));
-    }
 }
@@ -1,6 +1,5 @@
 repositories {
    maven { url = "https://build.shibboleth.net/maven/releases" }
-    maven { url = "https://repository.jboss.org/" }
 }

 ext {
@@ -14,10 +13,10 @@ bootRun {
 spotless {
        java {
        target 'src/**/java/**/*.java'
-        targetExclude 'src/main/java/org/apache/**'
        googleJavaFormat(googleJavaFormatVersion).aosp().reorderImports(false)

        importOrder("java", "javax", "org", "com", "net", "io", "jakarta", "lombok", "me", "stirling")
+        toggleOffOn()
        trimTrailingWhitespace()
        leadingTabsToSpaces()
        endWithNewline()
@@ -37,7 +36,6 @@ spotless {
 }
 dependencies {
    implementation project(':common')
-    api 'com.google.guava:guava:33.4.8-jre'

    api 'org.springframework:spring-jdbc'
    api 'org.springframework:spring-webmvc'
@@ -65,9 +63,12 @@ dependencies {
    runtimeOnly "io.jsonwebtoken:jjwt-jackson:$jwtVersion"
    runtimeOnly 'com.h2database:h2:2.3.232' // Don't upgrade h2database
    runtimeOnly 'org.postgresql:postgresql:42.7.10'
-    implementation('com.coveo:saml-client:5.0.0') {
-        exclude group: 'org.opensaml', module: 'opensaml-core'
+    constraints {
+        implementation "org.opensaml:opensaml-core:$openSamlVersion"
+        implementation "org.opensaml:opensaml-saml-api:$openSamlVersion"
+        implementation "org.opensaml:opensaml-saml-impl:$openSamlVersion"
    }
+    implementation 'com.coveo:saml-client:5.0.0'
 }

 tasks.register('prepareKotlinBuildScriptModel') {}
@@ -8,7 +8,6 @@ import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.reflect.MethodSignature;
-import org.slf4j.MDC;
 import org.springframework.stereotype.Component;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
@@ -42,67 +41,33 @@ public class AuditAspect {

        // Fast path: use unified check to determine if we should audit
        // This avoids all data collection if auditing is disabled
-        if (!auditService.shouldAudit(method, auditConfig)) {
+        if (!AuditUtils.shouldAudit(method, auditConfig)) {
            return joinPoint.proceed();
        }

-        // EARLY CAPTURE: Try to get from MDC first (propagated from background threads)
-        // If not found, capture from SecurityContext on request thread
-        String capturedPrincipal = MDC.get("auditPrincipal");
-        if (capturedPrincipal == null) {
-            // Fallback: Capture from SecurityContext if running in request thread
-            capturedPrincipal = auditService.captureCurrentPrincipal();
-        }
-
-        String capturedOrigin = MDC.get("auditOrigin");
-        if (capturedOrigin == null) {
-            // Fallback: Capture from SecurityContext if running in request thread
-            capturedOrigin = auditService.captureCurrentOrigin();
-        }
-
-        ServletRequestAttributes attrs =
-                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
-        HttpServletRequest req = attrs != null ? attrs.getRequest() : null;
-
-        String capturedIp = MDC.get("auditIp");
-        if (capturedIp == null) {
-            // Fallback: Try to extract from request if available
-            capturedIp = auditService.extractClientIp(req);
-        }
-
        // Only create the map once we know we'll use it
        Map<String, Object> auditData =
-                auditService.createBaseAuditData(joinPoint, auditedAnnotation.level());
+                AuditUtils.createBaseAuditData(joinPoint, auditedAnnotation.level());

        // Add HTTP information if we're in a web context
+        ServletRequestAttributes attrs =
+                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attrs != null) {
+            HttpServletRequest req = attrs.getRequest();
            String path = req.getRequestURI();
            String httpMethod = req.getMethod();
-            auditService.addHttpData(auditData, httpMethod, path, auditedAnnotation.level());
-            auditService.addFileData(auditData, joinPoint, auditedAnnotation.level());
-
-            // File operation details logged at DEBUG level for verification
-            if (auditData.containsKey("files") || auditData.containsKey("filename")) {
-                log.debug(
-                        "@Audited method file operation - Principal: {}, Origin: {}, IP: {}, Method: {}, Path: {}, Files: {}",
-                        capturedPrincipal,
-                        capturedOrigin,
-                        capturedIp,
-                        httpMethod,
-                        path,
-                        auditData.getOrDefault("files", auditData.getOrDefault("filename", "N/A")));
-            }
-            if (auditData.containsKey("fileHash") || auditData.containsKey("hash")) {
-                log.debug(
-                        "@Audited file hash captured - Hash: {}, Document: {}",
-                        auditData.getOrDefault("fileHash", auditData.getOrDefault("hash", "N/A")),
-                        auditData.getOrDefault("filename", "N/A"));
-            }
+            AuditUtils.addHttpData(auditData, httpMethod, path, auditedAnnotation.level());
+            AuditUtils.addFileData(auditData, joinPoint, auditedAnnotation.level());
        }

-        // Add method arguments if requested (captured at all audit levels for operational context)
-        if (auditedAnnotation.includeArgs()) {
-            auditService.addMethodArguments(auditData, joinPoint, auditedAnnotation.level());
+        // Add arguments if requested and if at VERBOSE level, or if specifically requested
+        boolean includeArgs =
+                auditedAnnotation.includeArgs()
+                        && (auditedAnnotation.level() == AuditLevel.VERBOSE
+                                || auditConfig.getAuditLevel() == AuditLevel.VERBOSE);
+
+        if (includeArgs) {
+            AuditUtils.addMethodArguments(auditData, joinPoint, AuditLevel.VERBOSE);
        }

        // Record start time for latency calculation
@@ -115,14 +80,15 @@ public class AuditAspect {
            // Add success status
            auditData.put("status", "success");

-            // Add result only if requested in annotation AND operation result capture is enabled
+            // Add result if requested and if at VERBOSE level
            boolean includeResult =
                    auditedAnnotation.includeResult()
-                            && auditService.shouldCaptureOperationResults();
+                            && (auditedAnnotation.level() == AuditLevel.VERBOSE
+                                    || auditConfig.getAuditLevel() == AuditLevel.VERBOSE);

            if (includeResult && result != null) {
                // Use safe string conversion with size limiting
-                auditData.put("result", auditService.safeToString(result, 1000));
+                auditData.put("result", AuditUtils.safeToString(result, 1000));
            }

            return result;
@@ -139,19 +105,20 @@ public class AuditAspect {
            // methods
            HttpServletResponse resp = attrs != null ? attrs.getResponse() : null;
            boolean isHttpRequest = attrs != null;
-            auditService.addTimingData(
+            AuditUtils.addTimingData(
                    auditData, startTime, resp, auditedAnnotation.level(), isHttpRequest);

            // Resolve the event type based on annotation and context
            String httpMethod = null;
            String path = null;
            if (attrs != null) {
+                HttpServletRequest req = attrs.getRequest();
                httpMethod = req.getMethod();
                path = req.getRequestURI();
            }

            AuditEventType eventType =
-                    auditService.resolveEventType(
+                    AuditUtils.resolveEventType(
                            method,
                            joinPoint.getTarget().getClass(),
                            path,
@@ -161,23 +128,11 @@ public class AuditAspect {
            // Check if we should use string type instead
            String typeString = auditedAnnotation.typeString();
            if (eventType == AuditEventType.HTTP_REQUEST && StringUtils.isNotEmpty(typeString)) {
-                // Use the string type with early-captured values
-                auditService.audit(
-                        capturedPrincipal,
-                        capturedOrigin,
-                        capturedIp,
-                        typeString,
-                        auditData,
-                        auditedAnnotation.level());
+                // Use the string type (for backward compatibility)
+                auditService.audit(typeString, auditData, auditedAnnotation.level());
            } else {
-                // Use the enum type with early-captured values
-                auditService.audit(
-                        capturedPrincipal,
-                        capturedOrigin,
-                        capturedIp,
-                        eventType,
-                        auditData,
-                        auditedAnnotation.level());
+                // Use the enum type (preferred)
+                auditService.audit(eventType, auditData, auditedAnnotation.level());
            }
        }
    }
@@ -22,9 +22,6 @@ public enum AuditEventType {
    // PDF operations - STANDARD level
    PDF_PROCESS("PDF processing operation"),

-    // UI data requests - STANDARD level
-    UI_DATA("UI data request"),
-
    // HTTP requests - STANDARD level
    HTTP_REQUEST("HTTP request");

@@ -52,7 +49,7 @@ public enum AuditEventType {
            // If the exact enum name doesn't match, try finding a similar one
            for (AuditEventType eventType : values()) {
                if (eventType.name().equalsIgnoreCase(type)
-                        || eventType.description.equalsIgnoreCase(type)) {
+                        || eventType.getDescription().equalsIgnoreCase(type)) {
                    return eventType;
                }
            }
@@ -12,26 +12,21 @@ public enum AuditLevel {
    OFF(0),

    /**
-     * BASIC - File modifications only (level 1) Tracks: PDF file operations like compress, split,
-     * merge, etc., and settings changes. Captures: Operation status (success/failure), method
-     * parameters, timing. Ideal for: Compliance tracking of file modifications with minimal log
-     * volume.
+     * BASIC - Minimal audit logging (level 1) Includes: - Authentication events (login, logout,
+     * failed logins) - Password changes - User/role changes - System configuration changes
     */
    BASIC(1),

    /**
-     * STANDARD - File operations and user actions (level 2) Tracks: Everything in BASIC plus user
-     * actions like login/logout, account changes, and general GET requests. Excludes continuous
-     * polling calls (e.g., auth/me, app-config, health, metrics endpoints). Ideal for: General
-     * audit trail with reasonable log volume for most deployments.
+     * STANDARD - Standard audit logging (level 2) Includes everything in BASIC plus: - All HTTP
+     * requests (basic info: URL, method, status) - File operations (upload, download, process) -
+     * PDF operations (view, edit, etc.) - User operations
     */
    STANDARD(2),

    /**
-     * VERBOSE - Everything including polling (level 3) Tracks: Everything in STANDARD plus
-     * continuous polling calls and all GET requests. Captures: Detailed timing information. Note:
-     * Operation results (return values) are controlled by separate captureOperationResults flag.
-     * Warning: High log volume and performance impact.
+     * VERBOSE - Detailed audit logging (level 3) Includes everything in STANDARD plus: - Request
+     * headers and parameters - Method parameters - Operation results - Detailed timing information
     */
    VERBOSE(3);

@@ -0,0 +1,427 @@
+package stirling.software.proprietary.audit;
+
+import java.lang.reflect.Method;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import org.apache.commons.lang3.StringUtils;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.slf4j.MDC;
+import org.springframework.http.MediaType;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+import org.springframework.web.multipart.MultipartFile;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import lombok.extern.slf4j.Slf4j;
+
+import stirling.software.common.util.RegexPatternUtils;
+import stirling.software.common.util.RequestUriUtils;
+import stirling.software.proprietary.config.AuditConfigurationProperties;
+
+/**
+ * Shared utilities for audit aspects to ensure consistent behavior across different audit
+ * mechanisms.
+ */
+@Slf4j
+public class AuditUtils {
+
+    /**
+     * Create a standard audit data map with common attributes based on the current audit level
+     *
+     * @param joinPoint The AspectJ join point
+     * @param auditLevel The current audit level
+     * @return A map with standard audit data
+     */
+    public static Map<String, Object> createBaseAuditData(
+            ProceedingJoinPoint joinPoint, AuditLevel auditLevel) {
+        Map<String, Object> data = new HashMap<>();
+
+        // Common data for all levels
+        data.put("timestamp", Instant.now().toString());
+
+        // Add principal if available
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        if (auth != null && auth.getName() != null) {
+            data.put("principal", auth.getName());
+        } else {
+            data.put("principal", "system");
+        }
+
+        // Add class name and method name only at VERBOSE level
+        if (auditLevel.includes(AuditLevel.VERBOSE)) {
+            data.put("className", joinPoint.getTarget().getClass().getName());
+            data.put(
+                    "methodName",
+                    ((MethodSignature) joinPoint.getSignature()).getMethod().getName());
+        }
+
+        return data;
+    }
+
+    /**
+     * Add HTTP-specific information to the audit data if available
+     *
+     * @param data The existing audit data map
+     * @param httpMethod The HTTP method (GET, POST, etc.)
+     * @param path The request path
+     * @param auditLevel The current audit level
+     */
+    public static void addHttpData(
+            Map<String, Object> data, String httpMethod, String path, AuditLevel auditLevel) {
+        if (httpMethod == null || path == null) {
+            return; // Skip if we don't have basic HTTP info
+        }
+
+        // BASIC level HTTP data
+        data.put("httpMethod", httpMethod);
+        data.put("path", path);
+
+        // Get request attributes safely
+        ServletRequestAttributes attrs =
+                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+        if (attrs == null) {
+            return; // No request context available
+        }
+
+        HttpServletRequest req = attrs.getRequest();
+        if (req == null) {
+            return; // No request available
+        }
+
+        // STANDARD level HTTP data
+        if (auditLevel.includes(AuditLevel.STANDARD)) {
+            data.put("clientIp", req.getRemoteAddr());
+            data.put(
+                    "sessionId",
+                    req.getSession(false) != null ? req.getSession(false).getId() : null);
+            data.put("requestId", MDC.get("requestId"));
+
+            // Form data for POST/PUT/PATCH
+            if (("POST".equalsIgnoreCase(httpMethod)
+                            || "PUT".equalsIgnoreCase(httpMethod)
+                            || "PATCH".equalsIgnoreCase(httpMethod))
+                    && req.getContentType() != null) {
+
+                String contentType = req.getContentType();
+                if (contentType.contains(MediaType.APPLICATION_FORM_URLENCODED_VALUE)
+                        || contentType.contains(MediaType.MULTIPART_FORM_DATA_VALUE)) {
+
+                    Map<String, String[]> params = new HashMap<>(req.getParameterMap());
+                    // Remove CSRF token from logged parameters
+                    params.remove("_csrf");
+
+                    if (!params.isEmpty()) {
+                        data.put("formParams", params);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Add file information to the audit data if available
+     *
+     * @param data The existing audit data map
+     * @param joinPoint The AspectJ join point
+     * @param auditLevel The current audit level
+     */
+    public static void addFileData(
+            Map<String, Object> data, ProceedingJoinPoint joinPoint, AuditLevel auditLevel) {
+        if (auditLevel.includes(AuditLevel.STANDARD)) {
+            List<MultipartFile> files =
+                    Arrays.stream(joinPoint.getArgs())
+                            .filter(a -> a instanceof MultipartFile)
+                            .map(a -> (MultipartFile) a)
+                            .collect(Collectors.toList());
+
+            if (!files.isEmpty()) {
+                List<Map<String, Object>> fileInfos =
+                        files.stream()
+                                .map(
+                                        f -> {
+                                            Map<String, Object> m = new HashMap<>();
+                                            m.put("name", f.getOriginalFilename());
+                                            m.put("size", f.getSize());
+                                            m.put("type", f.getContentType());
+                                            return m;
+                                        })
+                                .collect(Collectors.toList());
+
+                data.put("files", fileInfos);
+            }
+        }
+    }
+
+    /**
+     * Add method arguments to the audit data
+     *
+     * @param data The existing audit data map
+     * @param joinPoint The AspectJ join point
+     * @param auditLevel The current audit level
+     */
+    public static void addMethodArguments(
+            Map<String, Object> data, ProceedingJoinPoint joinPoint, AuditLevel auditLevel) {
+        if (auditLevel.includes(AuditLevel.VERBOSE)) {
+            MethodSignature sig = (MethodSignature) joinPoint.getSignature();
+            String[] names = sig.getParameterNames();
+            Object[] vals = joinPoint.getArgs();
+            if (names != null && vals != null) {
+                IntStream.range(0, names.length)
+                        .forEach(
+                                i -> {
+                                    if (vals[i] != null) {
+                                        // Convert objects to safe string representation
+                                        data.put("arg_" + names[i], safeToString(vals[i], 500));
+                                    } else {
+                                        data.put("arg_" + names[i], null);
+                                    }
+                                });
+            }
+        }
+    }
+
+    /**
+     * Safely convert an object to string with size limiting
+     *
+     * @param obj The object to convert
+     * @param maxLength Maximum length of the resulting string
+     * @return A safe string representation, truncated if needed
+     */
+    public static String safeToString(Object obj, int maxLength) {
+        if (obj == null) {
+            return "null";
+        }
+
+        String result;
+        try {
+            // Handle common types directly to avoid toString() overhead
+            if (obj instanceof String) {
+                result = (String) obj;
+            } else if (obj instanceof Number || obj instanceof Boolean) {
+                result = obj.toString();
+            } else if (obj instanceof byte[]) {
+                result = "[binary data length=" + ((byte[]) obj).length + "]";
+            } else {
+                // For complex objects, use toString but handle exceptions
+                result = obj.toString();
+            }
+
+            // Truncate if necessary
+            if (result != null && result.length() > maxLength) {
+                return StringUtils.truncate(result, maxLength - 3) + "...";
+            }
+
+            return result;
+        } catch (Exception e) {
+            // If toString() fails, return the class name
+            return "[" + obj.getClass().getName() + " - toString() failed]";
+        }
+    }
+
+    /**
+     * Determine if a method should be audited based on config and annotation
+     *
+     * @param method The method to check
+     * @param auditConfig The audit configuration
+     * @return true if the method should be audited
+     */
+    public static boolean shouldAudit(Method method, AuditConfigurationProperties auditConfig) {
+        // First check if audit is globally enabled - fast path
+        if (!auditConfig.isEnabled()) {
+            return false;
+        }
+
+        // Check for annotation override
+        Audited auditedAnnotation = method.getAnnotation(Audited.class);
+        AuditLevel requiredLevel =
+                (auditedAnnotation != null) ? auditedAnnotation.level() : AuditLevel.BASIC;
+
+        // Check if the required level is enabled
+        return auditConfig.getAuditLevel().includes(requiredLevel);
+    }
+
+    /**
+     * Add timing and response status data to the audit record
+     *
+     * @param data The audit data to add to
+     * @param startTime The start time in milliseconds
+     * @param response The HTTP response (may be null for non-HTTP methods)
+     * @param level The current audit level
+     * @param isHttpRequest Whether this is an HTTP request (controller) or a regular method call
+     */
+    public static void addTimingData(
+            Map<String, Object> data,
+            long startTime,
+            HttpServletResponse response,
+            AuditLevel level,
+            boolean isHttpRequest) {
+        if (level.includes(AuditLevel.STANDARD)) {
+            // For HTTP requests, let ControllerAuditAspect handle timing separately
+            // For non-HTTP methods, add execution time here
+            if (!isHttpRequest) {
+                data.put("latencyMs", System.currentTimeMillis() - startTime);
+            }
+
+            // Add HTTP status code if available
+            if (response != null) {
+                try {
+                    data.put("statusCode", response.getStatus());
+                } catch (Exception e) {
+                    // Ignore - response might be in an inconsistent state
+                }
+            }
+        }
+    }
+
+    /**
+     * Resolve the event type to use for auditing, considering annotations and context
+     *
+     * @param method The method being audited
+     * @param controller The controller class
+     * @param path The request path (may be null for non-HTTP methods)
+     * @param httpMethod The HTTP method (may be null for non-HTTP methods)
+     * @param annotation The @Audited annotation (may be null)
+     * @return The resolved event type (never null)
+     */
+    public static AuditEventType resolveEventType(
+            Method method,
+            Class<?> controller,
+            String path,
+            String httpMethod,
+            Audited annotation) {
+        // First check if we have an explicit annotation
+        if (annotation != null && annotation.type() != AuditEventType.HTTP_REQUEST) {
+            return annotation.type();
+        }
+
+        // For HTTP methods, infer based on controller and path
+        if (httpMethod != null && path != null) {
+            String cls = controller.getSimpleName().toLowerCase(Locale.ROOT);
+            String pkg = controller.getPackage().getName().toLowerCase(Locale.ROOT);
+
+            if ("GET".equals(httpMethod)) return AuditEventType.HTTP_REQUEST;
+
+            if (cls.contains("user")
+                    || cls.contains("auth")
+                    || pkg.contains("auth")
+                    || path.startsWith("/user")
+                    || path.startsWith("/login")) {
+                return AuditEventType.USER_PROFILE_UPDATE;
+            } else if (cls.contains("admin")
+                    || path.startsWith("/admin")
+                    || path.startsWith("/settings")) {
+                return AuditEventType.SETTINGS_CHANGED;
+            } else if (cls.contains("file")
+                    || path.startsWith("/file")
+                    || RegexPatternUtils.getInstance()
+                            .getUploadDownloadPathPattern()
+                            .matcher(path)
+                            .matches()) {
+                return AuditEventType.FILE_OPERATION;
+            }
+        }
+
+        // Default for non-HTTP methods or when no specific match
+        return AuditEventType.PDF_PROCESS;
+    }
+
+    /**
+     * Determine the appropriate audit level to use
+     *
+     * @param method The method to check
+     * @param defaultLevel The default level to use if no annotation present
+     * @param auditConfig The audit configuration
+     * @return The audit level to use
+     */
+    public static AuditLevel getEffectiveAuditLevel(
+            Method method, AuditLevel defaultLevel, AuditConfigurationProperties auditConfig) {
+        Audited auditedAnnotation = method.getAnnotation(Audited.class);
+        if (auditedAnnotation != null) {
+            // Method has @Audited - use its level
+            return auditedAnnotation.level();
+        }
+
+        // Use default level (typically from global config)
+        return defaultLevel;
+    }
+
+    /**
+     * Determine the appropriate audit event type to use
+     *
+     * @param method The method being audited
+     * @param controller The controller class
+     * @param path The request path
+     * @param httpMethod The HTTP method
+     * @return The determined audit event type
+     */
+    public static AuditEventType determineAuditEventType(
+            Method method, Class<?> controller, String path, String httpMethod) {
+        // First check for explicit annotation
+        Audited auditedAnnotation = method.getAnnotation(Audited.class);
+        if (auditedAnnotation != null) {
+            return auditedAnnotation.type();
+        }
+
+        // Otherwise infer from controller and path
+        String cls = controller.getSimpleName().toLowerCase(Locale.ROOT);
+        String pkg = controller.getPackage().getName().toLowerCase(Locale.ROOT);
+
+        if ("GET".equals(httpMethod)) return AuditEventType.HTTP_REQUEST;
+
+        if (cls.contains("user")
+                || cls.contains("auth")
+                || pkg.contains("auth")
+                || path.startsWith("/user")
+                || path.startsWith("/login")) {
+            return AuditEventType.USER_PROFILE_UPDATE;
+        } else if (cls.contains("admin")
+                || path.startsWith("/admin")
+                || path.startsWith("/settings")) {
+            return AuditEventType.SETTINGS_CHANGED;
+        } else if (cls.contains("file")
+                || path.startsWith("/file")
+                || RegexPatternUtils.getInstance()
+                        .getUploadDownloadPathPattern()
+                        .matcher(path)
+                        .matches()) {
+            return AuditEventType.FILE_OPERATION;
+        } else {
+            return AuditEventType.PDF_PROCESS;
+        }
+    }
+
+    /**
+     * Get the current HTTP request if available
+     *
+     * @return The current request or null if not in a request context
+     */
+    public static HttpServletRequest getCurrentRequest() {
+        ServletRequestAttributes attrs =
+                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+        return attrs != null ? attrs.getRequest() : null;
+    }
+
+    /**
+     * Check if a GET request is for a static resource
+     *
+     * @param request The HTTP request
+     * @return true if this is a static resource request
+     */
+    public static boolean isStaticResourceRequest(HttpServletRequest request) {
+        return request != null
+                && !RequestUriUtils.isTrackableResource(
+                        request.getContextPath(), request.getRequestURI());
+    }
+}
@@ -9,7 +9,6 @@ import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.reflect.MethodSignature;
-import org.slf4j.MDC;
 import org.springframework.stereotype.Component;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -38,7 +37,7 @@ import stirling.software.proprietary.service.AuditService;
@Slf4j
@RequiredArgsConstructor
@org.springframework.core.annotation.Order(
-        0) // Highest precedence - runs BEFORE AutoJobAspect to populate MDC
+        10) // Lower precedence (higher number) - executes after AutoJobAspect
 public class ControllerAuditAspect {

    private final AuditService auditService;
@@ -93,7 +92,7 @@ public class ControllerAuditAspect {

        // Fast path: check if auditing is enabled before doing any work
        // This avoids all data collection if auditing is disabled
-        if (!auditService.shouldAudit(method, auditConfig)) {
+        if (!AuditUtils.shouldAudit(method, auditConfig)) {
            return joinPoint.proceed();
        }

@@ -111,14 +110,8 @@ public class ControllerAuditAspect {

        // Skip static GET resources
        if ("GET".equals(httpMethod)) {
-            HttpServletRequest maybe = auditService.getCurrentRequest();
-            if (maybe != null && auditService.isStaticResourceRequest(maybe)) {
-                return joinPoint.proceed();
-            }
-            // Skip polling calls at STANDARD level (exclude from audit log noise)
-            if (maybe != null
-                    && auditService.isPollingCall(maybe)
-                    && auditConfig.getAuditLevel() == AuditLevel.STANDARD) {
+            HttpServletRequest maybe = AuditUtils.getCurrentRequest();
+            if (maybe != null && AuditUtils.isStaticResourceRequest(maybe)) {
                return joinPoint.proceed();
            }
        }
@@ -128,143 +121,75 @@ public class ControllerAuditAspect {
        HttpServletRequest req = attrs != null ? attrs.getRequest() : null;
        HttpServletResponse resp = attrs != null ? attrs.getResponse() : null;

-        String previousPrincipal = MDC.get("auditPrincipal");
-        String previousOrigin = MDC.get("auditOrigin");
-        String previousIp = MDC.get("auditIp");
+        long start = System.currentTimeMillis();

-        // EARLY CAPTURE: Capture from SecurityContext on request thread, store in MDC for async
-        // propagation
-        // MDC.put is necessary for background threads to inherit audit context
-        String capturedPrincipal = previousPrincipal;
-        if (capturedPrincipal == null) {
-            capturedPrincipal = auditService.captureCurrentPrincipal();
-            MDC.put("auditPrincipal", capturedPrincipal);
+        // Use AuditUtils to create the base audit data
+        Map<String, Object> data = AuditUtils.createBaseAuditData(joinPoint, level);
+
+        // Add HTTP-specific information
+        AuditUtils.addHttpData(data, httpMethod, path, level);
+
+        // Add file information if present
+        AuditUtils.addFileData(data, joinPoint, level);
+
+        // Add method arguments if at VERBOSE level
+        if (level.includes(AuditLevel.VERBOSE)) {
+            AuditUtils.addMethodArguments(data, joinPoint, level);
        }

-        String capturedOrigin = previousOrigin;
-        if (capturedOrigin == null) {
-            capturedOrigin = auditService.captureCurrentOrigin();
-            MDC.put("auditOrigin", capturedOrigin);
-        }
-
-        String capturedIp = previousIp;
-        if (capturedIp == null && req != null) {
-            capturedIp = auditService.extractClientIp(req);
-            if (capturedIp != null) {
-                MDC.put("auditIp", capturedIp);
-            }
-        }
+        Object result = null;
        try {
-            // Avoid duplicate events for controller methods explicitly annotated with @Audited.
-            // @Audited methods are audited by AuditAspect.
-            if (auditedAnnotation != null) {
-                return joinPoint.proceed();
-            }
-
-            long start = System.currentTimeMillis();
-
-            // Use auditService to create the base audit data
-            Map<String, Object> data = auditService.createBaseAuditData(joinPoint, level);
-
-            // Add HTTP-specific information
-            auditService.addHttpData(data, httpMethod, path, level);
-
-            // Add file information if present
-            auditService.addFileData(data, joinPoint, level);
-
-            // Add method arguments if at VERBOSE level
-            if (level.includes(AuditLevel.VERBOSE)) {
-                auditService.addMethodArguments(data, joinPoint, level);
-            }
-
-            Object result = null;
-            try {
-                result = joinPoint.proceed();
-                data.put("outcome", "success");
-            } catch (Throwable ex) {
-                data.put("outcome", "failure");
-                data.put("errorType", ex.getClass().getSimpleName());
-                data.put("errorMessage", ex.getMessage());
-                throw ex;
-            } finally {
-                // Handle timing directly for HTTP requests
-                if (level.includes(AuditLevel.STANDARD)) {
-                    data.put("latencyMs", System.currentTimeMillis() - start);
-                    if (resp != null) data.put("statusCode", resp.getStatus());
-                }
-
-                // Call auditService but with isHttpRequest=true to skip additional timing
-                auditService.addTimingData(data, start, resp, level, true);
-
-                // Resolve the event type using the unified method
-                AuditEventType eventType =
-                        auditService.resolveEventType(
-                                method,
-                                joinPoint.getTarget().getClass(),
-                                path,
-                                httpMethod,
-                                auditedAnnotation);
-
-                // Add result only if operation result capture is explicitly enabled
-                // Skip result for UI_DATA events to avoid storing large response bodies
-                if (auditService.shouldCaptureOperationResults()
-                        && result != null
-                        && eventType != AuditEventType.UI_DATA) {
-                    // Use safe string conversion with size limiting
-                    data.put("result", auditService.safeToString(result, 1000));
-                }
-
-                // Check if we should use string type instead (for backward compatibility)
-                if (auditedAnnotation != null) {
-                    String typeString = auditedAnnotation.typeString();
-                    if (eventType == AuditEventType.HTTP_REQUEST
-                            && StringUtils.isNotEmpty(typeString)) {
-                        auditService.audit(
-                                capturedPrincipal,
-                                capturedOrigin,
-                                capturedIp,
-                                typeString,
-                                data,
-                                level);
-                    } else {
-                        // Use the enum type with early-captured values
-                        auditService.audit(
-                                capturedPrincipal,
-                                capturedOrigin,
-                                capturedIp,
-                                eventType,
-                                data,
-                                level);
-                    }
-                } else {
-                    // Use the enum type with early-captured values
-                    auditService.audit(
-                            capturedPrincipal, capturedOrigin, capturedIp, eventType, data, level);
-                }
-            }
-
-            return result;
+            result = joinPoint.proceed();
+            data.put("outcome", "success");
+        } catch (Throwable ex) {
+            data.put("outcome", "failure");
+            data.put("errorType", ex.getClass().getSimpleName());
+            data.put("errorMessage", ex.getMessage());
+            throw ex;
        } finally {
-            restoreMdcValue("auditPrincipal", previousPrincipal);
-            restoreMdcValue("auditOrigin", previousOrigin);
-            restoreMdcValue("auditIp", previousIp);
+            // Handle timing directly for HTTP requests
+            if (level.includes(AuditLevel.STANDARD)) {
+                data.put("latencyMs", System.currentTimeMillis() - start);
+                if (resp != null) data.put("statusCode", resp.getStatus());
+            }
+
+            // Call AuditUtils but with isHttpRequest=true to skip additional timing
+            AuditUtils.addTimingData(data, start, resp, level, true);
+
+            // Add result for VERBOSE level
+            if (level.includes(AuditLevel.VERBOSE) && result != null) {
+                // Use safe string conversion with size limiting
+                data.put("result", AuditUtils.safeToString(result, 1000));
+            }
+
+            // Resolve the event type using the unified method
+            AuditEventType eventType =
+                    AuditUtils.resolveEventType(
+                            method,
+                            joinPoint.getTarget().getClass(),
+                            path,
+                            httpMethod,
+                            auditedAnnotation);
+
+            // Check if we should use string type instead (for backward compatibility)
+            if (auditedAnnotation != null) {
+                String typeString = auditedAnnotation.typeString();
+                if (eventType == AuditEventType.HTTP_REQUEST
+                        && StringUtils.isNotEmpty(typeString)) {
+                    auditService.audit(typeString, data, level);
+                    return result;
+                }
+            }
+
+            // Use the enum type
+            auditService.audit(eventType, data, level);
        }
+        return result;
    }

    // Using AuditUtils.determineAuditEventType instead

    private String getRequestPath(Method method, String httpMethod) {
-        // Prefer actual request URI over annotation patterns (which may contain regex)
-        ServletRequestAttributes attrs =
-                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
-        if (attrs != null) {
-            HttpServletRequest request = attrs.getRequest();
-            if (request != null) {
-                return request.getRequestURI();
-            }
-        }
-
-        // Fallback: reconstruct from annotations when not in web context
        String base = "";
        RequestMapping cm = method.getDeclaringClass().getAnnotation(RequestMapping.class);
        if (cm != null && cm.value().length > 0) base = cm.value()[0];
@@ -286,13 +211,5 @@ public class ControllerAuditAspect {
        return base + mp;
    }

-    private void restoreMdcValue(String key, String previousValue) {
-        if (previousValue != null) {
-            MDC.put(key, previousValue);
-        } else {
-            MDC.remove(key);
-        }
-    }
-
    // Using AuditUtils.getCurrentRequest instead
 }
@@ -23,9 +23,6 @@ public class AuditConfigurationProperties {
    private final boolean enabled;
    private final int level;
    private final int retentionDays;
-    private final boolean captureFileHash;
-    private final boolean capturePdfAuthor;
-    private final boolean captureOperationResults;

    public AuditConfigurationProperties(ApplicationProperties applicationProperties) {
        ApplicationProperties.Premium.EnterpriseFeatures.Audit auditConfig =
@@ -40,19 +37,11 @@ public class AuditConfigurationProperties {
        // Retention days (0 means infinite)
        this.retentionDays = auditConfig.getRetentionDays();

-        // Metadata and detail capture flags
-        this.captureFileHash = auditConfig.isCaptureFileHash();
-        this.capturePdfAuthor = auditConfig.isCapturePdfAuthor();
-        this.captureOperationResults = auditConfig.isCaptureOperationResults();
-
        log.debug(
-                "Initialized audit configuration: enabled={}, level={}, retentionDays={} (0=infinite), fileHash={}, pdfAuthor={}, operationResults={}",
+                "Initialized audit configuration: enabled={}, level={}, retentionDays={} (0=infinite)",
                this.enabled,
                this.level,
-                this.retentionDays,
-                this.captureFileHash,
-                this.capturePdfAuthor,
-                this.captureOperationResults);
+                this.retentionDays);
    }

    /**
@@ -1,6 +1,5 @@
 package stirling.software.proprietary.controller.api;

-import java.nio.charset.StandardCharsets;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -19,7 +18,6 @@ import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestParam;

 import lombok.RequiredArgsConstructor;
@@ -46,13 +44,12 @@ public class AuditRestController {
    private final ObjectMapper objectMapper;

    /**
-     * Get audit events with pagination and filters. Maps to frontend's getEvents() call. Supports
-     * both single values and multi-select arrays for eventType and username.
+     * Get audit events with pagination and filters. Maps to frontend's getEvents() call.
     *
     * @param page Page number (0-indexed)
     * @param pageSize Number of items per page
-     * @param eventType Filter by event type(s) - can be single value or array
-     * @param username Filter by username(s) - can be single value or array
+     * @param eventType Filter by event type
+     * @param username Filter by username (principal)
     * @param startDate Filter start date
     * @param endDate Filter end date
     * @return Paginated audit events response
@@ -61,8 +58,8 @@ public class AuditRestController {
    public ResponseEntity<AuditEventsResponse> getAuditEvents(
            @RequestParam(value = "page", defaultValue = "0") int page,
            @RequestParam(value = "pageSize", defaultValue = "30") int pageSize,
-            @RequestParam(value = "eventType", required = false) String[] eventTypes,
-            @RequestParam(value = "username", required = false) String[] usernames,
+            @RequestParam(value = "eventType", required = false) String eventType,
+            @RequestParam(value = "username", required = false) String username,
            @RequestParam(value = "startDate", required = false)
                    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
                    LocalDate startDate,
@@ -73,45 +70,33 @@ public class AuditRestController {
        Pageable pageable = PageRequest.of(page, pageSize, Sort.by("timestamp").descending());
        Page<PersistentAuditEvent> events;

-        // Convert arrays to lists
-        List<String> eventTypeList =
-                (eventTypes != null && eventTypes.length > 0) ? Arrays.asList(eventTypes) : null;
-        List<String> usernameList =
-                (usernames != null && usernames.length > 0) ? Arrays.asList(usernames) : null;
-
-        Instant startInstant = null;
-        Instant endInstant = null;
-        if (startDate != null && endDate != null) {
-            startInstant = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
-            endInstant = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
-        }
-
        // Apply filters based on provided parameters
-        if (eventTypeList != null
-                && usernameList != null
-                && startInstant != null
-                && endInstant != null) {
+        if (eventType != null && username != null && startDate != null && endDate != null) {
+            Instant start = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
+            Instant end = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
            events =
-                    auditRepository.findByTypeInAndPrincipalInAndTimestampBetween(
-                            eventTypeList, usernameList, startInstant, endInstant, pageable);
-        } else if (eventTypeList != null && usernameList != null) {
+                    auditRepository.findByPrincipalAndTypeAndTimestampBetween(
+                            username, eventType, start, end, pageable);
+        } else if (eventType != null && username != null) {
+            events = auditRepository.findByPrincipalAndType(username, eventType, pageable);
+        } else if (eventType != null && startDate != null && endDate != null) {
+            Instant start = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
+            Instant end = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
+            events = auditRepository.findByTypeAndTimestampBetween(eventType, start, end, pageable);
+        } else if (username != null && startDate != null && endDate != null) {
+            Instant start = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
+            Instant end = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
            events =
-                    auditRepository.findByTypeInAndPrincipalIn(
-                            eventTypeList, usernameList, pageable);
-        } else if (eventTypeList != null && startInstant != null && endInstant != null) {
-            events =
-                    auditRepository.findByTypeInAndTimestampBetween(
-                            eventTypeList, startInstant, endInstant, pageable);
-        } else if (usernameList != null && startInstant != null && endInstant != null) {
-            events =
-                    auditRepository.findByPrincipalInAndTimestampBetween(
-                            usernameList, startInstant, endInstant, pageable);
-        } else if (startInstant != null && endInstant != null) {
-            events = auditRepository.findByTimestampBetween(startInstant, endInstant, pageable);
-        } else if (eventTypeList != null) {
-            events = auditRepository.findByTypeIn(eventTypeList, pageable);
-        } else if (usernameList != null) {
-            events = auditRepository.findByPrincipalIn(usernameList, pageable);
+                    auditRepository.findByPrincipalAndTimestampBetween(
+                            username, start, end, pageable);
+        } else if (startDate != null && endDate != null) {
+            Instant start = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
+            Instant end = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
+            events = auditRepository.findByTimestampBetween(start, end, pageable);
+        } else if (eventType != null) {
+            events = auditRepository.findByType(eventType, pageable);
+        } else if (username != null) {
+            events = auditRepository.findByPrincipal(username, pageable);
        } else {
            events = auditRepository.findAll(pageable);
        }
@@ -273,253 +258,11 @@ public class AuditRestController {
    }

    /**
-     * Get audit statistics for KPI dashboard. Includes success rates, latency metrics, and top
-     * items.
-     *
-     * @param period Time period for statistics (day/week/month)
-     * @return Audit statistics data for dashboard KPI cards and enhanced charts
-     */
-    @GetMapping("/audit-stats")
-    public ResponseEntity<AuditStatsData> getAuditStats(
-            @RequestParam(value = "period", defaultValue = "week") String period) {
-
-        // Calculate days based on period
-        int days;
-        switch (period.toLowerCase()) {
-            case "day":
-                days = 1;
-                break;
-            case "month":
-                days = 30;
-                break;
-            case "week":
-            default:
-                days = 7;
-                break;
-        }
-
-        // Get events from the specified period and previous period
-        Instant now = Instant.now();
-        Instant start = now.minus(java.time.Duration.ofDays(days));
-        Instant prevStart = start.minus(java.time.Duration.ofDays(days));
-
-        List<PersistentAuditEvent> currentEvents = auditRepository.findByTimestampAfter(start);
-        List<PersistentAuditEvent> prevEvents =
-                auditRepository.findAllByTimestampBetweenForExport(prevStart, start);
-
-        // Compute metrics for current period
-        AuditMetrics currentMetrics = computeMetrics(currentEvents);
-        AuditMetrics prevMetrics = computeMetrics(prevEvents);
-
-        // Get hourly distribution using DB aggregation
-        List<Object[]> hourlyData = auditRepository.histogramByHourBetween(start, now);
-        Map<String, Long> hourlyDistribution = new TreeMap<>();
-        for (int h = 0; h < 24; h++) {
-            hourlyDistribution.put(String.format("%02d", h), 0L);
-        }
-        for (Object[] row : hourlyData) {
-            int hour = ((Number) row[0]).intValue();
-            long count = ((Number) row[1]).longValue();
-            hourlyDistribution.put(String.format("%02d", hour), count);
-        }
-
-        return ResponseEntity.ok(
-                AuditStatsData.builder()
-                        .totalEvents(currentMetrics.totalEvents)
-                        .prevTotalEvents(prevMetrics.totalEvents)
-                        .uniqueUsers(currentMetrics.uniqueUsers)
-                        .prevUniqueUsers(prevMetrics.uniqueUsers)
-                        .successRate(currentMetrics.successRate)
-                        .prevSuccessRate(prevMetrics.successRate)
-                        .avgLatencyMs(currentMetrics.avgLatencyMs)
-                        .prevAvgLatencyMs(prevMetrics.avgLatencyMs)
-                        .errorCount(currentMetrics.errorCount)
-                        .topEventType(currentMetrics.topEventType)
-                        .topUser(currentMetrics.topUser)
-                        .eventsByType(currentMetrics.eventsByType)
-                        .eventsByUser(currentMetrics.eventsByUser)
-                        .topTools(currentMetrics.topTools)
-                        .hourlyDistribution(hourlyDistribution)
-                        .build());
-    }
-
-    /** Compute metrics from a list of audit events. */
-    private AuditMetrics computeMetrics(List<PersistentAuditEvent> events) {
-        if (events.isEmpty()) {
-            return AuditMetrics.builder().build();
-        }
-
-        // Count by type
-        Map<String, Long> eventsByType =
-                events.stream()
-                        .collect(
-                                Collectors.groupingBy(
-                                        PersistentAuditEvent::getType, Collectors.counting()));
-
-        // Count by principal (user)
-        Map<String, Long> eventsByUser =
-                events.stream()
-                        .collect(
-                                Collectors.groupingBy(
-                                        PersistentAuditEvent::getPrincipal, Collectors.counting()));
-
-        // Parse JSON data once for success rate, latency, tool extraction, and error counting
-        long successCount = 0;
-        long failureCount = 0;
-        long errorCount = 0;
-        long totalLatencyMs = 0;
-        long latencyCount = 0;
-        Map<String, Long> topTools = new HashMap<>();
-
-        for (PersistentAuditEvent event : events) {
-            if (event.getData() != null) {
-                try {
-                    @SuppressWarnings("unchecked")
-                    Map<String, Object> data = objectMapper.readValue(event.getData(), Map.class);
-
-                    // Track success/failure (safe type conversion)
-                    // Check both "status" (current) and "outcome" (legacy) for compatibility
-                    Object statusObj = data.get("status");
-                    if (statusObj == null) {
-                        statusObj = data.get("outcome");
-                    }
-                    String status = null;
-                    if (statusObj instanceof String) {
-                        status = (String) statusObj;
-                    } else if (statusObj != null) {
-                        status = String.valueOf(statusObj);
-                    }
-                    if ("success".equals(status)) {
-                        successCount++;
-                    } else if ("failure".equals(status)) {
-                        failureCount++;
-                        errorCount++;
-                    } else {
-                        // Check statusCode for error counting (when status is not explicit failure)
-                        Object statusCode = data.get("statusCode");
-                        if (statusCode != null) {
-                            try {
-                                int statusCodeVal;
-                                if (statusCode instanceof Number) {
-                                    statusCodeVal = ((Number) statusCode).intValue();
-                                } else if (statusCode instanceof String) {
-                                    statusCodeVal = Integer.parseInt((String) statusCode);
-                                } else {
-                                    statusCodeVal = 0;
-                                }
-                                if (statusCodeVal >= 400) {
-                                    errorCount++;
-                                }
-                            } catch (NumberFormatException e) {
-                                log.trace("Failed to parse statusCode value: {}", statusCode);
-                            }
-                        }
-                    }
-
-                    // Track latency (safe conversion to handle strings/numbers)
-                    Object latency = data.get("latencyMs");
-                    if (latency != null) {
-                        try {
-                            long latencyVal;
-                            if (latency instanceof Number) {
-                                latencyVal = ((Number) latency).longValue();
-                            } else if (latency instanceof String) {
-                                latencyVal = Long.parseLong((String) latency);
-                            } else {
-                                latencyVal = 0;
-                            }
-                            totalLatencyMs += latencyVal;
-                            latencyCount++;
-                        } catch (NumberFormatException e) {
-                            log.trace("Failed to parse latency value: {}", latency);
-                        }
-                    }
-
-                    // Extract tool from path (safe type conversion)
-                    Object pathObj = data.get("path");
-                    String path = null;
-                    if (pathObj instanceof String) {
-                        path = (String) pathObj;
-                    } else if (pathObj != null) {
-                        path = String.valueOf(pathObj);
-                    }
-                    if (path != null && !path.isEmpty()) {
-                        String[] parts = path.split("/");
-                        if (parts.length > 0) {
-                            String tool = parts[parts.length - 1];
-                            if (!tool.isEmpty()) {
-                                topTools.put(tool, topTools.getOrDefault(tool, 0L) + 1);
-                            }
-                        }
-                    }
-                } catch (JacksonException e) {
-                    log.trace("Failed to parse audit event data: {}", event.getData());
-                }
-            }
-        }
-
-        // Calculate success rate
-        double successRate = 0;
-        long totalWithOutcome = successCount + failureCount;
-        if (totalWithOutcome > 0) {
-            successRate = (successCount * 100.0) / totalWithOutcome;
-        }
-
-        // Calculate average latency
-        double avgLatencyMs = 0;
-        if (latencyCount > 0) {
-            avgLatencyMs = totalLatencyMs / (double) latencyCount;
-        }
-
-        // Get top event type
-        String topEventType =
-                eventsByType.entrySet().stream()
-                        .max((e1, e2) -> Long.compare(e1.getValue(), e2.getValue()))
-                        .map(Map.Entry::getKey)
-                        .orElse("");
-
-        // Get top user
-        String topUser =
-                eventsByUser.entrySet().stream()
-                        .max((e1, e2) -> Long.compare(e1.getValue(), e2.getValue()))
-                        .map(Map.Entry::getKey)
-                        .orElse("");
-
-        // Sort and limit top tools to 10
-        Map<String, Long> topToolsSorted =
-                topTools.entrySet().stream()
-                        .sorted((e1, e2) -> Long.compare(e2.getValue(), e1.getValue()))
-                        .limit(10)
-                        .collect(
-                                Collectors.toMap(
-                                        Map.Entry::getKey,
-                                        Map.Entry::getValue,
-                                        (e1, e2) -> e1,
-                                        LinkedHashMap::new));
-
-        return AuditMetrics.builder()
-                .totalEvents(events.size())
-                .uniqueUsers((int) eventsByUser.size())
-                .successRate(successRate)
-                .avgLatencyMs(avgLatencyMs)
-                .errorCount(errorCount)
-                .topEventType(topEventType)
-                .topUser(topUser)
-                .eventsByType(eventsByType)
-                .eventsByUser(eventsByUser)
-                .topTools(topToolsSorted)
-                .build();
-    }
-
-    /**
-     * Export audit data in CSV or JSON format. Maps to frontend's exportData() call. Supports both
-     * single values and multi-select arrays for eventType and username.
+     * Export audit data in CSV or JSON format. Maps to frontend's exportData() call.
     *
     * @param format Export format (csv or json)
-     * @param fields Comma-separated list of fields to include (e.g.,
-     *     "date,username,tool,documentName,author,fileHash")
-     * @param eventTypes Filter by event type(s) - can be single value or array
-     * @param usernames Filter by username(s) - can be single value or array
+     * @param eventType Filter by event type
+     * @param username Filter by username
     * @param startDate Filter start date
     * @param endDate Filter end date
     * @return File download response
@@ -527,9 +270,8 @@ public class AuditRestController {
    @GetMapping("/audit-export")
    public ResponseEntity<byte[]> exportAuditData(
            @RequestParam(value = "format", defaultValue = "csv") String format,
-            @RequestParam(value = "fields", required = false) String fields,
-            @RequestParam(value = "eventType", required = false) String[] eventTypes,
-            @RequestParam(value = "username", required = false) String[] usernames,
+            @RequestParam(value = "eventType", required = false) String eventType,
+            @RequestParam(value = "username", required = false) String username,
            @RequestParam(value = "startDate", required = false)
                    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
                    LocalDate startDate,
@@ -540,44 +282,34 @@ public class AuditRestController {
        // Get data with same filtering as getAuditEvents
        List<PersistentAuditEvent> events;

-        // Convert arrays to lists
-        List<String> eventTypeList =
-                (eventTypes != null && eventTypes.length > 0) ? Arrays.asList(eventTypes) : null;
-        List<String> usernameList =
-                (usernames != null && usernames.length > 0) ? Arrays.asList(usernames) : null;
-
-        Instant startInstant = null;
-        Instant endInstant = null;
-        if (startDate != null && endDate != null) {
-            startInstant = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
-            endInstant = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
-        }
-
-        if (eventTypeList != null
-                && usernameList != null
-                && startInstant != null
-                && endInstant != null) {
+        if (eventType != null && username != null && startDate != null && endDate != null) {
+            Instant start = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
+            Instant end = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
            events =
-                    auditRepository.findByTypeInAndPrincipalInAndTimestampBetweenForExport(
-                            eventTypeList, usernameList, startInstant, endInstant);
-        } else if (eventTypeList != null && usernameList != null) {
+                    auditRepository.findAllByPrincipalAndTypeAndTimestampBetweenForExport(
+                            username, eventType, start, end);
+        } else if (eventType != null && username != null) {
+            events = auditRepository.findAllByPrincipalAndTypeForExport(username, eventType);
+        } else if (eventType != null && startDate != null && endDate != null) {
+            Instant start = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
+            Instant end = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
            events =
-                    auditRepository.findByTypeInAndPrincipalInForExport(
-                            eventTypeList, usernameList);
-        } else if (eventTypeList != null && startInstant != null && endInstant != null) {
+                    auditRepository.findAllByTypeAndTimestampBetweenForExport(
+                            eventType, start, end);
+        } else if (username != null && startDate != null && endDate != null) {
+            Instant start = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
+            Instant end = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
            events =
-                    auditRepository.findByTypeInAndTimestampBetweenForExport(
-                            eventTypeList, startInstant, endInstant);
-        } else if (usernameList != null && startInstant != null && endInstant != null) {
-            events =
-                    auditRepository.findByPrincipalInAndTimestampBetweenForExport(
-                            usernameList, startInstant, endInstant);
-        } else if (startInstant != null && endInstant != null) {
-            events = auditRepository.findAllByTimestampBetweenForExport(startInstant, endInstant);
-        } else if (eventTypeList != null) {
-            events = auditRepository.findByTypeInForExport(eventTypeList);
-        } else if (usernameList != null) {
-            events = auditRepository.findByPrincipalInForExport(usernameList);
+                    auditRepository.findAllByPrincipalAndTimestampBetweenForExport(
+                            username, start, end);
+        } else if (startDate != null && endDate != null) {
+            Instant start = startDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
+            Instant end = endDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant();
+            events = auditRepository.findAllByTimestampBetweenForExport(start, end);
+        } else if (eventType != null) {
+            events = auditRepository.findByTypeForExport(eventType);
+        } else if (username != null) {
+            events = auditRepository.findAllByPrincipalForExport(username);
        } else {
            events = auditRepository.findAll();
        }
@@ -586,7 +318,7 @@ public class AuditRestController {
        if ("json".equalsIgnoreCase(format)) {
            return exportAsJson(events);
        } else {
-            return exportAsCsv(events, fields);
+            return exportAsCsv(events);
        }
    }

@@ -606,89 +338,17 @@ public class AuditRestController {
            }
        }

-        // Extract IP address (check both clientIp and __ipAddress for async/audited events)
-        String ipAddress = "";
-        Object ipObj = details.get("clientIp");
-        if (ipObj != null) {
-            ipAddress = String.valueOf(ipObj);
-        } else {
-            ipObj = details.get("__ipAddress");
-            if (ipObj != null) {
-                ipAddress = String.valueOf(ipObj);
-            }
-        }
-
        return AuditEventDto.builder()
                .id(String.valueOf(event.getId()))
                .timestamp(event.getTimestamp().toString())
                .eventType(event.getType())
                .username(event.getPrincipal())
-                .ipAddress(ipAddress)
+                .ipAddress((String) details.getOrDefault("ipAddress", "")) // Extract if available
                .details(details)
                .build();
    }

-    private ResponseEntity<byte[]> exportAsCsv(List<PersistentAuditEvent> events, String fields) {
-        // Parse selected fields (comma-separated:
-        // date,username,tool,documentName,author,fileHash,ipAddress,etc)
-        Set<String> selectedFields = new HashSet<>();
-        if (fields != null && !fields.trim().isEmpty()) {
-            String[] fieldArray = fields.split(",");
-            for (String field : fieldArray) {
-                selectedFields.add(field.trim().toLowerCase());
-            }
-        }
-
-        // If no fields specified, use default technical export
-        if (selectedFields.isEmpty()) {
-            return exportAsDefaultCsv(events);
-        }
-
-        StringBuilder csv = new StringBuilder();
-
-        // Build header based on selected fields
-        List<String> headerOrder = new ArrayList<>();
-        if (selectedFields.contains("date")) headerOrder.add("date");
-        if (selectedFields.contains("username")) headerOrder.add("username");
-        if (selectedFields.contains("ipaddress")) headerOrder.add("ipaddress");
-        if (selectedFields.contains("tool")) headerOrder.add("tool");
-        if (selectedFields.contains("documentname")) headerOrder.add("documentname");
-        if (selectedFields.contains("outcome")) headerOrder.add("outcome");
-        if (selectedFields.contains("author")) headerOrder.add("author");
-        if (selectedFields.contains("filehash")) headerOrder.add("filehash");
-        if (selectedFields.contains("operationresults")) headerOrder.add("operationresults");
-        if (selectedFields.contains("eventtype")) headerOrder.add("eventtype");
-
-        // Write header
-        for (int i = 0; i < headerOrder.size(); i++) {
-            csv.append(capitalizeHeader(headerOrder.get(i)));
-            if (i < headerOrder.size() - 1) csv.append(",");
-        }
-        csv.append("\n");
-
-        DateTimeFormatter formatter = DateTimeFormatter.ISO_INSTANT;
-
-        // Write data rows
-        for (PersistentAuditEvent event : events) {
-            Map<String, String> rowData = extractEventData(event, formatter);
-
-            for (int i = 0; i < headerOrder.size(); i++) {
-                csv.append(escapeCSV(rowData.getOrDefault(headerOrder.get(i), "")));
-                if (i < headerOrder.size() - 1) csv.append(",");
-            }
-            csv.append("\n");
-        }
-
-        byte[] csvBytes = csv.toString().getBytes(StandardCharsets.UTF_8);
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.parseMediaType("text/csv;charset=UTF-8"));
-        headers.setContentDispositionFormData(
-                "attachment", "audit_export_" + System.currentTimeMillis() + ".csv");
-
-        return ResponseEntity.ok().headers(headers).body(csvBytes);
-    }
-
-    private ResponseEntity<byte[]> exportAsDefaultCsv(List<PersistentAuditEvent> events) {
+    private ResponseEntity<byte[]> exportAsCsv(List<PersistentAuditEvent> events) {
        StringBuilder csv = new StringBuilder();
        csv.append("ID,Principal,Type,Timestamp,Data\n");

@@ -702,102 +362,15 @@ public class AuditRestController {
            csv.append(escapeCSV(event.getData())).append("\n");
        }

-        byte[] csvBytes = csv.toString().getBytes(StandardCharsets.UTF_8);
+        byte[] csvBytes = csv.toString().getBytes();
+
        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.parseMediaType("text/csv;charset=UTF-8"));
+        headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
        headers.setContentDispositionFormData("attachment", "audit_export.csv");

        return ResponseEntity.ok().headers(headers).body(csvBytes);
    }

-    private Map<String, String> extractEventData(
-            PersistentAuditEvent event, DateTimeFormatter formatter) {
-        Map<String, String> data = new HashMap<>();
-
-        data.put("date", formatter.format(event.getTimestamp()));
-        data.put("username", event.getPrincipal());
-        data.put("eventtype", event.getType());
-        data.put("ipaddress", "");
-        data.put("tool", "");
-        data.put("documentname", "");
-        data.put("outcome", "");
-        data.put("author", "");
-        data.put("filehash", "");
-        data.put("operationresults", "");
-
-        if (event.getData() != null) {
-            try {
-                @SuppressWarnings("unchecked")
-                Map<String, Object> eventData = objectMapper.readValue(event.getData(), Map.class);
-
-                // Extract IP address (check both clientIp and __ipAddress)
-                String ipAddress = "";
-                if (eventData.containsKey("clientIp")) {
-                    ipAddress = String.valueOf(eventData.getOrDefault("clientIp", ""));
-                } else if (eventData.containsKey("__ipAddress")) {
-                    ipAddress = String.valueOf(eventData.getOrDefault("__ipAddress", ""));
-                }
-                if (!ipAddress.isEmpty()) {
-                    data.put("ipaddress", ipAddress);
-                }
-
-                // Extract outcome (success/failure), supporting legacy "status" key
-                if (eventData.containsKey("outcome")) {
-                    data.put("outcome", String.valueOf(eventData.getOrDefault("outcome", "")));
-                } else if (eventData.containsKey("status")) {
-                    data.put("outcome", String.valueOf(eventData.getOrDefault("status", "")));
-                }
-
-                // Extract operation result if present
-                if (eventData.containsKey("result")) {
-                    data.put(
-                            "operationresults",
-                            String.valueOf(eventData.getOrDefault("result", "")));
-                }
-
-                // Extract tool from path
-                if (eventData.containsKey("path")) {
-                    String path = (String) eventData.get("path");
-                    if (path != null) {
-                        String[] parts = path.split("/");
-                        data.put("tool", parts.length > 0 ? parts[parts.length - 1] : "");
-                    }
-                }
-
-                // Extract file information
-                @SuppressWarnings("unchecked")
-                List<Map<String, Object>> files =
-                        (List<Map<String, Object>>) eventData.get("files");
-                if (files != null && !files.isEmpty()) {
-                    Map<String, Object> firstFile = files.get(0);
-                    data.put("documentname", String.valueOf(firstFile.getOrDefault("name", "")));
-                    data.put("author", String.valueOf(firstFile.getOrDefault("pdfAuthor", "")));
-                    data.put("filehash", String.valueOf(firstFile.getOrDefault("fileHash", "")));
-                }
-            } catch (Exception e) {
-                log.trace("Failed to parse audit event data: {}", event.getData());
-            }
-        }
-
-        return data;
-    }
-
-    private String capitalizeHeader(String field) {
-        return switch (field.toLowerCase()) {
-            case "date" -> "Date";
-            case "username" -> "Username";
-            case "ipaddress" -> "IP Address";
-            case "tool" -> "Tool";
-            case "documentname" -> "Document Name";
-            case "outcome" -> "Outcome";
-            case "author" -> "Author";
-            case "filehash" -> "File Hash";
-            case "operationresults" -> "Operation Results";
-            case "eventtype" -> "Event Type";
-            default -> field;
-        };
-    }
-
    private ResponseEntity<byte[]> exportAsJson(List<PersistentAuditEvent> events) {
        try {
            byte[] jsonBytes = objectMapper.writeValueAsBytes(events);
@@ -858,60 +431,4 @@ public class AuditRestController {
        private List<String> labels;
        private List<Integer> values;
    }
-
-    @lombok.Data
-    @lombok.Builder
-    public static class AuditStatsData {
-        private long totalEvents;
-        private long prevTotalEvents;
-        private int uniqueUsers;
-        private int prevUniqueUsers;
-        private double successRate;
-        private double prevSuccessRate;
-        private double avgLatencyMs;
-        private double prevAvgLatencyMs;
-        private long errorCount;
-        private String topEventType;
-        private String topUser;
-        private Map<String, Long> eventsByType;
-        private Map<String, Long> eventsByUser;
-        private Map<String, Long> topTools;
-        private Map<String, Long> hourlyDistribution;
-    }
-
-    @lombok.Data
-    @lombok.Builder
-    public static class AuditMetrics {
-        private long totalEvents;
-        private int uniqueUsers;
-        private double successRate;
-        private double avgLatencyMs;
-        private long errorCount;
-        private String topEventType;
-        private String topUser;
-        private Map<String, Long> eventsByType;
-        private Map<String, Long> eventsByUser;
-        private Map<String, Long> topTools;
-    }
-
-    /**
-     * Clear all audit data from the database. This is an irreversible operation. Requires ADMIN
-     * role.
-     *
-     * @return Success response
-     */
-    @PostMapping("/audit-clear-all")
-    public ResponseEntity<?> clearAllAuditData() {
-        try {
-            // Delete all audit events
-            auditRepository.deleteAll();
-            log.warn("All audit data has been cleared by admin user");
-            return ResponseEntity.ok()
-                    .body(Map.of("message", "All audit data has been cleared successfully"));
-        } catch (Exception e) {
-            log.error("Error clearing audit data", e);
-            return ResponseEntity.internalServerError()
-                    .body("Failed to clear audit data: " + e.getMessage());
-        }
-    }
 }
@@ -43,7 +43,6 @@ import stirling.software.proprietary.security.database.repository.UserRepository
 import stirling.software.proprietary.security.model.Authority;
 import stirling.software.proprietary.security.model.SessionEntity;
 import stirling.software.proprietary.security.model.User;
-import stirling.software.proprietary.security.model.dto.AdminUserSummary;
 import stirling.software.proprietary.security.repository.TeamRepository;
 import stirling.software.proprietary.security.saml2.CustomSaml2AuthenticatedPrincipal;
 import stirling.software.proprietary.security.service.DatabaseService;
@@ -127,13 +126,6 @@ public class ProprietaryUIDataController {
        data.setRetentionDays(auditConfig.getRetentionDays());
        data.setAuditLevels(AuditLevel.values());
        data.setAuditEventTypes(AuditEventType.values());
-        // Metadata capture settings (independent flags)
-        data.setCaptureFileHash(auditConfig.isCaptureFileHash());
-        data.setCapturePdfAuthor(auditConfig.isCapturePdfAuthor());
-        data.setCaptureOperationResults(auditConfig.isCaptureOperationResults());
-        // pdfMetadataEnabled: true if any metadata flag is enabled (file hash or PDF author)
-        data.setPdfMetadataEnabled(
-                auditConfig.isCaptureFileHash() || auditConfig.isCapturePdfAuthor());

        return ResponseEntity.ok(data);
    }
@@ -365,12 +357,8 @@ public class ProprietaryUIDataController {
        int licenseMaxUsers = licenseSettingsService.getSettings().getLicenseMaxUsers();
        boolean premiumEnabled = applicationProperties.getPremium().isEnabled();

-        // Convert User entities to AdminUserSummary DTOs to exclude sensitive fields
-        List<AdminUserSummary> userSummaries =
-                sortedUsers.stream().map(this::convertUserToSummary).toList();
-
        AdminSettingsData data = new AdminSettingsData();
-        data.setUsers(userSummaries);
+        data.setUsers(sortedUsers);
        data.setCurrentUsername(authentication.getName());
        data.setRoleDetails(roleDetails);
        data.setUserSessions(userSessions);
@@ -530,34 +518,6 @@ public class ProprietaryUIDataController {
        return ResponseEntity.ok(data);
    }

-    /**
-     * Convert User entity to AdminUserSummary DTO, excluding sensitive fields like password and
-     * apiKey.
-     */
-    private AdminUserSummary convertUserToSummary(User user) {
-        AdminUserSummary summary = new AdminUserSummary();
-        summary.setId(user.getId());
-        summary.setUsername(user.getUsername());
-        summary.setEmail(user.getUsername()); // Use username as email for consistency
-        summary.setRoleName(user.getRoleName());
-        summary.setRolesAsString(user.getRolesAsString());
-        summary.setEnabled(user.isEnabled());
-        summary.setIsFirstLogin(user.isFirstLogin());
-        summary.setAuthenticationType(user.getAuthenticationType());
-        summary.setCreatedAt(user.getCreatedAt());
-        summary.setUpdatedAt(user.getUpdatedAt());
-
-        // Map team if present
-        if (user.getTeam() != null) {
-            AdminUserSummary.TeamSummary teamSummary = new AdminUserSummary.TeamSummary();
-            teamSummary.setId(user.getTeam().getId());
-            teamSummary.setName(user.getTeam().getName());
-            summary.setTeam(teamSummary);
-        }
-
-        return summary;
-    }
-
    // Data classes
    @Data
    public static class AuditDashboardData {
@@ -567,10 +527,6 @@ public class ProprietaryUIDataController {
        private int retentionDays;
        private AuditLevel[] auditLevels;
        private AuditEventType[] auditEventTypes;
-        private boolean pdfMetadataEnabled;
-        private boolean captureFileHash;
-        private boolean capturePdfAuthor;
-        private boolean captureOperationResults;
    }

    @Data
@@ -588,7 +544,7 @@ public class ProprietaryUIDataController {

    @Data
    public static class AdminSettingsData {
-        private List<AdminUserSummary> users;
+        private List<User> users;
        private String currentUsername;
        private Map<String, String> roleDetails;
        private Map<String, Boolean> userSessions;
@@ -1,7 +1,5 @@
 package stirling.software.proprietary.controller.api;

-import java.time.Duration;
-import java.time.Instant;
 import java.util.*;
 import java.util.stream.Collectors;

@@ -34,32 +32,34 @@ public class UsageRestController {
    private final ObjectMapper objectMapper;

    /**
-     * Get endpoint statistics derived from audit events. This endpoint analyzes audit events
-     * filtered by type to generate usage statistics.
+     * Get endpoint statistics derived from audit events. This endpoint analyzes HTTP_REQUEST audit
+     * events to generate usage statistics.
     *
     * @param limit Optional limit on number of endpoints to return
-     * @param dataType Type of data to include: "all" (default), "api" (operational endpoints), or
-     *     "ui" (UI data endpoints)
-     * @param days Lookback window in days (default 30, clamped to 1-365)
+     * @param dataType Type of data to include: "all" (default), "api" (API endpoints excluding
+     *     auth), or "ui" (non-API endpoints)
     * @return Endpoint statistics response
     */
    @GetMapping("/usage-endpoint-statistics")
    public ResponseEntity<EndpointStatisticsResponse> getEndpointStatistics(
            @RequestParam(value = "limit", required = false) Integer limit,
-            @RequestParam(value = "dataType", defaultValue = "all") String dataType,
-            @RequestParam(value = "days", defaultValue = "30") Integer days) {
+            @RequestParam(value = "dataType", defaultValue = "all") String dataType) {

-        int lookbackDays = Math.max(1, Math.min(days, 365));
-
-        // Get audit events filtered by type
-        List<PersistentAuditEvent> events = getEventsByDataType(dataType, lookbackDays);
+        // Get all HTTP_REQUEST audit events
+        List<PersistentAuditEvent> httpEvents =
+                auditRepository.findByTypeForExport(AuditEventType.HTTP_REQUEST.name());

        // Count visits per endpoint
        Map<String, Long> endpointCounts = new HashMap<>();

-        for (PersistentAuditEvent event : events) {
+        for (PersistentAuditEvent event : httpEvents) {
            String endpoint = extractEndpointFromAuditData(event.getData());
            if (endpoint != null) {
+                // Apply data type filter
+                if (!shouldIncludeEndpoint(endpoint, dataType)) {
+                    continue;
+                }
+
                endpointCounts.merge(endpoint, 1L, Long::sum);
            }
        }
@@ -168,28 +168,52 @@ public class UsageRestController {
    }

    /**
-     * Get audit events filtered by data type. UI = UI_DATA events. API = everything except UI_DATA.
+     * Determine if an endpoint should be included based on the data type filter.
     *
-     * @param dataType "all", "api" (not UI_DATA), or "ui" (UI_DATA only)
-     * @param days lookback window in days
-     * @return List of audit events matching the data type filter
+     * @param endpoint The endpoint path to check
+     * @param dataType The filter type: "all", "api", or "ui"
+     * @return true if the endpoint should be included, false otherwise
     */
-    private List<PersistentAuditEvent> getEventsByDataType(String dataType, int days) {
-        Instant start = Instant.now().minus(Duration.ofDays(days));
-
+    private boolean shouldIncludeEndpoint(String endpoint, String dataType) {
        if ("all".equalsIgnoreCase(dataType)) {
-            return auditRepository.findByTimestampAfter(start);
-        } else if ("ui".equalsIgnoreCase(dataType)) {
-            // UI data endpoints only
-            return auditRepository.findByTypeAndTimestampAfterForExport(
-                    AuditEventType.UI_DATA.name(), start);
-        } else if ("api".equalsIgnoreCase(dataType)) {
-            // API = everything except UI_DATA (queried at DB level, not filtered in-memory)
-            return auditRepository.findAllExceptTypeAndTimestampAfterForExport(
-                    AuditEventType.UI_DATA.name(), start);
+            return true;
        }

-        return new ArrayList<>();
+        boolean isApiEndpoint = isApiEndpoint(endpoint);
+
+        if ("api".equalsIgnoreCase(dataType)) {
+            return isApiEndpoint;
+        } else if ("ui".equalsIgnoreCase(dataType)) {
+            return !isApiEndpoint;
+        }
+
+        // Default to including all if unrecognized type
+        return true;
+    }
+
+    /**
+     * Check if an endpoint is an API endpoint. API endpoints match /api/v1/* pattern but exclude
+     * /api/v1/auth/* paths.
+     *
+     * @param endpoint The endpoint path to check
+     * @return true if this is an API endpoint (excluding auth endpoints), false otherwise
+     */
+    private boolean isApiEndpoint(String endpoint) {
+        if (endpoint == null) {
+            return false;
+        }
+
+        // Check if it starts with /api/v1/
+        if (!endpoint.startsWith("/api/v1/")) {
+            return false;
+        }
+
+        // Exclude auth endpoints
+        if (endpoint.startsWith("/api/v1/auth/")) {
+            return false;
+        }
+
+        return true;
    }

    // DTOs for response formatting
--- a/Show More
+++ b/Show More