audit: jpdfium split

# Conflicts:
#	app/common/build.gradle

.github/workflows/backend-build.yml

@@ -1,7 +1,7 @@
 name: Backend build, format check, and coverage
 
-# Reusable workflow called from build.yml. Runs the full backend build matrix
-# (JDK 21/25 × spring-security on/off), Spotless formatting check, JUnit, and
+# Reusable workflow called from build.yml. Runs the backend build matrix
+# (JDK 25 × spring-security on/off), Spotless formatting check, JUnit, and
 # posts Jacoco coverage to PRs.
 on:
   workflow_call:
@@ -18,7 +18,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        jdk-version: [21, 25]
+        jdk-version: [25]
         spring-security: [true, false]
     steps:
       - name: Harden Runner

.github/workflows/dependency-review.yml

@@ -21,6 +21,6 @@ jobs:
       - name: "Checkout Repository"
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: "Dependency Review"
-        uses: actions/dependency-review-action@2031cfc080254a8a887f58cffee85186f0e49e48 # v4.9.0
+        uses: actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0
         with:
           config-file: "./.github/config/dependency-review-config.yml"

.github/workflows/multiOSReleases.yml

@@ -90,21 +90,21 @@ jobs:
           if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
             case "${{ github.event.inputs.platform }}" in
               "windows")
-                echo 'matrix={"include":[{"platform":"windows-latest","args":"--target x86_64-pc-windows-msvc","name":"windows-x86_64"}]}' >> $GITHUB_OUTPUT
+                echo 'matrix={"include":[{"platform":"windows-latest","args":"--target x86_64-pc-windows-msvc","name":"windows-x86_64","jpdfium_platforms":"windows-x64"}]}' >> $GITHUB_OUTPUT
                 ;;
               "macos")
-                echo 'matrix={"include":[{"platform":"macos-15","args":"--target universal-apple-darwin","name":"macos-universal"}]}' >> $GITHUB_OUTPUT
+                echo 'matrix={"include":[{"platform":"macos-15","args":"--target universal-apple-darwin","name":"macos-universal","jpdfium_platforms":"darwin-arm64,darwin-x64"}]}' >> $GITHUB_OUTPUT
                 ;;
               "linux")
-                echo 'matrix={"include":[{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64"}]}' >> $GITHUB_OUTPUT
+                echo 'matrix={"include":[{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64","jpdfium_platforms":"linux-x64"}]}' >> $GITHUB_OUTPUT
                 ;;
               *)
-                echo 'matrix={"include":[{"platform":"windows-latest","args":"--target x86_64-pc-windows-msvc","name":"windows-x86_64"},{"platform":"macos-15","args":"--target universal-apple-darwin","name":"macos-universal"},{"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","jpdfium_platforms":"windows-x64"},{"platform":"macos-15","args":"--target universal-apple-darwin","name":"macos-universal","jpdfium_platforms":"darwin-arm64,darwin-x64"},{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64","jpdfium_platforms":"linux-x64"}]}' >> $GITHUB_OUTPUT
                 ;;
             esac
           else
             # For push/release 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 universal-apple-darwin","name":"macos-universal"},{"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","jpdfium_platforms":"windows-x64"},{"platform":"macos-15","args":"--target universal-apple-darwin","name":"macos-universal","jpdfium_platforms":"darwin-arm64,darwin-x64"},{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64","jpdfium_platforms":"linux-x64"}]}' >> $GITHUB_OUTPUT
           fi
 
   build-jars:
@@ -256,15 +256,17 @@ jobs:
         if: matrix.platform == 'macos-15'
         env:
           AARCH64_JAVA_HOME: ${{ env.JAVA_HOME }}
+          JPDFIUM_PLATFORMS: ${{ matrix.jpdfium_platforms }}
         run: task desktop:jlink:universal-mac
 
       - name: Prepare desktop build
-        run: task desktop:prepare
         env:
           MAVEN_USER: ${{ secrets.MAVEN_USER }}
           MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
           MAVEN_PUBLIC_URL: ${{ secrets.MAVEN_PUBLIC_URL }}
           DISABLE_ADDITIONAL_FEATURES: true
+          JPDFIUM_PLATFORMS: ${{ matrix.jpdfium_platforms }}
+        run: task desktop:prepare
 
       # DigiCert KeyLocker Setup (Cloud HSM)
       - name: Setup DigiCert KeyLocker
@@ -638,7 +640,7 @@ jobs:
         run: ls -R ./artifacts
 
       - name: Upload binaries to Release
-        uses: softprops/action-gh-release@153bb8e04406b158c6c84fc1615b65b24149a1fe # v2.6.1
+        uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
         with:
           tag_name: v${{ needs.determine-matrix.outputs.version }}
           generate_release_notes: true

.github/workflows/push-docker-base.yml

@@ -100,7 +100,7 @@ jobs:
           sbom: true
 
       - name: Install cosign
-        uses: sigstore/cosign-installer@cad07c2e89fa2edd6e2d7bab4c1aa38e53f76003 # v4.1.1
+        uses: sigstore/cosign-installer@6f9f17788090df1f26f669e9d70d6ae9567deba6 # v4.1.2
         with:
           cosign-release: "v2.4.1"
 

.github/workflows/push-docker.yml

@@ -96,13 +96,13 @@ jobs:
 
       - name: Install cosign
         if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/V2-master'
-        uses: sigstore/cosign-installer@cad07c2e89fa2edd6e2d7bab4c1aa38e53f76003 # v4.1.1
+        uses: sigstore/cosign-installer@6f9f17788090df1f26f669e9d70d6ae9567deba6 # v4.1.2
         with:
           cosign-release: "v2.4.1"
 
       - name: Install cosign
         if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/V2-master'
-        uses: sigstore/cosign-installer@cad07c2e89fa2edd6e2d7bab4c1aa38e53f76003 # v4.1.1
+        uses: sigstore/cosign-installer@6f9f17788090df1f26f669e9d70d6ae9567deba6 # v4.1.2
         with:
           cosign-release: "v2.4.1"
 

.github/workflows/scorecards.yml

@@ -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@e46ed2cbd01164d986452f91f178727624ae40d7 # v3.29.5
+        uses: github/codeql-action/upload-sarif@68bde559dea0fdcac2102bfdf6230c5f70eb485e # v3.29.5
         with:
           sarif_file: results.sarif

.github/workflows/tauri-build.yml

@@ -47,12 +47,10 @@ jobs:
           APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
           PLATFORM: ${{ inputs.platform }}
         run: |
-          WINDOWS='{"platform":"windows-latest","args":"--target x86_64-pc-windows-msvc","name":"windows-x86_64"}'
-          MACOS='{"platform":"macos-15","args":"--target universal-apple-darwin","name":"macos-universal"}'
-          LINUX='{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64"}'
+          WINDOWS='{"platform":"windows-latest","args":"--target x86_64-pc-windows-msvc","name":"windows-x86_64","jpdfium_platforms":"windows-x64"}'
+          MACOS='{"platform":"macos-15","args":"--target universal-apple-darwin","name":"macos-universal","jpdfium_platforms":"darwin-arm64,darwin-x64"}'
+          LINUX='{"platform":"ubuntu-22.04","args":"","name":"linux-x86_64","jpdfium_platforms":"linux-x64"}'
 
-          # Resolve requested platform — populated by either workflow_dispatch
-          # or workflow_call inputs; both paths default to "all".
           case "$PLATFORM" in
             windows) ENTRIES=("$WINDOWS") ;;
             macos)   ENTRIES=("$MACOS") ;;
@@ -112,10 +110,6 @@ jobs:
           toolchain: stable
           targets: ${{ matrix.platform == 'macos-15' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}
 
-      # x86_64 JDK is set up first so the aarch64 step below can leave its
-      # JAVA_HOME as the active one. The macOS universal JRE build needs
-      # jmods from both arches; the x64 path is captured into the env
-      # before the second setup-java overwrites JAVA_HOME.
       - name: Set up x86_64 JDK 25 (macOS universal JRE)
         if: matrix.platform == 'macos-15'
         uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
@@ -142,21 +136,21 @@ jobs:
       - name: Setup Task
         uses: go-task/setup-task@3be4020d41929789a01026e0e427a4321ce0ad44 # v2.0.0
 
-      # Build the universal JRE before desktop:prepare so the jlink:runtime
-      # task short-circuits on its `test -d runtime/jre` status check.
       - name: Build universal macOS JRE
         if: matrix.platform == 'macos-15'
         env:
           AARCH64_JAVA_HOME: ${{ env.JAVA_HOME }}
+          JPDFIUM_PLATFORMS: ${{ matrix.jpdfium_platforms }}
         run: task desktop:jlink:universal-mac
 
       - name: Prepare desktop build
-        run: task desktop:prepare
         env:
           MAVEN_USER: ${{ secrets.MAVEN_USER }}
           MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
           MAVEN_PUBLIC_URL: ${{ secrets.MAVEN_PUBLIC_URL }}
           DISABLE_ADDITIONAL_FEATURES: true
+          JPDFIUM_PLATFORMS: ${{ matrix.jpdfium_platforms }}
+        run: task desktop:prepare
 
       # DigiCert KeyLocker Setup (Cloud HSM)
       - name: Setup DigiCert KeyLocker
@@ -269,6 +263,10 @@ jobs:
           echo "APPLE_SIGNING_IDENTITY=$CERT_ID" >> $GITHUB_ENV
           echo "Certificate imported successfully."
 
+      - name: Sign JPDFium dylibs inside bootJar (macOS only)
+        if: matrix.platform == 'macos-15' && env.APPLE_CERTIFICATE != ''
+        run: bash frontend/scripts/sign-jpdfium-dylibs-in-bootjar.sh
+
       - name: Check DMG creation dependencies (macOS only)
         if: matrix.platform == 'macos-15'
         run: |

.github/workflows/test-build-docker.yml

@@ -165,7 +165,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@8d3c67de8e2fe68ef647c8db1e6a09f647780f40 # v2.19.0
+        uses: step-security/harden-runner@a5ad31d6a139d249332a2605b85202e8c0b78450 # v2.19.1
         with:
           egress-policy: audit
 

.gitignore

@@ -265,6 +265,8 @@ docs/type3/signatures/
 # Type3 sample PDFs (development only)
 **/type3/samples/
 
+**/application-dev-local.properties
+
 # Claude
 .claude/
 

.taskfiles/backend.yml

@@ -1,7 +1,19 @@
 version: '3'
 
-# All gradle invocations go through `bash gradlew` (the sh wrapper) so they work
-# uniformly on Linux/macOS (native bash) and Windows-with-Git-Bash.
+# Gradle invocation strategy:
+#   - Linux/macOS: `./gradlew` runs the POSIX shell wrapper natively.
+#   - Windows:     `cmd /c ".\gradlew.bat ..."` invokes the .bat wrapper through
+#                  cmd.exe so it inherits the user's Windows-side `JAVA_HOME`
+#                  and PATH. Routing through `bash gradlew` on Windows ends up
+#                  under WSL or Git-Bash, neither of which inherits
+#                  Adoptium/Temurin's default Windows-only Java env - gradlew
+#                  then errors with "JAVA_HOME is not set and no 'java' command
+#                  could be found".
+#
+#                  The entire `.\gradlew.bat ...` payload is double-quoted so
+#                  the leading `.\` survives mvdan/sh's POSIX backslash
+#                  stripping; cmd.exe also requires `.\` (not bare `gradlew.bat`)
+#                  because modern Windows excludes cwd from cmd's search path.
 
 tasks:
   dev:
@@ -13,43 +25,67 @@ tasks:
     env:
       SERVER_PORT: '{{.PORT}}'
     cmds:
-      - '{{if .AIENGINE_URL}}AIENGINE_URL={{.AIENGINE_URL}} AIENGINE_ENABLED=true {{end}}bash gradlew :stirling-pdf:bootRun'
+      - cmd: '{{if .AIENGINE_URL}}AIENGINE_URL={{.AIENGINE_URL}} AIENGINE_ENABLED=true {{end}}cmd /c ".\gradlew.bat :stirling-pdf:bootRun"'
+        platforms: [windows]
+      - cmd: '{{if .AIENGINE_URL}}AIENGINE_URL={{.AIENGINE_URL}} AIENGINE_ENABLED=true {{end}}./gradlew :stirling-pdf:bootRun'
+        platforms: [linux, darwin]
 
   dev:bundled:
     desc: "Clean + bootRun with frontend bundled into the backend (single :8080 server)"
     ignore_error: true
     cmds:
-      - bash gradlew clean bootRun -PbuildWithFrontend=true
+      - cmd: cmd /c ".\gradlew.bat clean bootRun -PbuildWithFrontend=true"
+        platforms: [windows]
+      - cmd: ./gradlew clean bootRun -PbuildWithFrontend=true
+        platforms: [linux, darwin]
 
   build:
     desc: "Full backend build"
     cmds:
-      - bash gradlew clean build
+      - cmd: cmd /c ".\gradlew.bat clean build"
+        platforms: [windows]
+      - cmd: ./gradlew clean build
+        platforms: [linux, darwin]
 
   build:fast:
     desc: "Build without tests"
     cmds:
-      - bash gradlew clean build -x test
+      - cmd: cmd /c ".\gradlew.bat clean build -x test"
+        platforms: [windows]
+      - cmd: ./gradlew clean build -x test
+        platforms: [linux, darwin]
 
   build:ci:
     desc: "Build for CI (formatting checked separately)"
     cmds:
-      - bash gradlew build -PnoSpotless
+      - cmd: cmd /c ".\gradlew.bat build -PnoSpotless"
+        platforms: [windows]
+      - cmd: ./gradlew build -PnoSpotless
+        platforms: [linux, darwin]
 
   test:
     desc: "Run backend tests"
     cmds:
-      - bash gradlew test
+      - cmd: cmd /c ".\gradlew.bat test"
+        platforms: [windows]
+      - cmd: ./gradlew test
+        platforms: [linux, darwin]
 
   format:
     desc: "Auto-fix code formatting"
     cmds:
-      - bash gradlew spotlessApply
+      - cmd: cmd /c ".\gradlew.bat spotlessApply"
+        platforms: [windows]
+      - cmd: ./gradlew spotlessApply
+        platforms: [linux, darwin]
 
   format:check:
     desc: "Check code formatting"
     cmds:
-      - bash gradlew spotlessCheck
+      - cmd: cmd /c ".\gradlew.bat spotlessCheck"
+        platforms: [windows]
+      - cmd: ./gradlew spotlessCheck
+        platforms: [linux, darwin]
 
   fix:
     desc: "Auto-fix backend"
@@ -59,7 +95,10 @@ tasks:
   swagger:
     desc: "Generate OpenAPI docs"
     cmds:
-      - bash gradlew :stirling-pdf:copySwaggerDoc
+      - cmd: cmd /c ".\gradlew.bat :stirling-pdf:copySwaggerDoc"
+        platforms: [windows]
+      - cmd: ./gradlew :stirling-pdf:copySwaggerDoc
+        platforms: [linux, darwin]
     sources:
       - app/core/src/main/java/**/*.java
       - app/proprietary/src/main/java/**/*.java
@@ -77,19 +116,31 @@ tasks:
     desc: "Print project version"
     silent: true
     cmds:
-      - bash gradlew printVersion --quiet | tail -1
+      - cmd: cmd /c ".\gradlew.bat printVersion --quiet" | tail -1
+        platforms: [windows]
+      - cmd: ./gradlew printVersion --quiet | tail -1
+        platforms: [linux, darwin]
 
   licenses:check:
     desc: "Check dependency licenses"
     cmds:
-      - bash gradlew checkLicense --no-parallel
+      - cmd: cmd /c ".\gradlew.bat checkLicense --no-parallel"
+        platforms: [windows]
+      - cmd: ./gradlew checkLicense --no-parallel
+        platforms: [linux, darwin]
 
   licenses:generate:
     desc: "Check and generate dependency license report"
     cmds:
-      - bash gradlew checkLicense generateLicenseReport --no-parallel
+      - cmd: cmd /c ".\gradlew.bat checkLicense generateLicenseReport --no-parallel"
+        platforms: [windows]
+      - cmd: ./gradlew checkLicense generateLicenseReport --no-parallel
+        platforms: [linux, darwin]
 
   clean:
     desc: "Clean build artifacts"
     cmds:
-      - bash gradlew clean
+      - cmd: cmd /c ".\gradlew.bat clean"
+        platforms: [windows]
+      - cmd: ./gradlew clean
+        platforms: [linux, darwin]

.taskfiles/desktop.yml

@@ -3,6 +3,22 @@ version: '3'
 vars:
   JLINK_MODULES: "java.base,java.compiler,java.desktop,java.instrument,java.logging,java.management,java.naming,java.net.http,java.prefs,java.rmi,java.scripting,java.security.jgss,java.security.sasl,java.sql,java.transaction.xa,java.xml,java.xml.crypto,jdk.crypto.ec,jdk.crypto.cryptoki,jdk.unsupported"
 
+  # Override via JPDFIUM_PLATFORMS env (csv of platform keys, or 'all').
+  JPDFIUM_PLATFORMS:
+    sh: |
+      if [ -n "${JPDFIUM_PLATFORMS:-}" ]; then
+          echo "$JPDFIUM_PLATFORMS"
+      else
+          case "{{OS}}-{{ARCH}}" in
+              darwin-arm64)  echo "darwin-arm64";;
+              darwin-amd64)  echo "darwin-x64";;
+              linux-amd64)   echo "linux-x64";;
+              linux-arm64)   echo "linux-arm64";;
+              windows-amd64) echo "windows-x64";;
+              *)             echo "all";;
+          esac
+      fi
+
 tasks:
   prepare:
     desc: "Prepare desktop build dependencies"
@@ -71,15 +87,16 @@ tasks:
     deps: [jlink:jar, jlink:runtime]
 
   jlink:jar:
-    desc: "Build backend JAR for Tauri bundling"
+    desc: "Build backend JAR for Tauri bundling (host-OS natives only by default)"
     run: once
     dir: ..
     env:
       DISABLE_ADDITIONAL_FEATURES: "true"
     cmds:
-      - cmd: cmd /c gradlew.bat bootJar --no-daemon
+      - echo "Building bootJar with JPDFium natives for {{.JPDFIUM_PLATFORMS}}"
+      - cmd: cmd /c gradlew.bat bootJar --no-daemon -PjpdfiumPlatforms={{.JPDFIUM_PLATFORMS}}
         platforms: [windows]
-      - cmd: ./gradlew bootJar --no-daemon
+      - cmd: ./gradlew bootJar --no-daemon -PjpdfiumPlatforms={{.JPDFIUM_PLATFORMS}}
         platforms: [linux, darwin]
       - mkdir -p frontend/src-tauri/libs
       - cp app/core/build/libs/stirling-pdf-*.jar frontend/src-tauri/libs/

.taskfiles/engine.yml

@@ -86,8 +86,9 @@ tasks:
   fix:
     desc: "Auto-fix lint + format"
     cmds:
+      - task: format  # Can auto-fix some things that `lint:fix` can't like line length violations
       - task: lint:fix
-      - task: format
+      - task: format  # Ensure that after lint fixing that the code is still formatted correctly
 
   check:
     desc: "Full engine quality gate"

AGENTS.md

@@ -183,26 +183,26 @@ Use this pattern for desktop-specific or proprietary-specific features WITHOUT r
 **Example - Desktop-specific footer:**
 
 ```typescript
-// core/components/rightRail/RightRailFooterExtensions.tsx (stub)
-interface RightRailFooterExtensionsProps {
+// core/components/workbenchBar/WorkbenchBarFooterExtensions.tsx (stub)
+interface WorkbenchBarFooterExtensionsProps {
   className?: string;
 }
 
-export function RightRailFooterExtensions(_props: RightRailFooterExtensionsProps) {
+export function WorkbenchBarFooterExtensions(_props: WorkbenchBarFooterExtensionsProps) {
   return null; // Stub - does nothing in web builds
 }
 ```
 
 ```tsx
-// desktop/components/rightRail/RightRailFooterExtensions.tsx (real implementation)
+// desktop/components/workbenchBar/WorkbenchBarFooterExtensions.tsx (real implementation)
 import { Box } from '@mantine/core';
 import { BackendHealthIndicator } from '@app/components/BackendHealthIndicator';
 
-interface RightRailFooterExtensionsProps {
+interface WorkbenchBarFooterExtensionsProps {
   className?: string;
 }
 
-export function RightRailFooterExtensions({ className }: RightRailFooterExtensionsProps) {
+export function WorkbenchBarFooterExtensions({ className }: WorkbenchBarFooterExtensionsProps) {
   return (
     <Box className={className}>
       <BackendHealthIndicator />
@@ -212,15 +212,15 @@ export function RightRailFooterExtensions({ className }: RightRailFooterExtensio
 ```
 
 ```tsx
-// core/components/shared/RightRail.tsx (usage - works in ALL builds)
-import { RightRailFooterExtensions } from '@app/components/rightRail/RightRailFooterExtensions';
+// core/components/shared/WorkbenchBar.tsx (usage - works in ALL builds)
+import { WorkbenchBarFooterExtensions } from '@app/components/workbenchBar/WorkbenchBarFooterExtensions';
 
-export function RightRail() {
+export function WorkbenchBar() {
   return (
     <div>
       {/* In web builds: renders nothing (stub returns null) */}
       {/* In desktop builds: renders BackendHealthIndicator */}
-      <RightRailFooterExtensions className="right-rail-footer" />
+      <WorkbenchBarFooterExtensions className="workbench-bar-footer" />
     </div>
   );
 }
@@ -431,7 +431,7 @@ The frontend is organized with a clear separation of concerns:
 
 ## Important Notes
 
-- **Java Version**: Minimum JDK 21, supports and recommends JDK 25
+- **Java Version**: Requires 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

DeveloperGuide.md

@@ -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 (requires JDK 25)
 - PDFBox for core PDF operations
 - LibreOffice for document conversions
 - qpdf for PDF optimization
@@ -45,7 +45,7 @@ This guide focuses on developing for Stirling 2.0, including both the React fron
 - [Task](https://taskfile.dev/installation/) — unified command runner (recommended)
 - Docker
 - Git
-- Java JDK 21 or later (JDK 25 recommended)
+- Java JDK 25
 - Node.js 18+ and npm (required for frontend development)
 - Gradle 7.0 or later (Included within the repo)
 - [uv](https://docs.astral.sh/uv/) — Python package manager (required for engine development)
@@ -61,7 +61,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 JDK 25 if not already installed.
 
 3. Install a recommended Java IDE such as Eclipse, IntelliJ, or VSCode
    1. Only VSCode

LICENSE

@@ -6,6 +6,8 @@ Portions of this software are licensed as follows:
 
 * All content that resides under the "app/proprietary/" directory of this repository,
 if that directory exists, is licensed under the license defined in "app/proprietary/LICENSE".
+* All content that resides under the "app/saas/" directory of this repository,
+if that directory exists, is licensed under the license defined in "app/saas/LICENSE".
 * All content that resides under the "engine/" directory of this repository,
 if that directory exists, is licensed under the license defined in "engine/LICENSE".
 * All content that resides under the "frontend/src/proprietary/" directory of this repository,

Taskfile.yml

@@ -3,7 +3,7 @@ version: '3'
 output: prefixed
 
 vars:
-  FIND_FREE_PORT_PS: powershell -NoProfile -File scripts\find-free-port.ps1 -Preferred
+  FIND_FREE_PORT_PS: powershell -NoProfile -File scripts/find-free-port.ps1
   FIND_FREE_PORT_SH: bash scripts/find-free-port.sh
 
 includes:
@@ -45,7 +45,7 @@ tasks:
     desc: "Start backend + frontend concurrently on free ports"
     vars:
       PORTS:
-        sh: '{{if eq OS "windows"}}{{.FIND_FREE_PORT_PS}} 8080,5173{{else}}{{.FIND_FREE_PORT_SH}} 8080 5173{{end}}'
+        sh: '{{if eq OS "windows"}}{{.FIND_FREE_PORT_PS}} 8080 5173{{else}}{{.FIND_FREE_PORT_SH}} 8080 5173{{end}}'
       BACKEND_PORT: '{{index (splitList "\n" .PORTS) 0}}'
       FRONTEND_PORT: '{{index (splitList "\n" .PORTS) 1}}'
     deps:
@@ -62,7 +62,7 @@ tasks:
     desc: "Start backend + frontend + engine concurrently on free ports"
     vars:
       PORTS:
-        sh: '{{if eq OS "windows"}}{{.FIND_FREE_PORT_PS}} 8080,5173,5001{{else}}{{.FIND_FREE_PORT_SH}} 8080 5173 5001{{end}}'
+        sh: '{{if eq OS "windows"}}{{.FIND_FREE_PORT_PS}} 8080 5173 5001{{else}}{{.FIND_FREE_PORT_SH}} 8080 5173 5001{{end}}'
       BACKEND_PORT: '{{index (splitList "\n" .PORTS) 0}}'
       FRONTEND_PORT: '{{index (splitList "\n" .PORTS) 1}}'
       ENGINE_PORT: '{{index (splitList "\n" .PORTS) 2}}'

app/common/build.gradle

@@ -51,4 +51,33 @@ dependencies {
     api 'org.simplejavamail:outlook-module:8.12.6' // MSG file support
     api 'jakarta.mail:jakarta.mail-api:2.1.5'
     runtimeOnly 'org.eclipse.angus:angus-mail:2.0.5'
+
+    // Tabula table extraction — used by the shared PDF parser and directly by downstream modules.
+    // api-scoped so downstream modules (core, proprietary) retain it on their compile classpath.
+    api ('technology.tabula:tabula:1.0.5') {
+        exclude group: 'org.slf4j', module: 'slf4j-simple'
+        exclude group: 'org.bouncycastle', module: 'bcprov-jdk15on'
+        exclude group: 'com.google.code.gson', module: 'gson'
+    }
+
+    api 'com.stirling:jpdfium:1.0.0'
+
+    // -PjpdfiumPlatforms=all|<csv of linux-x64,linux-arm64,darwin-x64,darwin-arm64,windows-x64>
+    def jpdfiumPlatformsProp = (project.findProperty('jpdfiumPlatforms') ?: 'all').toString().trim()
+    def jpdfiumAllPlatforms = ['linux-x64', 'linux-arm64', 'darwin-x64', 'darwin-arm64', 'windows-x64']
+    def jpdfiumPlatforms = jpdfiumPlatformsProp == 'all'
+            ? jpdfiumAllPlatforms
+            : jpdfiumPlatformsProp.split(',').collect { it.trim() }.findAll { it }
+    def jpdfiumInvalid = jpdfiumPlatforms.findAll { !jpdfiumAllPlatforms.contains(it) }
+    if (jpdfiumInvalid) {
+        throw new GradleException("Unknown jpdfiumPlatforms value(s): ${jpdfiumInvalid.join(', ')}. " +
+                "Valid: ${jpdfiumAllPlatforms.join(', ')} or 'all'.")
+    }
+    logger.lifecycle("JPDFium native platforms: ${jpdfiumPlatforms.join(', ')}")
+    jpdfiumPlatforms.each { platform ->
+        runtimeOnly "com.stirling:jpdfium-natives-${platform}:1.0.0"
+    }
+
+    // ArchUnit: enforces module dependency direction (see ArchitectureTest)
+    testImplementation 'com.tngtech.archunit:archunit-junit5:1.4.2'
 }

app/common/src/main/java/stirling/software/SPDF/pdf/parser/CompositeTableParser.java

@@ -0,0 +1,73 @@
+package stirling.software.SPDF.pdf.parser;
+
+import static stirling.software.SPDF.pdf.parser.PdfModels.*;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.springframework.context.annotation.Primary;
+import org.springframework.stereotype.Service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Chains table parsers in priority order: Tabula lattice → Tabula stream → {@link
+ * LineAlignmentTableParser}. The first parser returning a result above {@link
+ * #TABULA_CONFIDENCE_THRESHOLD} wins; results from different parsers are never mixed on one page.
+ */
+@Service
+@Primary
+@RequiredArgsConstructor
+@Slf4j
+public class CompositeTableParser implements TableParser {
+
+    /** Min Tabula confidence to accept results; below this LineAlignment is tried instead. */
+    static final float TABULA_CONFIDENCE_THRESHOLD = 0.5f;
+
+    private final TabulaTableParser tabulaParser;
+    private final LineAlignmentTableParser lineAlignmentParser;
+
+    @Override
+    public List<TableFragment> parse(PDDocument document, RawPage rawPage) throws IOException {
+        // Step 1: Tabula lattice mode (ruled/bordered tables).
+        List<TableFragment> latticeResults = filterConfident(tabulaParser.parse(document, rawPage));
+        if (!latticeResults.isEmpty()) {
+            log.debug(
+                    "Page {}: using Tabula lattice ({} table(s))",
+                    rawPage.pageNumber(),
+                    latticeResults.size());
+            return latticeResults;
+        }
+
+        // Step 2: Tabula stream mode (borderless/whitespace-delimited tables).
+        // parseStream is not on the TableParser interface — this intentionally couples to the
+        // concrete TabulaTableParser since stream mode is a Tabula-specific concept.
+        List<TableFragment> streamResults =
+                filterConfident(tabulaParser.parseStream(document, rawPage));
+        if (!streamResults.isEmpty()) {
+            log.debug(
+                    "Page {}: using Tabula stream ({} table(s))",
+                    rawPage.pageNumber(),
+                    streamResults.size());
+            return streamResults;
+        }
+
+        // Step 3: Geometry-based line-alignment fallback.
+        List<TableFragment> lineResults = lineAlignmentParser.parse(document, rawPage);
+        if (!lineResults.isEmpty()) {
+            log.debug(
+                    "Page {}: using LineAlignment ({} table(s))",
+                    rawPage.pageNumber(),
+                    lineResults.size());
+            return lineResults;
+        }
+
+        return List.of();
+    }
+
+    private List<TableFragment> filterConfident(List<TableFragment> tables) {
+        return tables.stream().filter(t -> t.confidence() >= TABULA_CONFIDENCE_THRESHOLD).toList();
+    }
+}

app/common/src/main/java/stirling/software/SPDF/pdf/parser/LineAlignmentTableParser.java

@@ -0,0 +1,528 @@
+package stirling.software.SPDF.pdf.parser;
+
+import static stirling.software.SPDF.pdf.parser.PdfModels.*;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.TreeMap;
+import java.util.regex.Pattern;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.springframework.stereotype.Service;
+
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Fallback {@link TableParser} for borderless financial tables using text geometry.
+ *
+ * <p>Identifies "anchor lines" (≥2 numeric tokens), builds a column grid from their right-edge
+ * positions, groups vertically proximate anchor lines into table candidates, then scores each group
+ * on column consistency and anchor density (confidence ceiling 0.85).
+ */
+@Service
+@Slf4j
+public class LineAlignmentTableParser implements TableParser {
+
+    /** Width in points of each column position bucket. */
+    static final float COLUMN_BUCKET_PT = 5f;
+
+    /** Tolerance in buckets when matching a token's right-edge to a confirmed column position. */
+    private static final int COLUMN_MATCH_BUCKETS = 2;
+
+    /** Maximum gap (as a multiple of modal line spacing) before splitting a group. */
+    private static final float MAX_GAP_FACTOR = 2.5f;
+
+    /** Minimum anchor rows (numeric-heavy) to form a valid table. */
+    static final int MIN_TABLE_ROWS = 3;
+
+    /** Minimum confirmed column positions to form a valid table. */
+    static final int MIN_COLUMNS = 2;
+
+    /**
+     * Min fraction of anchor lines a column must appear on to be confirmed (permissive for N/A
+     * rows).
+     */
+    private static final double COLUMN_MIN_FREQUENCY = 0.40;
+
+    /**
+     * Matches financial numeric tokens: integers, decimals, parenthetical negatives, currency,
+     * percent, nil dashes.
+     */
+    private static final Pattern NUMERIC =
+            Pattern.compile("^[\\(\\-\\$£€¥]?\\d[\\d,\\.]*[\\)%]?$|^[-–—]$");
+
+    /**
+     * Lines within this y-distance are merged into one row (restores rows split by LineBuilder's
+     * column-gap logic).
+     */
+    static final float ROW_MERGE_TOLERANCE_PT = 2f;
+
+    // ── public API ───────────────────────────────────────────────────────────────────────────────
+
+    @Override
+    public List<TableFragment> parse(PDDocument document, RawPage rawPage) throws IOException {
+        List<RawLine> lines = rawPage.lines();
+        if (lines.size() < MIN_TABLE_ROWS) return List.of();
+
+        float modalSpacing = computeModalSpacing(lines);
+        List<TokenizedLine> tokenized =
+                mergeCoincidentLines(lines.stream().map(this::tokenize).toList());
+
+        List<TokenizedLine> anchors = tokenized.stream().filter(TokenizedLine::isAnchor).toList();
+
+        if (anchors.size() < MIN_TABLE_ROWS) return List.of();
+
+        List<Float> columnGrid = buildColumnGrid(anchors);
+        if (columnGrid.size() < MIN_COLUMNS) {
+            log.debug(
+                    "Page {}: LineAlignment — fewer than {} confirmed columns, skipping",
+                    rawPage.pageNumber(),
+                    MIN_COLUMNS);
+            return List.of();
+        }
+
+        List<List<TokenizedLine>> groups = groupRows(tokenized, columnGrid, modalSpacing);
+
+        List<TableFragment> results = new ArrayList<>();
+        for (int i = 0; i < groups.size(); i++) {
+            buildFragment(groups.get(i), columnGrid, rawPage.pageNumber(), i)
+                    .ifPresent(results::add);
+        }
+
+        log.debug(
+                "Page {}: LineAlignment detected {} table(s) ({} anchor lines, {} columns)",
+                rawPage.pageNumber(),
+                results.size(),
+                anchors.size(),
+                columnGrid.size());
+        return results;
+    }
+
+    // ── coincident-line merging ──────────────────────────────────────────────────────────────────
+
+    /**
+     * Merges tokenised lines sharing the same y-position into one row, rejoining label/value halves
+     * split by LineBuilder.
+     */
+    List<TokenizedLine> mergeCoincidentLines(List<TokenizedLine> tokenized) {
+        if (tokenized.size() < 2) return tokenized;
+
+        List<TokenizedLine> result = new ArrayList<>();
+        int i = 0;
+
+        while (i < tokenized.size()) {
+            float baseY = tokenized.get(i).line().bounds().y();
+            int j = i + 1;
+            while (j < tokenized.size()
+                    && Math.abs(tokenized.get(j).line().bounds().y() - baseY)
+                            <= ROW_MERGE_TOLERANCE_PT) {
+                j++;
+            }
+
+            if (j == i + 1) {
+                result.add(tokenized.get(i));
+            } else {
+                result.add(mergeGroup(tokenized.subList(i, j)));
+            }
+            i = j;
+        }
+
+        return result;
+    }
+
+    private TokenizedLine mergeGroup(List<TokenizedLine> group) {
+        List<TextFragment> mergedFragments =
+                group.stream()
+                        .flatMap(tl -> tl.line().fragments().stream())
+                        .sorted(Comparator.comparingDouble(f -> f.bounds().x()))
+                        .toList();
+
+        Bounds mergedBounds =
+                group.stream()
+                        .map(tl -> tl.line().bounds())
+                        .reduce(Bounds::merge)
+                        .orElse(group.get(0).line().bounds());
+
+        RawLine mergedLine =
+                new RawLine(
+                        group.get(0).line().lineId(),
+                        mergedFragments,
+                        mergedBounds,
+                        group.get(0).line().pageNumber());
+
+        return tokenize(mergedLine);
+    }
+
+    // ── tokenisation ─────────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Splits fragments into word-level tokens; x-positions are estimated linearly within each
+     * fragment.
+     */
+    TokenizedLine tokenize(RawLine line) {
+        List<LineToken> tokens = new ArrayList<>();
+        for (TextFragment frag : line.fragments()) {
+            tokens.addAll(tokensFromFragment(frag));
+        }
+        List<LineToken> numeric = tokens.stream().filter(LineToken::numeric).toList();
+        return new TokenizedLine(line, tokens, numeric);
+    }
+
+    private List<LineToken> tokensFromFragment(TextFragment frag) {
+        String raw = frag.text();
+        if (raw == null || raw.isBlank()) return List.of();
+
+        float fragX = frag.bounds().x();
+        float fragWidth = frag.bounds().width();
+        int rawLen = raw.length();
+
+        List<LineToken> result = new ArrayList<>();
+        int offset = 0;
+        for (String part : raw.split("\\s+")) {
+            if (part.isEmpty()) {
+                offset++;
+                continue;
+            }
+            int idx = raw.indexOf(part, offset);
+            if (idx < 0) idx = offset;
+
+            float tokenX = rawLen > 0 ? fragX + ((float) idx / rawLen) * fragWidth : fragX;
+            float tokenRight =
+                    rawLen > 0
+                            ? fragX + ((float) (idx + part.length()) / rawLen) * fragWidth
+                            : fragX + fragWidth;
+
+            result.add(new LineToken(part, tokenX, tokenRight, NUMERIC.matcher(part).matches()));
+            offset = idx + part.length();
+        }
+        return result;
+    }
+
+    // ── column grid ──────────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Returns confirmed column right-edge positions — those appearing on ≥ {@value
+     * #COLUMN_MIN_FREQUENCY} × N anchor lines.
+     */
+    private List<Float> buildColumnGrid(List<TokenizedLine> anchors) {
+        // bucket → set of line indices that contributed a numeric token to that bucket
+        Map<Integer, List<Integer>> bucketLines = new HashMap<>();
+        for (int i = 0; i < anchors.size(); i++) {
+            for (LineToken t : anchors.get(i).numeric()) {
+                int bucket = bucket(t.right());
+                bucketLines.computeIfAbsent(bucket, k -> new ArrayList<>()).add(i);
+            }
+        }
+
+        int minHits =
+                Math.max(MIN_TABLE_ROWS, (int) Math.ceil(anchors.size() * COLUMN_MIN_FREQUENCY));
+
+        // Confirmed buckets → average right-edge for that bucket
+        TreeMap<Integer, Float> confirmed = new TreeMap<>();
+        for (Map.Entry<Integer, List<Integer>> entry : bucketLines.entrySet()) {
+            // Count distinct lines
+            long distinctLines = entry.getValue().stream().distinct().count();
+            if (distinctLines >= minHits) {
+                double avg =
+                        entry.getValue().stream()
+                                .distinct() // weight each line equally regardless of token count
+                                .mapToDouble(
+                                        lineIdx ->
+                                                avgRightEdgeForBucket(
+                                                        anchors, lineIdx, entry.getKey()))
+                                .average()
+                                .orElse(entry.getKey() * (double) COLUMN_BUCKET_PT);
+                confirmed.put(entry.getKey(), (float) avg);
+            }
+        }
+
+        return new ArrayList<>(confirmed.values()); // already sorted by bucket (left to right)
+    }
+
+    /**
+     * Returns the average right-edge position of tokens in {@code line} whose bucket matches {@code
+     * targetBucket}, falling back to the bucket's nominal centre when no tokens match.
+     */
+    private double avgRightEdgeForBucket(
+            List<TokenizedLine> anchors, int lineIdx, int targetBucket) {
+        return anchors.get(lineIdx).numeric().stream()
+                .filter(t -> bucket(t.right()) == targetBucket)
+                .mapToDouble(LineToken::right)
+                .average()
+                .orElse(targetBucket * (double) COLUMN_BUCKET_PT);
+    }
+
+    // ── grouping ─────────────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Groups anchor lines into table candidates, including adjacent label rows; a gap &gt;
+     * MAX_GAP_FACTOR × modal spacing splits groups.
+     */
+    private List<List<TokenizedLine>> groupRows(
+            List<TokenizedLine> all, List<Float> columnGrid, float modalSpacing) {
+        float maxGap = modalSpacing > 0 ? modalSpacing * MAX_GAP_FACTOR : 30f;
+
+        List<List<TokenizedLine>> groups = new ArrayList<>();
+        List<TokenizedLine> current = new ArrayList<>();
+
+        for (int i = 0; i < all.size(); i++) {
+            TokenizedLine tl = all.get(i);
+            boolean fits = tl.isAnchor() && matchesGrid(tl, columnGrid);
+
+            if (current.isEmpty()) {
+                if (fits) current.add(tl);
+                continue;
+            }
+
+            float gap =
+                    tl.line().bounds().y()
+                            - current.get(current.size() - 1).line().bounds().bottom();
+
+            if (gap > maxGap) {
+                groups.add(current);
+                current = new ArrayList<>();
+                if (fits) current.add(tl);
+                continue;
+            }
+
+            if (fits) {
+                current.add(tl);
+            } else if (!tl.line().text().isBlank()) {
+                // Include non-anchor lines (labels) only if they have text and are within
+                // proximity.
+                current.add(tl);
+            }
+        }
+
+        if (!current.isEmpty()) groups.add(current);
+
+        return groups.stream().filter(g -> hasEnoughAnchorRows(g, columnGrid)).toList();
+    }
+
+    private boolean hasEnoughAnchorRows(List<TokenizedLine> group, List<Float> columnGrid) {
+        return group.stream().filter(r -> r.isAnchor() && matchesGrid(r, columnGrid)).count()
+                >= MIN_TABLE_ROWS;
+    }
+
+    /** A line "matches" the grid when ≥ 60 % of its numeric tokens land in confirmed columns. */
+    private boolean matchesGrid(TokenizedLine tl, List<Float> columnGrid) {
+        if (tl.numeric().isEmpty()) return false;
+        long matches =
+                tl.numeric().stream()
+                        .filter(t -> nearestColumnIndex(t.right(), columnGrid) >= 0)
+                        .count();
+        return (double) matches / tl.numeric().size() >= 0.60;
+    }
+
+    private boolean hasInconsistentColumnMatch(TokenizedLine tl, List<Float> columnGrid) {
+        if (tl.numeric().isEmpty()) return false;
+        long hits =
+                tl.numeric().stream()
+                        .filter(t -> nearestColumnIndex(t.right(), columnGrid) >= 0)
+                        .count();
+        return (double) hits / tl.numeric().size() < 0.60;
+    }
+
+    // ── fragment assembly ────────────────────────────────────────────────────────────────────────
+
+    private Optional<TableFragment> buildFragment(
+            List<TokenizedLine> group, List<Float> columnGrid, int pageNumber, int tableIndex) {
+
+        long anchorCount =
+                group.stream().filter(r -> r.isAnchor() && matchesGrid(r, columnGrid)).count();
+        if (anchorCount < MIN_TABLE_ROWS) return Optional.empty();
+
+        List<String> warnings = new ArrayList<>();
+        List<List<String>> rawRows = new ArrayList<>();
+        List<TableRow> rows = new ArrayList<>();
+
+        for (int rowIdx = 0; rowIdx < group.size(); rowIdx++) {
+            TokenizedLine tl = group.get(rowIdx);
+            List<String> rawRow = buildRawRow(tl, columnGrid);
+            rawRows.add(Collections.unmodifiableList(rawRow));
+            rows.add(buildTableRow(rowIdx, tl, rawRow, columnGrid));
+        }
+
+        // Column count = 1 label column + confirmed numeric columns
+        int colCount = columnGrid.size() + 1;
+        Bounds bounds = computeGroupBounds(group);
+        float confidence = computeConfidence(group, columnGrid, warnings);
+
+        return Optional.of(
+                new TableFragment(
+                        "tbl-la-p" + pageNumber + "-" + tableIndex,
+                        pageNumber,
+                        bounds,
+                        List.of(),
+                        Collections.unmodifiableList(rows),
+                        Collections.unmodifiableList(rawRows),
+                        colCount,
+                        confidence,
+                        Collections.unmodifiableList(warnings),
+                        null));
+    }
+
+    /**
+     * Builds a raw row as a list of strings: index 0 = label text, indices 1..N = column values.
+     */
+    private List<String> buildRawRow(TokenizedLine tl, List<Float> columnGrid) {
+        String[] cells = new String[columnGrid.size() + 1];
+        Arrays.fill(cells, "");
+
+        // Separate label tokens (those not landing in any confirmed column) from column tokens.
+        List<String> labelParts = new ArrayList<>();
+        for (LineToken token : tl.all()) {
+            int col = nearestColumnIndex(token.right(), columnGrid);
+            if (col >= 0 && token.numeric()) {
+                int cellIdx = col + 1;
+                cells[cellIdx] =
+                        cells[cellIdx].isEmpty()
+                                ? token.text()
+                                : cells[cellIdx] + " " + token.text();
+            } else {
+                labelParts.add(token.text());
+            }
+        }
+        cells[0] = String.join(" ", labelParts).trim();
+        return Arrays.asList(cells);
+    }
+
+    private TableRow buildTableRow(
+            int rowIdx, TokenizedLine tl, List<String> rawRow, List<Float> columnGrid) {
+        List<TableCell> cells = new ArrayList<>(rawRow.size());
+
+        // Label cell: use the line's full bounds as an approximation.
+        cells.add(TableCell.of(0, rawRow.get(0), tl.line().bounds()));
+
+        for (int col = 0; col < columnGrid.size(); col++) {
+            String text = col + 1 < rawRow.size() ? rawRow.get(col + 1) : "";
+            float right = columnGrid.get(col);
+            float left = col > 0 ? columnGrid.get(col - 1) : right - 50f;
+            Bounds cellBounds =
+                    new Bounds(
+                            left,
+                            tl.line().bounds().y(),
+                            right - left,
+                            tl.line().bounds().height());
+            cells.add(TableCell.of(col + 1, text, cellBounds));
+        }
+        return new TableRow(rowIdx, Collections.unmodifiableList(cells));
+    }
+
+    // ── confidence scoring ───────────────────────────────────────────────────────────────────────
+
+    /**
+     * Heuristic score in [0.0, 0.85] (ceiling keeps results below Tabula lattice which starts at
+     * 1.0). Base 0.70; +0.05/col beyond 2 (max +0.10); +0.05 at ≥5 anchors, +0.05 at ≥8; −0.15 if
+     * &gt;30 % of anchors have inconsistent columns; −0.10 if non-anchors outnumber anchors.
+     */
+    private float computeConfidence(
+            List<TokenizedLine> group, List<Float> columnGrid, List<String> warnings) {
+        float score = 0.70f;
+
+        long anchorCount =
+                group.stream().filter(r -> r.isAnchor() && matchesGrid(r, columnGrid)).count();
+        long totalRows = group.size();
+
+        // More columns
+        int extraCols = Math.min(columnGrid.size() - MIN_COLUMNS, 2);
+        score += extraCols * 0.05f;
+
+        // More anchor rows
+        if (anchorCount >= 5) score += 0.05f;
+        if (anchorCount >= 8) score += 0.05f;
+
+        // Inconsistent column matching
+        long inconsistent =
+                group.stream()
+                        .filter(TokenizedLine::isAnchor)
+                        .filter(tl -> hasInconsistentColumnMatch(tl, columnGrid))
+                        .count();
+        if (inconsistent > anchorCount * 0.30) {
+            score -= 0.15f;
+            warnings.add(
+                    "Column match inconsistent on "
+                            + inconsistent
+                            + "/"
+                            + anchorCount
+                            + " anchor rows");
+        }
+
+        // Label-heavy
+        long nonAnchor = totalRows - anchorCount;
+        if (nonAnchor > anchorCount) {
+            score -= 0.10f;
+            warnings.add(
+                    "Non-anchor rows ("
+                            + nonAnchor
+                            + ") outnumber anchor rows ("
+                            + anchorCount
+                            + ")");
+        }
+
+        return Math.max(0f, Math.min(0.85f, score));
+    }
+
+    // ── utility ──────────────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Returns the grid index nearest to {@code rightEdge}, or -1 if none is within {@value
+     * #COLUMN_MATCH_BUCKETS} buckets.
+     */
+    private int nearestColumnIndex(float rightEdge, List<Float> grid) {
+        int nearest = -1;
+        float minDist = COLUMN_MATCH_BUCKETS * COLUMN_BUCKET_PT + 1f;
+        for (int i = 0; i < grid.size(); i++) {
+            float dist = Math.abs(rightEdge - grid.get(i));
+            if (dist < minDist) {
+                minDist = dist;
+                nearest = i;
+            }
+        }
+        return nearest;
+    }
+
+    private Bounds computeGroupBounds(List<TokenizedLine> group) {
+        return group.stream()
+                .map(tl -> tl.line().bounds())
+                .reduce(Bounds::merge)
+                .orElse(new Bounds(0, 0, 0, 0));
+    }
+
+    /** Modal gap between consecutive line edges, used to calibrate the group-split threshold. */
+    private float computeModalSpacing(List<RawLine> lines) {
+        if (lines.size() < 2) return 0f;
+        Map<Float, Long> freq = new HashMap<>();
+        for (int i = 1; i < lines.size(); i++) {
+            float gap = lines.get(i).bounds().y() - lines.get(i - 1).bounds().bottom();
+            if (gap > 0) freq.merge(Math.round(gap / 2f) * 2f, 1L, Long::sum);
+        }
+        return freq.entrySet().stream()
+                .max(Map.Entry.comparingByValue())
+                .map(Map.Entry::getKey)
+                .orElse(0f);
+    }
+
+    private static int bucket(float x) {
+        return Math.round(x / COLUMN_BUCKET_PT);
+    }
+
+    // ── private data types ───────────────────────────────────────────────────────────────────────
+
+    /** A word-level token with an approximate right-edge x-position. */
+    record LineToken(String text, float x, float right, boolean numeric) {}
+
+    /** A {@link RawLine} with tokens pre-computed; an "anchor" has ≥ 2 numeric tokens. */
+    record TokenizedLine(RawLine line, List<LineToken> all, List<LineToken> numeric) {
+        boolean isAnchor() {
+            return numeric.size() >= 2;
+        }
+    }
+}

app/common/src/main/java/stirling/software/SPDF/pdf/parser/LineBuilder.java

@@ -0,0 +1,139 @@
+package stirling.software.SPDF.pdf.parser;
+
+import static stirling.software.SPDF.pdf.parser.PdfModels.*;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+import org.springframework.stereotype.Service;
+
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Groups {@link TextFragment} objects into visual {@link RawLine}s using baseline proximity.
+ *
+ * <p>Fragments are on the same line when their baselines are within a font-size-derived tolerance.
+ * A new line starts whenever the horizontal gap exceeds an adaptive column-gap threshold ({@code
+ * max(effectiveWidth * COLUMN_GAP_RATIO, COLUMN_GAP_MIN_PT)}), splitting two-column text.
+ */
+@Service
+@Slf4j
+public class LineBuilder {
+
+    /** Baseline tolerance as a fraction of font size; 0.5 keeps mixed-size text on one line. */
+    private static final float BASELINE_TOLERANCE_FACTOR = 0.5f;
+
+    /** Absolute minimum tolerance so tiny font sizes don't collapse multi-line content. */
+    private static final float MIN_BASELINE_TOLERANCE = 2f;
+
+    /**
+     * Column-gap threshold as a fraction of page width; 0.10 clears tab stops but stays below
+     * two-column gutters.
+     */
+    static final float COLUMN_GAP_RATIO = 0.10f;
+
+    /** Floor for the column-gap threshold so narrow pages don't over-split lines. */
+    static final float COLUMN_GAP_MIN_PT = 40f;
+
+    public List<RawLine> build(List<TextFragment> fragments, int pageNumber) {
+        if (fragments.isEmpty()) return List.of();
+
+        float effectiveWidth = inferEffectiveWidth(fragments);
+        float columnGapThreshold = Math.max(effectiveWidth * COLUMN_GAP_RATIO, COLUMN_GAP_MIN_PT);
+        log.debug(
+                "LineBuilder page {}: effectiveWidth={:.1f}pt, columnGapThreshold={:.1f}pt",
+                pageNumber,
+                effectiveWidth,
+                columnGapThreshold);
+
+        // Sort top-to-bottom first, then left-to-right within the same baseline band.
+        List<TextFragment> sorted =
+                fragments.stream()
+                        .sorted(
+                                Comparator.comparingDouble(TextFragment::baseline)
+                                        .thenComparingDouble(f -> f.bounds().x()))
+                        .toList();
+
+        List<List<TextFragment>> groups = groupByBaseline(sorted, columnGapThreshold);
+
+        List<RawLine> lines = new ArrayList<>(groups.size());
+        for (int i = 0; i < groups.size(); i++) {
+            List<TextFragment> group =
+                    groups.get(i).stream()
+                            .sorted(Comparator.comparingDouble(f -> f.bounds().x()))
+                            .toList();
+
+            Bounds lineBounds =
+                    group.stream()
+                            .map(TextFragment::bounds)
+                            .reduce(Bounds::merge)
+                            .orElse(new Bounds(0, 0, 0, 0));
+
+            lines.add(new RawLine("ln-p" + pageNumber + "-" + i, group, lineBounds, pageNumber));
+        }
+        return lines;
+    }
+
+    private List<List<TextFragment>> groupByBaseline(
+            List<TextFragment> sorted, float columnGapThreshold) {
+        List<List<TextFragment>> groups = new ArrayList<>();
+        List<TextFragment> current = new ArrayList<>();
+        float currentBaseline = Float.NaN;
+
+        for (TextFragment fragment : sorted) {
+            if (current.isEmpty()) {
+                current.add(fragment);
+                currentBaseline = fragment.baseline();
+                continue;
+            }
+
+            float maxFontSize =
+                    Math.max(
+                            fragment.fontSize(),
+                            (float)
+                                    current.stream()
+                                            .mapToDouble(TextFragment::fontSize)
+                                            .max()
+                                            .orElse(0));
+            float tolerance =
+                    Math.max(maxFontSize * BASELINE_TOLERANCE_FACTOR, MIN_BASELINE_TOLERANCE);
+
+            boolean sameBaseline = Math.abs(fragment.baseline() - currentBaseline) <= tolerance;
+            boolean columnGap = sameBaseline && hasColumnGap(fragment, current, columnGapThreshold);
+
+            if (sameBaseline && !columnGap) {
+                current.add(fragment);
+                // Anchor to the weighted mean baseline so long lines stay stable.
+                currentBaseline =
+                        (currentBaseline * (current.size() - 1) + fragment.baseline())
+                                / current.size();
+            } else {
+                groups.add(current);
+                current = new ArrayList<>();
+                current.add(fragment);
+                currentBaseline = fragment.baseline();
+            }
+        }
+
+        if (!current.isEmpty()) groups.add(current);
+        return groups;
+    }
+
+    /**
+     * True when the gap from the rightmost fragment in {@code group} to {@code next} exceeds {@code
+     * threshold}.
+     */
+    private static boolean hasColumnGap(
+            TextFragment next, List<TextFragment> group, float threshold) {
+        float lastRight = group.get(group.size() - 1).bounds().right();
+        return next.bounds().x() - lastRight > threshold;
+    }
+
+    /** Infers effective page width from the rightmost fragment right-edge plus a 10 % margin. */
+    private static float inferEffectiveWidth(List<TextFragment> fragments) {
+        double maxRight =
+                fragments.stream().mapToDouble(f -> f.bounds().right()).max().orElse(500.0);
+        return (float) maxRight * 1.10f;
+    }
+}

app/common/src/main/java/stirling/software/SPDF/pdf/parser/PdfIngester.java

@@ -0,0 +1,79 @@
+package stirling.software.SPDF.pdf.parser;
+
+import static stirling.software.SPDF.pdf.parser.PdfModels.*;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.common.PDRectangle;
+import org.springframework.stereotype.Service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Runs the per-page ingestion pipeline: {@link WordExtractingStripper} → {@link LineBuilder} →
+ * {@link TableParser}, producing a {@link PdfModels.ParsedPage} per page. The caller owns the
+ * {@link PDDocument} lifecycle.
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class PdfIngester {
+
+    private final LineBuilder lineBuilder;
+    private final TableParser tableParser;
+
+    public List<ParsedPage> parse(PDDocument document) throws IOException {
+        return parse(document, document.getNumberOfPages());
+    }
+
+    public List<ParsedPage> parse(PDDocument document, int maxPages) throws IOException {
+        int pageCount = Math.min(document.getNumberOfPages(), maxPages);
+        List<ParsedPage> pages = new ArrayList<>(pageCount);
+        long fragmentsMs = 0;
+        long tablesMs = 0;
+        long t0 = System.currentTimeMillis();
+
+        for (int p = 1; p <= pageCount; p++) {
+            long ft = System.currentTimeMillis();
+            List<TextFragment> fragments = extractFragments(document, p);
+            fragmentsMs += System.currentTimeMillis() - ft;
+
+            PDPage page = document.getPage(p - 1);
+            PDRectangle mediaBox = page.getMediaBox();
+            List<RawLine> lines = lineBuilder.build(fragments, p);
+            RawPage rawPage = new RawPage(p, mediaBox.getWidth(), mediaBox.getHeight(), lines);
+
+            long tt = System.currentTimeMillis();
+            List<TableFragment> tables = tableParser.parse(document, rawPage);
+            tablesMs += System.currentTimeMillis() - tt;
+
+            log.debug(
+                    "Page {}: {} fragments → {} lines, {} table(s)",
+                    p,
+                    fragments.size(),
+                    lines.size(),
+                    tables.size());
+            pages.add(new ParsedPage(p, mediaBox.getWidth(), mediaBox.getHeight(), tables, lines));
+        }
+
+        log.info(
+                "[timing] parse pages={} total={}ms fragments={}ms tables={}ms",
+                pageCount,
+                System.currentTimeMillis() - t0,
+                fragmentsMs,
+                tablesMs);
+        return pages;
+    }
+
+    private List<TextFragment> extractFragments(PDDocument document, int pageNumber)
+            throws IOException {
+        WordExtractingStripper stripper = new WordExtractingStripper(pageNumber);
+        stripper.getText(document);
+        return stripper.getFragments();
+    }
+}

app/common/src/main/java/stirling/software/SPDF/pdf/parser/PdfModels.java

@@ -0,0 +1,148 @@
+package stirling.software.SPDF.pdf.parser;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+
+/**
+ * All PDF parser model types and the table-parser contract in one place.
+ *
+ * <p>Import as {@code import static stirling.software.SPDF.pdf.parser.PdfModels.*;} to use all
+ * nested types without qualification.
+ */
+public final class PdfModels {
+
+    private PdfModels() {}
+
+    // ── Geometry ──────────────────────────────────────────────────────────────
+
+    public record Bounds(float x, float y, float width, float height) {
+
+        public float right() {
+            return x + width;
+        }
+
+        public float bottom() {
+            return y + height;
+        }
+
+        public static Bounds merge(Bounds a, Bounds b) {
+            float x = Math.min(a.x, b.x);
+            float y = Math.min(a.y, b.y);
+            return new Bounds(
+                    x, y, Math.max(a.right(), b.right()) - x, Math.max(a.bottom(), b.bottom()) - y);
+        }
+    }
+
+    // ── Text fragments and lines ──────────────────────────────────────────────
+
+    /**
+     * A contiguous run of text from a single PDF content-stream string operation. {@code baseline}
+     * is preserved separately from bounds for line-grouping — characters of different sizes on the
+     * same visual line share a baseline but differ in top Y.
+     */
+    public record TextFragment(
+            String fragmentId,
+            String text,
+            Bounds bounds,
+            float baseline,
+            float fontSize,
+            String fontName,
+            boolean bold) {}
+
+    public record RawLine(
+            String lineId, List<TextFragment> fragments, Bounds bounds, int pageNumber) {
+
+        public String text() {
+            if (fragments.isEmpty()) return "";
+            StringBuilder sb = new StringBuilder();
+            TextFragment prev = null;
+            for (TextFragment f : fragments) {
+                if (prev != null) {
+                    float gap = f.bounds().x() - prev.bounds().right();
+                    float avgCharWidth = prev.bounds().width() / Math.max(prev.text().length(), 1);
+                    if (gap > avgCharWidth * 0.5f) sb.append(' ');
+                }
+                sb.append(f.text());
+                prev = f;
+            }
+            return sb.toString();
+        }
+
+        public float dominantFontSize() {
+            return fragments.stream()
+                    .collect(Collectors.groupingBy(TextFragment::fontSize, Collectors.counting()))
+                    .entrySet()
+                    .stream()
+                    .max(Map.Entry.comparingByValue())
+                    .map(Map.Entry::getKey)
+                    .orElse(0f);
+        }
+
+        public boolean hasBold() {
+            return fragments.stream().anyMatch(TextFragment::bold);
+        }
+    }
+
+    public record RawPage(int pageNumber, float widthPt, float heightPt, List<RawLine> lines) {}
+
+    // ── Table model ───────────────────────────────────────────────────────────
+
+    /**
+     * A single cell within a {@link TableRow}. {@code colSpan} and {@code rowSpan} are always 1 in
+     * v1 — span detection is deferred but the fields keep the schema stable.
+     */
+    public record TableCell(int colIndex, String text, Bounds bounds, int colSpan, int rowSpan) {
+
+        public static TableCell of(int colIndex, String text, Bounds bounds) {
+            return new TableCell(colIndex, text, bounds, 1, 1);
+        }
+    }
+
+    public record TableRow(int rowIndex, List<TableCell> cells) {}
+
+    /**
+     * A table as it appears on a single page. {@code headers} is empty in v1 — all rows are in
+     * {@code rows}. {@code rawRows} preserves exact Tabula text output for diagnostics. {@code
+     * confidence} is a heuristic score in [0.0, 1.0]. {@code continuedFromPage} is null in v1.
+     */
+    public record TableFragment(
+            String tableId,
+            int pageNumber,
+            Bounds bounds,
+            List<TableRow> headers,
+            List<TableRow> rows,
+            List<List<String>> rawRows,
+            int columnCount,
+            float confidence,
+            List<String> warnings,
+            Integer continuedFromPage) {}
+
+    // ── Page output ───────────────────────────────────────────────────────────
+
+    public record ParsedPage(
+            int pageNumber,
+            float widthPt,
+            float heightPt,
+            List<TableFragment> tables,
+            List<RawLine> layoutLines) {}
+
+    // ── Parser contract ───────────────────────────────────────────────────────
+
+    /**
+     * Extracts tables from a single page of a PDF. The caller owns the document lifecycle;
+     * implementations must not close it.
+     */
+    public interface TableParser {
+
+        /**
+         * @param document open PDF; must not be closed by the implementation
+         * @param rawPage page metadata and lines for the page to process
+         * @return zero or more table fragments found on the page, never null
+         */
+        List<TableFragment> parse(PDDocument document, RawPage rawPage) throws IOException;
+    }
+}

app/common/src/main/java/stirling/software/SPDF/pdf/parser/TabulaTableParser.java

@@ -0,0 +1,256 @@
+package stirling.software.SPDF.pdf.parser;
+
+import static stirling.software.SPDF.pdf.parser.PdfModels.*;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.springframework.stereotype.Service;
+
+import lombok.extern.slf4j.Slf4j;
+
+import technology.tabula.ObjectExtractor;
+import technology.tabula.Page;
+import technology.tabula.RectangularTextContainer;
+import technology.tabula.Table;
+import technology.tabula.extractors.BasicExtractionAlgorithm;
+import technology.tabula.extractors.ExtractionAlgorithm;
+import technology.tabula.extractors.SpreadsheetExtractionAlgorithm;
+
+/**
+ * Primary {@link TableParser} implementation using Tabula's lattice-mode extraction.
+ *
+ * <h3>Algorithm</h3>
+ *
+ * Uses {@link SpreadsheetExtractionAlgorithm} (lattice mode), which detects tables from ruled lines
+ * (horizontal and vertical PDF path operators). This is reliable for tables with visible borders.
+ * Borderless or whitespace-delimited tables will not be detected — that requires stream mode, which
+ * is deferred to a later iteration.
+ *
+ * <h3>Coordinate system</h3>
+ *
+ * Tabula normalises page coordinates so that (0,0) is the top-left corner and Y increases downward,
+ * matching the {@link Bounds} convention used throughout this parser. No coordinate transformation
+ * is needed when mapping Tabula cell bounds to {@link Bounds}.
+ *
+ * <h3>Known limitations</h3>
+ *
+ * <ul>
+ *   <li>Borderless tables are not detected (use stream mode, deferred).
+ *   <li>Colspan and rowspan are not detected; all cells report colSpan=1, rowSpan=1.
+ *   <li>Header rows are not identified; all rows appear in {@code rows}, headers is empty.
+ *   <li>Cross-page table linking is not performed; each page is independent.
+ *   <li>Rotated tables (90°/270° pages) may produce incorrect bounds.
+ * </ul>
+ */
+@Service
+@Slf4j
+public class TabulaTableParser implements TableParser {
+
+    /** Lattice mode — reliable for tables with visible ruled borders. */
+    @Override
+    public List<TableFragment> parse(PDDocument document, RawPage rawPage) throws IOException {
+        return parseWithAlgorithm(
+                document, rawPage, new SpreadsheetExtractionAlgorithm(), "lattice");
+    }
+
+    /**
+     * Convenience overload for callers that only have a page number, not a full {@link RawPage}.
+     */
+    public List<TableFragment> parse(PDDocument document, int pageNumber) throws IOException {
+        return parse(document, new RawPage(pageNumber, 0f, 0f, List.of()));
+    }
+
+    /** Stream mode — whitespace-based column detection for borderless tables. */
+    public List<TableFragment> parseStream(PDDocument document, RawPage rawPage)
+            throws IOException {
+        return parseWithAlgorithm(document, rawPage, new BasicExtractionAlgorithm(), "stream");
+    }
+
+    private List<TableFragment> parseWithAlgorithm(
+            PDDocument document, RawPage rawPage, ExtractionAlgorithm algorithm, String modeName)
+            throws IOException {
+        int pageNumber = rawPage.pageNumber();
+
+        List<Table> tabulaTables;
+        try {
+            // Do NOT use try-with-resources: ObjectExtractor.close() closes the underlying
+            // PDDocument, which we don't own. The extractor holds no resources of its own.
+            ObjectExtractor extractor = new ObjectExtractor(document);
+            Page page = extractor.extract(pageNumber);
+            tabulaTables = new ArrayList<>(algorithm.extract(page));
+        } catch (Exception e) {
+            log.warn(
+                    "Tabula {} extraction failed on page {}: {}",
+                    modeName,
+                    pageNumber,
+                    e.getMessage());
+            return List.of();
+        }
+
+        if (tabulaTables.isEmpty()) {
+            log.debug("Page {}: no tables detected by Tabula ({})", pageNumber, modeName);
+            return List.of();
+        }
+
+        log.debug(
+                "Page {}: Tabula ({}) detected {} table(s)",
+                pageNumber,
+                modeName,
+                tabulaTables.size());
+
+        List<TableFragment> fragments = new ArrayList<>(tabulaTables.size());
+        for (int i = 0; i < tabulaTables.size(); i++) {
+            fragments.add(toFragment(tabulaTables.get(i), pageNumber, i));
+        }
+        return fragments;
+    }
+
+    // ── private helpers ──────────────────────────────────────────────────────────────────────────
+
+    private TableFragment toFragment(Table table, int pageNumber, int tableIndex) {
+        List<List<RectangularTextContainer>> tabulaRows = table.getRows();
+        List<String> warnings = new ArrayList<>();
+
+        List<List<String>> rawRows = buildRawRows(tabulaRows);
+        int colCount = inferColumnCount(rawRows, warnings);
+        List<TableRow> rows = buildRows(tabulaRows, colCount, warnings);
+        float confidence = computeConfidence(rawRows, colCount, warnings);
+        Bounds bounds = tableBounds(table);
+
+        String tableId = "tbl-p" + pageNumber + "-" + tableIndex;
+
+        if (!warnings.isEmpty()) {
+            log.warn("Page {}, table {}: {}", pageNumber, tableIndex, warnings);
+        }
+
+        return new TableFragment(
+                tableId,
+                pageNumber,
+                bounds,
+                List.of(), // headers: deferred to v2
+                rows,
+                rawRows,
+                colCount,
+                confidence,
+                Collections.unmodifiableList(warnings),
+                null); // continuedFromPage: deferred to v2
+    }
+
+    private List<List<String>> buildRawRows(List<List<RectangularTextContainer>> tabulaRows) {
+        List<List<String>> rawRows = new ArrayList<>(tabulaRows.size());
+        for (List<RectangularTextContainer> tabulaRow : tabulaRows) {
+            List<String> cells = new ArrayList<>(tabulaRow.size());
+            for (RectangularTextContainer cell : tabulaRow) {
+                cells.add(normaliseText(cell.getText()));
+            }
+            rawRows.add(Collections.unmodifiableList(cells));
+        }
+        return rawRows;
+    }
+
+    private List<TableRow> buildRows(
+            List<List<RectangularTextContainer>> tabulaRows, int colCount, List<String> warnings) {
+        List<TableRow> rows = new ArrayList<>(tabulaRows.size());
+        for (int rowIdx = 0; rowIdx < tabulaRows.size(); rowIdx++) {
+            List<RectangularTextContainer> tabulaRow = tabulaRows.get(rowIdx);
+            List<TableCell> cells = new ArrayList<>(tabulaRow.size());
+
+            for (int colIdx = 0; colIdx < tabulaRow.size(); colIdx++) {
+                RectangularTextContainer c = tabulaRow.get(colIdx);
+                Bounds cellBounds =
+                        new Bounds(
+                                (float) c.getX(),
+                                (float) c.getY(),
+                                (float) c.getWidth(),
+                                (float) c.getHeight());
+                cells.add(TableCell.of(colIdx, normaliseText(c.getText()), cellBounds));
+            }
+
+            if (tabulaRow.size() != colCount) {
+                warnings.add(
+                        "Row "
+                                + rowIdx
+                                + " has "
+                                + tabulaRow.size()
+                                + " cells; expected "
+                                + colCount);
+            }
+
+            rows.add(new TableRow(rowIdx, Collections.unmodifiableList(cells)));
+        }
+        return rows;
+    }
+
+    /**
+     * The canonical column count for a table is the size of the widest row. Tabula can produce
+     * uneven rows when a cell's ruling lines are partially missing.
+     */
+    private int inferColumnCount(List<List<String>> rawRows, List<String> warnings) {
+        if (rawRows.isEmpty()) return 0;
+        int max = rawRows.stream().mapToInt(List::size).max().orElse(0);
+        int mode =
+                rawRows.stream()
+                        .collect(
+                                java.util.stream.Collectors.groupingBy(
+                                        List::size, java.util.stream.Collectors.counting()))
+                        .entrySet()
+                        .stream()
+                        .max(java.util.Map.Entry.comparingByValue())
+                        .map(java.util.Map.Entry::getKey)
+                        .orElse(0);
+        if (max != mode) {
+            warnings.add("Inconsistent column count: modal=" + mode + " max=" + max);
+        }
+        return mode > 0 ? mode : max;
+    }
+
+    /**
+     * Heuristic confidence score in [0.0, 1.0].
+     *
+     * <ul>
+     *   <li>Starts at 1.0.
+     *   <li>-0.3 if only one column (single-column tables are usually not real tables).
+     *   <li>-0.1 per row with an inconsistent column count, capped at -0.4.
+     *   <li>-0.3 if the empty-cell ratio across all cells exceeds 80%.
+     * </ul>
+     */
+    private float computeConfidence(
+            List<List<String>> rawRows, int colCount, List<String> warnings) {
+        if (rawRows.isEmpty() || colCount == 0) return 0f;
+
+        float score = 1.0f;
+
+        if (colCount == 1) score -= 0.3f;
+
+        long inconsistentRows = rawRows.stream().filter(r -> r.size() != colCount).count();
+        score -= Math.min(inconsistentRows * 0.1f, 0.4f);
+
+        long totalCells = rawRows.stream().mapToLong(List::size).sum();
+        long emptyCells =
+                rawRows.stream().flatMap(Collection::stream).filter(String::isBlank).count();
+        if (totalCells > 0 && (float) emptyCells / totalCells > 0.8f) {
+            score -= 0.3f;
+        }
+
+        return Math.max(0f, Math.min(1f, score));
+    }
+
+    private Bounds tableBounds(Table table) {
+        return new Bounds(
+                (float) table.getX(),
+                (float) table.getY(),
+                (float) table.getWidth(),
+                (float) table.getHeight());
+    }
+
+    private String normaliseText(String raw) {
+        if (raw == null) return "";
+        // Tabula wraps multi-line cell content with \r\n — collapse to a single space.
+        return raw.replace("\r\n", " ").replace("\n", " ").replace("\r", " ").trim();
+    }
+}

app/common/src/main/java/stirling/software/SPDF/pdf/parser/WordExtractingStripper.java

@@ -0,0 +1,113 @@
+package stirling.software.SPDF.pdf.parser;
+
+import static stirling.software.SPDF.pdf.parser.PdfModels.*;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.font.PDFont;
+import org.apache.pdfbox.text.PDFTextStripper;
+import org.apache.pdfbox.text.TextPosition;
+
+/**
+ * Extends {@link PDFTextStripper} to capture per-fragment geometry and font metadata.
+ *
+ * <p>Overrides {@link #writeString} to split each content-stream string into word-level {@link
+ * TextFragment}s with bounding boxes, baseline, font name, and bold flag. Coordinates are in
+ * PDFTextStripper space: (0,0) top-left, Y increases downward, {@code getY()} is the baseline.
+ */
+class WordExtractingStripper extends PDFTextStripper {
+
+    private final int targetPage;
+    private final List<TextFragment> fragments = new ArrayList<>();
+    private int fragmentIndex = 0;
+
+    WordExtractingStripper(int pageNumber) throws IOException {
+        this.targetPage = pageNumber;
+        setStartPage(pageNumber);
+        setEndPage(pageNumber);
+        setSortByPosition(true);
+    }
+
+    @Override
+    protected void startPage(PDPage page) throws IOException {
+        super.startPage(page);
+        fragments.clear();
+        fragmentIndex = 0;
+    }
+
+    @Override
+    protected void writeString(String text, List<TextPosition> textPositions) throws IOException {
+        if (text == null || text.isBlank()) return;
+
+        // Fast path: no whitespace → emit one fragment (most financial PDFs have each
+        // number as its own string operation, so this is the common case).
+        if (text.indexOf(' ') < 0) {
+            emitFragment(text, textPositions);
+            return;
+        }
+
+        // Per-word splitting requires 1:1 text-char to TextPosition correspondence.
+        // Fall back to one fragment when sizes differ (ligatures, encoding edge cases).
+        if (textPositions.size() != text.length()) {
+            emitFragment(text, textPositions);
+            return;
+        }
+
+        // Emit one TextFragment per whitespace-delimited word with accurate per-word bounds.
+        int start = 0;
+        for (int i = 0; i <= text.length(); i++) {
+            if (i == text.length() || text.charAt(i) == ' ') {
+                if (start < i) {
+                    emitFragment(text.substring(start, i), textPositions.subList(start, i));
+                }
+                start = i + 1;
+            }
+        }
+    }
+
+    private void emitFragment(String text, List<TextPosition> positions) {
+        if (positions.isEmpty()) return;
+
+        float minX = Float.MAX_VALUE;
+        float minY = Float.MAX_VALUE;
+        float maxRight = -Float.MAX_VALUE;
+        float maxBaseline = -Float.MAX_VALUE;
+        TextPosition first = null;
+
+        for (TextPosition tp : positions) {
+            if (tp == null) continue;
+            if (first == null) first = tp;
+
+            float x = tp.getX();
+            // getY() is the baseline; top of character = getY() - getHeight().
+            float top = tp.getY() - tp.getHeight();
+            float right = x + tp.getWidth();
+            float baseline = tp.getY();
+
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, top);
+            maxRight = Math.max(maxRight, right);
+            maxBaseline = Math.max(maxBaseline, baseline);
+        }
+
+        if (first == null) return;
+
+        PDFont font = first.getFont();
+        String fontName = font != null ? font.getName() : "";
+        boolean bold = fontName != null && fontName.toLowerCase().contains("bold");
+        // getHeight() gives the rendered glyph height, which is the most reliable visual size.
+        float fontSize = first.getHeight();
+
+        Bounds bounds = new Bounds(minX, minY, maxRight - minX, maxBaseline - minY);
+        String id = "tf-p" + targetPage + "-" + fragmentIndex++;
+        fragments.add(new TextFragment(id, text, bounds, maxBaseline, fontSize, fontName, bold));
+    }
+
+    List<TextFragment> getFragments() {
+        return Collections.unmodifiableList(fragments);
+    }
+}

app/common/src/main/java/stirling/software/common/annotations/AutoJobPostMapping.java

@@ -75,8 +75,8 @@ public @interface AutoJobPostMapping {
     boolean queueable() default false;
 
     /**
-     * Relative resource weight (1–100) used by the scheduler to prioritise / throttle jobs. Values
-     * below 1 are clamped to 1, values above 100 to 100.
+     * Relative resource weight (1-100). See {@link
+     * stirling.software.common.enumeration.ResourceWeight} for the standard tiers.
      */
-    int resourceWeight() default 50;
+    int resourceWeight() default 1;
 }

app/common/src/main/java/stirling/software/common/enumeration/ResourceWeight.java

@@ -0,0 +1,22 @@
+package stirling.software.common.enumeration;
+
+/**
+ * Standard resource-weight tiers for {@link
+ * stirling.software.common.annotations.AutoJobPostMapping#resourceWeight()}.
+ */
+public final class ResourceWeight {
+
+    /** Lightweight: rotate, page numbers, extract pages, permissions, etc. */
+    public static final int SMALL_WEIGHT = 1;
+
+    /** Medium: merge, split, multi-tool batch. */
+    public static final int MEDIUM_WEIGHT = 3;
+
+    /** Heavy: compress, OCR (small), conversions, raster. */
+    public static final int LARGE_WEIGHT = 5;
+
+    /** Extra heavy: OCR on large files, full-document re-render, AI-assisted edits. */
+    public static final int XLARGE_WEIGHT = 10;
+
+    private ResourceWeight() {}
+}

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

@@ -97,7 +97,14 @@ public class ApplicationProperties {
         EncodedResource encodedResource = new EncodedResource(resource);
         PropertySource<?> propertySource =
                 new YamlPropertySourceFactory().createPropertySource(null, encodedResource);
-        environment.getPropertySources().addFirst(propertySource);
+
+        boolean saasActive = Arrays.asList(environment.getActiveProfiles()).contains("saas");
+        if (saasActive) {
+            // Saas-pinned values in application-saas.properties must beat settings.yml.
+            environment.getPropertySources().addLast(propertySource);
+        } else {
+            environment.getPropertySources().addFirst(propertySource);
+        }
 
         log.debug("Loaded properties: {}", propertySource.getSource());
 

app/common/src/main/java/stirling/software/common/model/api/PDFFile.java

@@ -14,7 +14,6 @@ import lombok.NoArgsConstructor;
 @Data
 @NoArgsConstructor
 @EqualsAndHashCode
-@Schema(description = "PDF file input - either upload a file or provide a server-side file ID")
 public class PDFFile {
 
     @Schema(

app/common/src/main/java/stirling/software/common/model/enumeration/InvitationStatus.java

@@ -0,0 +1,26 @@
+package stirling.software.common.model.enumeration;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+/** Team invitation status */
+@Getter
+@RequiredArgsConstructor
+public enum InvitationStatus {
+    PENDING("PENDING"),
+    ACCEPTED("ACCEPTED"),
+    REJECTED("REJECTED"),
+    CANCELLED("CANCELLED"),
+    EXPIRED("EXPIRED");
+
+    private final String statusName;
+
+    public static InvitationStatus fromString(String statusName) {
+        for (InvitationStatus status : InvitationStatus.values()) {
+            if (status.getStatusName().equalsIgnoreCase(statusName)) {
+                return status;
+            }
+        }
+        throw new IllegalArgumentException("No InvitationStatus defined for name: " + statusName);
+    }
+}

app/common/src/main/java/stirling/software/common/model/enumeration/Role.java

@@ -16,6 +16,9 @@ public enum Role {
     // Unlimited access
     USER("ROLE_USER", Integer.MAX_VALUE, Integer.MAX_VALUE, "adminUserSettings.user"),
 
+    // Paid tier; set by Stripe webhooks under saas mode.
+    PRO_USER("ROLE_PRO_USER", Integer.MAX_VALUE, Integer.MAX_VALUE, "adminUserSettings.proUser"),
+
     // 40 API calls Per Day, 40 web calls
     LIMITED_API_USER("ROLE_LIMITED_API_USER", 40, 40, "adminUserSettings.apiUser"),
 

app/common/src/main/java/stirling/software/common/model/enumeration/TeamRole.java

@@ -0,0 +1,26 @@
+package stirling.software.common.model.enumeration;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+/**
+ * Team membership roles LEADER: Can invite/remove members, manage settings, view usage, manage
+ * billing MEMBER: Regular team member with standard access
+ */
+@Getter
+@RequiredArgsConstructor
+public enum TeamRole {
+    LEADER("LEADER"),
+    MEMBER("MEMBER");
+
+    private final String roleName;
+
+    public static TeamRole fromString(String roleName) {
+        for (TeamRole role : TeamRole.values()) {
+            if (role.getRoleName().equalsIgnoreCase(roleName)) {
+                return role;
+            }
+        }
+        throw new IllegalArgumentException("No TeamRole defined for name: " + roleName);
+    }
+}

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

@@ -2289,6 +2289,85 @@ public class FormUtils {
         acroForm.getFields().add(field);
     }
 
+    /** Drops AcroForm fields whose widgets are no longer on any page of {@code document}. */
+    public void pruneOrphanedFormFields(PDDocument document) {
+        if (document == null) {
+            return;
+        }
+        PDDocumentCatalog catalog = document.getDocumentCatalog();
+        if (catalog == null) {
+            return;
+        }
+        PDAcroForm form = catalog.getAcroForm(null);
+        if (form == null) {
+            return;
+        }
+        List<PDField> fields = form.getFields();
+        if (fields.isEmpty()) {
+            return;
+        }
+
+        Set<COSDictionary> liveWidgets = collectLiveWidgetDictionaries(document);
+        List<PDField> kept = pruneFieldList(fields, liveWidgets);
+        if (kept.isEmpty()) {
+            catalog.setAcroForm(null);
+        } else if (kept.size() != fields.size()) {
+            form.setFields(kept);
+        }
+    }
+
+    private Set<COSDictionary> collectLiveWidgetDictionaries(PDDocument document) {
+        Set<COSDictionary> live = new HashSet<>();
+        int pageCount = document.getNumberOfPages();
+        for (int i = 0; i < pageCount; i++) {
+            try {
+                for (PDAnnotation annotation : document.getPage(i).getAnnotations()) {
+                    if (annotation instanceof PDAnnotationWidget) {
+                        live.add(annotation.getCOSObject());
+                    }
+                }
+            } catch (IOException e) {
+                log.debug("Failed reading page {} annotations: {}", i, e.getMessage());
+            }
+        }
+        return live;
+    }
+
+    private List<PDField> pruneFieldList(List<PDField> fields, Set<COSDictionary> liveWidgets) {
+        List<PDField> kept = new ArrayList<>(fields.size());
+        for (PDField field : fields) {
+            if (field instanceof PDNonTerminalField nonTerminal) {
+                List<PDField> children = nonTerminal.getChildren();
+                List<PDField> remaining = pruneFieldList(children, liveWidgets);
+                if (remaining.isEmpty()) {
+                    continue;
+                }
+                if (remaining.size() != children.size()) {
+                    nonTerminal.setChildren(remaining);
+                }
+                kept.add(nonTerminal);
+            } else if (field instanceof PDTerminalField terminal) {
+                List<PDAnnotationWidget> widgets = terminal.getWidgets();
+                List<PDAnnotationWidget> liveOnes = new ArrayList<>(widgets.size());
+                for (PDAnnotationWidget widget : widgets) {
+                    if (liveWidgets.contains(widget.getCOSObject())) {
+                        liveOnes.add(widget);
+                    }
+                }
+                if (liveOnes.isEmpty()) {
+                    continue;
+                }
+                if (liveOnes.size() != widgets.size()) {
+                    terminal.setWidgets(liveOnes);
+                }
+                kept.add(terminal);
+            } else {
+                kept.add(field);
+            }
+        }
+        return kept;
+    }
+
     // Delegation methods to GeneralFormCopyUtils for form field transformation
     public boolean hasAnyRotatedPage(PDDocument document) {
         return stirling.software.common.util.GeneralFormCopyUtils.hasAnyRotatedPage(document);

app/common/src/test/java/stirling/software/SPDF/pdf/parser/LineAlignmentTableParserTest.java

@@ -0,0 +1,153 @@
+package stirling.software.SPDF.pdf.parser;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static stirling.software.SPDF.pdf.parser.PdfModels.*;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for {@link LineAlignmentTableParser}, focused on the coincident-line merge logic and
+ * column-grid construction.
+ */
+class LineAlignmentTableParserTest {
+
+    private final LineAlignmentTableParser parser = new LineAlignmentTableParser();
+
+    // ── mergeCoincidentLines ─────────────────────────────────────────────────────────────────────
+
+    @Test
+    void mergeCoincidentLines_singleLine_unchanged() {
+        var lines = List.of(tokenized(rawLine(10f, 100f, "Revenue")));
+        assertThat(parser.mergeCoincidentLines(lines)).hasSize(1);
+    }
+
+    @Test
+    void mergeCoincidentLines_distinctYLines_unchanged() {
+        // Two lines at different y positions — must NOT be merged.
+        var lines =
+                List.of(
+                        tokenized(rawLine(10f, 100f, "Revenue")),
+                        tokenized(rawLine(10f, 115f, "Cost")));
+        assertThat(parser.mergeCoincidentLines(lines)).hasSize(2);
+    }
+
+    @Test
+    void mergeCoincidentLines_sameY_merged() {
+        // Simulates a financial-table row split by LineBuilder at the column gap:
+        //   label fragment at x=72  → "Revenue"
+        //   value fragment at x=350 → "1,234"
+        // Both have y=100. After merge they should form one TokenizedLine.
+        var label = rawLine(72f, 100f, "Revenue");
+        var value = rawLine(350f, 100f, "1,234");
+
+        var merged = parser.mergeCoincidentLines(List.of(tokenized(label), tokenized(value)));
+
+        assertThat(merged).hasSize(1);
+        // The merged line should contain tokens from both halves.
+        var tokens = merged.get(0).all();
+        assertThat(tokens.stream().map(t -> t.text()).toList())
+                .containsExactlyInAnyOrder("Revenue", "1,234");
+    }
+
+    @Test
+    void mergeCoincidentLines_sameY_mergedLineHasCorrectBounds() {
+        var label = rawLine(72f, 100f, "Revenue"); // 7 chars × 6pt = 42pt wide → right = 114
+        var value = rawLine(350f, 100f, "1,234"); // 5 chars × 6pt = 30pt wide → right = 380
+
+        var merged = parser.mergeCoincidentLines(List.of(tokenized(label), tokenized(value)));
+
+        var bounds = merged.get(0).line().bounds();
+        assertThat(bounds.x()).isEqualTo(72f);
+        assertThat(bounds.right()).isEqualTo(380f);
+    }
+
+    @Test
+    void mergeCoincidentLines_withinTolerance_merged() {
+        // Lines 1.5pt apart (within ROW_MERGE_TOLERANCE_PT = 2pt) should merge.
+        var a = rawLine(10f, 100.0f, "Alpha");
+        var b = rawLine(200f, 101.5f, "99");
+
+        var merged = parser.mergeCoincidentLines(List.of(tokenized(a), tokenized(b)));
+        assertThat(merged).hasSize(1);
+    }
+
+    @Test
+    void mergeCoincidentLines_beyondTolerance_notMerged() {
+        // Lines 3pt apart (beyond ROW_MERGE_TOLERANCE_PT = 2pt) should NOT merge.
+        var a = rawLine(10f, 100.0f, "Alpha");
+        var b = rawLine(200f, 103.0f, "99");
+
+        var merged = parser.mergeCoincidentLines(List.of(tokenized(a), tokenized(b)));
+        assertThat(merged).hasSize(2);
+    }
+
+    @Test
+    void mergeCoincidentLines_threeCoincident_allMerged() {
+        // Three fragments at the same y (e.g. wide financial table with two value columns).
+        var a = rawLine(72f, 100f, "Revenue");
+        var b = rawLine(300f, 100f, "1,234");
+        var c = rawLine(400f, 100f, "5,678");
+
+        var merged = parser.mergeCoincidentLines(List.of(tokenized(a), tokenized(b), tokenized(c)));
+        assertThat(merged).hasSize(1);
+        assertThat(merged.get(0).all()).hasSize(3);
+    }
+
+    @Test
+    void mergeCoincidentLines_coincidentPairFollowedByDistinctLine_twoGroups() {
+        var a = rawLine(72f, 100f, "Revenue");
+        var b = rawLine(350f, 100f, "1,234"); // same y as a → merges with a
+        var c = rawLine(10f, 115f, "Expenses"); // different y → stays separate
+
+        var merged = parser.mergeCoincidentLines(List.of(tokenized(a), tokenized(b), tokenized(c)));
+        assertThat(merged).hasSize(2);
+    }
+
+    @Test
+    void mergeCoincidentLines_numericAnchorStatus_correctAfterMerge() {
+        // After merging, the combined line should be an anchor (≥2 numeric tokens).
+        // "Revenue" alone → not an anchor. "1,234  567" alone → anchor.
+        // Merged → anchor with at least 2 numerics.
+        var label = rawLine(72f, 100f, "Revenue");
+        var values = rawLineMultiWord(350f, 100f, "1,234", 30f, "567", 30f);
+
+        var merged = parser.mergeCoincidentLines(List.of(tokenized(label), tokenized(values)));
+
+        assertThat(merged).hasSize(1);
+        assertThat(merged.get(0).isAnchor()).isTrue();
+    }
+
+    // ── helpers ──────────────────────────────────────────────────────────────────────────────────
+
+    /** Creates a RawLine with a single TextFragment of the given text at the given position. */
+    private static RawLine rawLine(float x, float y, String text) {
+        float width = text.length() * 6f; // ~6pt per char — rough but consistent
+        float height = 12f;
+        Bounds bounds = new Bounds(x, y, width, height);
+        TextFragment fragment =
+                new TextFragment("tf-test", text, bounds, y + height, 11f, "Helvetica", false);
+        return new RawLine("ln-test", List.of(fragment), bounds, 1);
+    }
+
+    /**
+     * Creates a RawLine with two TextFragments representing two words separated by a small gap.
+     * Used to simulate a values-only line with multiple numeric tokens.
+     */
+    private static RawLine rawLineMultiWord(
+            float x, float y, String word1, float w1, String word2, float w2) {
+        float height = 12f;
+        Bounds b1 = new Bounds(x, y, w1, height);
+        Bounds b2 = new Bounds(x + w1 + 5f, y, w2, height);
+        TextFragment f1 = new TextFragment("tf-1", word1, b1, y + height, 11f, "Helvetica", false);
+        TextFragment f2 = new TextFragment("tf-2", word2, b2, y + height, 11f, "Helvetica", false);
+        Bounds lineBounds = new Bounds(x, y, x + w1 + 5f + w2 - x, height);
+        return new RawLine("ln-test", List.of(f1, f2), lineBounds, 1);
+    }
+
+    /** Tokenises a RawLine via the parser's own tokenise logic (package-private access). */
+    private LineAlignmentTableParser.TokenizedLine tokenized(RawLine line) {
+        return parser.tokenize(line);
+    }
+}

app/common/src/test/java/stirling/software/common/architecture/ArchitectureTest.java

@@ -0,0 +1,59 @@
+package stirling.software.common.architecture;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+import org.junit.jupiter.api.Test;
+
+import com.tngtech.archunit.core.domain.JavaClasses;
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.lang.ArchRule;
+
+/**
+ * Module dependency-direction guardrails. Allowed direction: {@code saas → proprietary → common}
+ * and {@code stirling-pdf → proprietary → common}.
+ */
+class ArchitectureTest {
+
+    private static final JavaClasses commonClasses =
+            new ClassFileImporter()
+                    .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_JARS)
+                    .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS)
+                    .importPackages("stirling.software.common");
+
+    @Test
+    void commonDoesNotDependOnCore() {
+        ArchRule rule =
+                noClasses()
+                        .that()
+                        .resideInAPackage("stirling.software.common..")
+                        .should()
+                        .dependOnClassesThat()
+                        .resideInAPackage("stirling.software.SPDF..");
+        rule.check(commonClasses);
+    }
+
+    @Test
+    void commonDoesNotDependOnProprietary() {
+        ArchRule rule =
+                noClasses()
+                        .that()
+                        .resideInAPackage("stirling.software.common..")
+                        .should()
+                        .dependOnClassesThat()
+                        .resideInAPackage("stirling.software.proprietary..");
+        rule.check(commonClasses);
+    }
+
+    @Test
+    void commonDoesNotDependOnSaas() {
+        ArchRule rule =
+                noClasses()
+                        .that()
+                        .resideInAPackage("stirling.software.common..")
+                        .should()
+                        .dependOnClassesThat()
+                        .resideInAPackage("stirling.software.saas..");
+        rule.check(commonClasses);
+    }
+}

app/common/src/test/java/stirling/software/common/jpdfium/JPDFiumSmokeTest.java

@@ -0,0 +1,32 @@
+package stirling.software.common.jpdfium;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import stirling.software.jpdfium.PdfDocument;
+
+class JPDFiumSmokeTest {
+
+    @Test
+    void opensExamplePdfAndReadsPageCount(@TempDir Path tmp) throws IOException {
+        Path pdf = tmp.resolve("example.pdf");
+        try (InputStream in = getClass().getResourceAsStream("/example.pdf")) {
+            assertNotNull(in, "example.pdf must exist under src/test/resources");
+            Files.copy(in, pdf);
+        }
+
+        try (PdfDocument doc = PdfDocument.open(pdf)) {
+            assertTrue(
+                    doc.pageCount() >= 1,
+                    "PdfDocument should report at least one page for example.pdf");
+        }
+    }
+}

app/common/src/test/java/stirling/software/common/util/FormUtilsPruneOrphanedFieldsTest.java

@@ -0,0 +1,229 @@
+package stirling.software.common.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.pdfbox.Loader;
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.PDResources;
+import org.apache.pdfbox.pdmodel.common.PDRectangle;
+import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotationWidget;
+import org.apache.pdfbox.pdmodel.interactive.form.PDAcroForm;
+import org.apache.pdfbox.pdmodel.interactive.form.PDField;
+import org.apache.pdfbox.pdmodel.interactive.form.PDNonTerminalField;
+import org.apache.pdfbox.pdmodel.interactive.form.PDTextField;
+import org.junit.jupiter.api.Test;
+
+class FormUtilsPruneOrphanedFieldsTest {
+
+    @Test
+    void noAcroFormIsNoOp() throws IOException {
+        try (PDDocument document = new PDDocument()) {
+            document.addPage(new PDPage(PDRectangle.A4));
+            FormUtils.pruneOrphanedFormFields(document);
+            assertNull(document.getDocumentCatalog().getAcroForm(null));
+        }
+    }
+
+    @Test
+    void dropsFieldsWhoseWidgetsAreAllOnRemovedPages() throws IOException {
+        byte[] pdfBytes = buildPdfWithFieldPerPage(3);
+
+        try (PDDocument document = Loader.loadPDF(pdfBytes)) {
+            document.removePage(2);
+            document.removePage(0);
+
+            FormUtils.pruneOrphanedFormFields(document);
+
+            PDAcroForm form = document.getDocumentCatalog().getAcroForm(null);
+            assertNotNull(form);
+            List<String> remainingNames = new ArrayList<>();
+            for (PDField field : form.getFields()) {
+                remainingNames.add(field.getPartialName());
+            }
+            assertEquals(List.of("field_1"), remainingNames);
+        }
+    }
+
+    @Test
+    void dropsAcroFormEntirelyWhenNoFieldsSurvive() throws IOException {
+        byte[] pdfBytes = buildPdfWithFieldPerPage(2);
+
+        try (PDDocument document = Loader.loadPDF(pdfBytes)) {
+            document.removePage(1);
+            document.removePage(0);
+            document.addPage(new PDPage(PDRectangle.A4));
+
+            FormUtils.pruneOrphanedFormFields(document);
+
+            assertNull(document.getDocumentCatalog().getAcroForm(null));
+        }
+    }
+
+    @Test
+    void keepsLiveWidgetsAndDropsOrphanWidgetsFromMultiWidgetField() throws IOException {
+        byte[] pdfBytes = buildPdfWithMultiWidgetField();
+
+        try (PDDocument document = Loader.loadPDF(pdfBytes)) {
+            document.removePage(0);
+
+            FormUtils.pruneOrphanedFormFields(document);
+
+            PDAcroForm form = document.getDocumentCatalog().getAcroForm(null);
+            assertNotNull(form);
+            assertEquals(1, form.getFields().size());
+            PDField field = form.getFields().get(0);
+            assertEquals("multi", field.getPartialName());
+            assertEquals(2, field.getWidgets().size(), "two widgets remain after one is dropped");
+        }
+    }
+
+    @Test
+    void survivesRoundTripWithoutOrphanPagesInOutput() throws IOException {
+        byte[] pdfBytes = buildPdfWithFieldPerPage(3);
+
+        byte[] writtenBytes;
+        try (PDDocument document = Loader.loadPDF(pdfBytes)) {
+            document.removePage(2);
+            document.removePage(1);
+            FormUtils.pruneOrphanedFormFields(document);
+            try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
+                document.save(out);
+                writtenBytes = out.toByteArray();
+            }
+        }
+
+        try (PDDocument reloaded = Loader.loadPDF(writtenBytes)) {
+            assertEquals(1, reloaded.getNumberOfPages());
+            PDAcroForm form = reloaded.getDocumentCatalog().getAcroForm(null);
+            assertNotNull(form);
+            assertEquals(1, form.getFields().size());
+            assertEquals("field_0", form.getFields().get(0).getPartialName());
+        }
+    }
+
+    @Test
+    void prunesNestedNonTerminalFields() throws IOException {
+        byte[] pdfBytes = buildPdfWithNestedFields();
+
+        try (PDDocument document = Loader.loadPDF(pdfBytes)) {
+            document.removePage(1);
+
+            FormUtils.pruneOrphanedFormFields(document);
+
+            PDAcroForm form = document.getDocumentCatalog().getAcroForm(null);
+            assertNotNull(form);
+            assertEquals(1, form.getFields().size());
+            PDField group = form.getFields().get(0);
+            assertEquals("group", group.getPartialName());
+            assertTrue(group instanceof PDNonTerminalField);
+            PDNonTerminalField nonTerminal = (PDNonTerminalField) group;
+            assertEquals(1, nonTerminal.getChildren().size());
+            assertEquals("kept", nonTerminal.getChildren().get(0).getPartialName());
+        }
+    }
+
+    private static byte[] buildPdfWithFieldPerPage(int pageCount) throws IOException {
+        try (PDDocument document = new PDDocument()) {
+            PDAcroForm acroForm = new PDAcroForm(document);
+            acroForm.setDefaultResources(new PDResources());
+            document.getDocumentCatalog().setAcroForm(acroForm);
+
+            for (int i = 0; i < pageCount; i++) {
+                PDPage page = new PDPage(PDRectangle.A4);
+                document.addPage(page);
+
+                PDTextField field = new PDTextField(acroForm);
+                field.setPartialName("field_" + i);
+                PDAnnotationWidget widget = new PDAnnotationWidget();
+                widget.setRectangle(new PDRectangle(50, 50, 100, 20));
+                widget.setPage(page);
+                field.setWidgets(List.of(widget));
+                acroForm.getFields().add(field);
+                page.getAnnotations().add(widget);
+            }
+
+            try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
+                document.save(out);
+                return out.toByteArray();
+            }
+        }
+    }
+
+    private static byte[] buildPdfWithMultiWidgetField() throws IOException {
+        try (PDDocument document = new PDDocument()) {
+            PDAcroForm acroForm = new PDAcroForm(document);
+            acroForm.setDefaultResources(new PDResources());
+            document.getDocumentCatalog().setAcroForm(acroForm);
+
+            List<PDAnnotationWidget> widgets = new ArrayList<>();
+            for (int i = 0; i < 3; i++) {
+                PDPage page = new PDPage(PDRectangle.A4);
+                document.addPage(page);
+                PDAnnotationWidget widget = new PDAnnotationWidget();
+                widget.setRectangle(new PDRectangle(50, 50, 100, 20));
+                widget.setPage(page);
+                page.getAnnotations().add(widget);
+                widgets.add(widget);
+            }
+
+            PDTextField field = new PDTextField(acroForm);
+            field.setPartialName("multi");
+            field.setWidgets(widgets);
+            acroForm.getFields().add(field);
+
+            try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
+                document.save(out);
+                return out.toByteArray();
+            }
+        }
+    }
+
+    private static byte[] buildPdfWithNestedFields() throws IOException {
+        try (PDDocument document = new PDDocument()) {
+            PDAcroForm acroForm = new PDAcroForm(document);
+            acroForm.setDefaultResources(new PDResources());
+            document.getDocumentCatalog().setAcroForm(acroForm);
+
+            PDPage pageA = new PDPage(PDRectangle.A4);
+            PDPage pageB = new PDPage(PDRectangle.A4);
+            document.addPage(pageA);
+            document.addPage(pageB);
+
+            PDNonTerminalField group = new PDNonTerminalField(acroForm);
+            group.setPartialName("group");
+
+            PDTextField kept = new PDTextField(acroForm);
+            kept.setPartialName("kept");
+            PDAnnotationWidget keptWidget = new PDAnnotationWidget();
+            keptWidget.setRectangle(new PDRectangle(50, 50, 100, 20));
+            keptWidget.setPage(pageA);
+            kept.setWidgets(List.of(keptWidget));
+            pageA.getAnnotations().add(keptWidget);
+
+            PDTextField dropped = new PDTextField(acroForm);
+            dropped.setPartialName("dropped");
+            PDAnnotationWidget droppedWidget = new PDAnnotationWidget();
+            droppedWidget.setRectangle(new PDRectangle(50, 100, 100, 20));
+            droppedWidget.setPage(pageB);
+            dropped.setWidgets(List.of(droppedWidget));
+            pageB.getAnnotations().add(droppedWidget);
+
+            group.setChildren(List.of(kept, dropped));
+            acroForm.getFields().add(group);
+
+            try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
+                document.save(out);
+                return out.toByteArray();
+            }
+        }
+    }
+}

app/core/build.gradle

@@ -39,12 +39,14 @@ spotless {
 }
 
 dependencies {
-    if (System.getenv('DISABLE_ADDITIONAL_FEATURES') != 'true'
-        || (project.hasProperty('DISABLE_ADDITIONAL_FEATURES')
-        && System.getProperty('DISABLE_ADDITIONAL_FEATURES') != 'true')) {
+    if (!gradle.ext.disableAdditional) {
         implementation project(':proprietary')
     }
 
+    if (gradle.ext.enableSaas) {
+        implementation project(':saas')
+    }
+
     implementation project(':common')
     implementation 'org.springframework.boot:spring-boot-starter-jetty'
     implementation 'org.eclipse.jetty.http2:jetty-http2-server'
@@ -87,12 +89,6 @@ dependencies {
     implementation 'com.sun.xml.bind:jaxb-core:4.0.7'
     implementation 'org.apache.poi:poi-ooxml:5.5.1'
 
-    // https://mvnrepository.com/artifact/technology.tabula/tabula
-    implementation ('technology.tabula:tabula:1.0.5')  {
-        exclude group: 'org.slf4j', module: 'slf4j-simple'
-        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)
     implementation 'com.google.code.gson:gson:2.13.2'
     implementation 'org.apache.pdfbox:jbig2-imageio:3.0.4'
@@ -140,6 +136,17 @@ sourceSets {
 
 }
 
+// Forward bench-related system properties through to the test JVM so
+// `-Dsplit.bench=true` (and similar) flags reach Boolean.getBoolean().
+tasks.named('test', Test) {
+    ['split.bench', 'split.bench.pages', 'split.bench.chunk',
+     'split.bench.imgW', 'split.bench.imgH'].each { key ->
+        def v = System.getProperty(key)
+        if (v != null) systemProperty(key, v)
+    }
+    maxHeapSize = '2g'
+}
+
 
 // Disable regular jar
 jar {
@@ -166,7 +173,8 @@ bootJar {
     manifest {
         attributes(
             'Implementation-Title': 'Stirling-PDF',
-            'Implementation-Version': project.version
+            'Implementation-Version': project.version,
+            'Enable-Native-Access': 'ALL-UNNAMED'
         )
     }
 }
@@ -179,6 +187,23 @@ springBoot {
 // Frontend build tasks - only enabled with -PbuildWithFrontend=true
 def buildWithFrontend = project.hasProperty('buildWithFrontend') && project.property('buildWithFrontend') == 'true'
 def buildPrototypes = project.hasProperty('prototypesMode') && project.property('prototypesMode') == 'true'
+
+// Vite mode: -PprototypesMode > -PfrontendMode > enableSaas > disableAdditional > proprietary.
+def frontendModeOverride = project.findProperty('frontendMode')?.toString()?.toLowerCase()
+def frontendMode
+if (buildPrototypes) {
+    frontendMode = 'prototypes'
+} else if (frontendModeOverride) {
+    frontendMode = frontendModeOverride
+} else if (gradle.ext.enableSaas) {
+    frontendMode = 'saas'
+} else if (gradle.ext.disableAdditional) {
+    frontendMode = 'core'
+} else {
+    frontendMode = 'proprietary'
+}
+def frontendBuildTask = "frontend:build:${frontendMode}"
+
 def frontendDir = file('../../frontend')
 def frontendDistDir = file('../../frontend/dist')
 def resourcesStaticDir = file('src/main/resources/static')
@@ -247,7 +272,7 @@ tasks.register('npmBuild', Exec) {
     group = 'frontend'
     description = 'Build frontend application'
     workingDir file('../..')
-    commandLine = buildPrototypes ? ['task', 'frontend:build:prototypes'] : ['task', 'frontend:build']
+    commandLine = ['task', frontendBuildTask]
     inputs.dir(new File(frontendDir, 'src'))
     inputs.dir(new File(frontendDir, 'public'))
     inputs.file(new File(frontendDir, 'package.json'))
@@ -262,7 +287,7 @@ tasks.register('npmBuild', Exec) {
     environment 'VITE_API_BASE_URL', '/'
 
     doFirst {
-        println "Building frontend application for production (VITE_API_BASE_URL=/)"
+        println "Building frontend application for production (mode=${frontendMode}, VITE_API_BASE_URL=/)"
     }
 }
 
@@ -271,6 +296,7 @@ tasks.register('copyFrontendAssets', Copy) {
     group = 'frontend'
     description = 'Copy frontend build to static resources'
     dependsOn npmBuild
+    dependsOn cleanFrontendAssets
     from(frontendDistDir) {
         // Exclude files that conflict with backend static resources
         exclude 'robots.txt'  // Backend already has this
@@ -311,7 +337,7 @@ tasks.named('copyFrontendAssets').configure {
 }
 
 if (buildWithFrontend) {
-    println "Frontend build enabled - JAR will include React frontend"
+    println "Frontend build enabled - JAR will include React frontend (mode=${frontendMode})"
     processResources.dependsOn copyFrontendAssets
 } else {
     println "Frontend build disabled - JAR will be backend-only with API landing page"
@@ -320,4 +346,9 @@ if (buildWithFrontend) {
 }
 
 bootJar.dependsOn ':common:jar'
-bootJar.dependsOn ':proprietary:jar'
+if (!gradle.ext.disableAdditional) {
+    bootJar.dependsOn ':proprietary:jar'
+}
+if (gradle.ext.enableSaas) {
+    bootJar.dependsOn ':saas:jar'
+}

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

@@ -35,7 +35,8 @@ import stirling.software.common.model.ApplicationProperties;
         scanBasePackages = {
             "stirling.software.SPDF",
             "stirling.software.common",
-            "stirling.software.proprietary"
+            "stirling.software.proprietary",
+            "stirling.software.saas"
         })
 public class SPDFApplication {
 
@@ -205,15 +206,22 @@ public class SPDFApplication {
             }
         }
 
-        // 2. Detect if SecurityConfiguration is present on classpath
-        if (isClassPresent(
-                "stirling.software.proprietary.security.configuration.SecurityConfiguration")) {
+        // 2. Detect classpath shape and pick the matching profile chain.
+        boolean hasSaas = isClassPresent("stirling.software.saas.security.SupabaseSecurityConfig");
+        boolean hasSecurity =
+                isClassPresent(
+                        "stirling.software.proprietary.security.configuration.SecurityConfiguration");
+
+        if (hasSaas) {
+            log.info("SaaS features in jar");
+            return new String[] {"security", "saas"};
+        }
+        if (hasSecurity) {
             log.info("Additional features in jar");
             return new String[] {"security"};
-        } else {
-            log.info("Without additional features in jar");
-            return new String[] {"default"};
         }
+        log.info("Without additional features in jar");
+        return new String[] {"default"};
     }
 
     private static boolean isClassPresent(String className) {

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

@@ -23,6 +23,7 @@ import lombok.RequiredArgsConstructor;
 import stirling.software.SPDF.config.swagger.JsonDataResponse;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.AnalysisApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 
@@ -32,7 +33,10 @@ public class AnalysisController {
 
     private final CustomPDFDocumentFactory pdfDocumentFactory;
 
-    @AutoJobPostMapping(value = "/page-count", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/page-count",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @JsonDataResponse
     @Operation(
             summary = "Get PDF page count",
@@ -43,7 +47,10 @@ public class AnalysisController {
         }
     }
 
-    @AutoJobPostMapping(value = "/basic-info", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/basic-info",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @JsonDataResponse
     @Operation(
             summary = "Get basic PDF information",
@@ -60,7 +67,8 @@ public class AnalysisController {
 
     @AutoJobPostMapping(
             value = "/document-properties",
-            consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @JsonDataResponse
     @Operation(
             summary = "Get PDF document properties",
@@ -90,7 +98,10 @@ public class AnalysisController {
         }
     }
 
-    @AutoJobPostMapping(value = "/page-dimensions", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/page-dimensions",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @JsonDataResponse
     @Operation(
             summary = "Get page dimensions for all pages",
@@ -110,7 +121,10 @@ public class AnalysisController {
         }
     }
 
-    @AutoJobPostMapping(value = "/form-fields", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/form-fields",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @JsonDataResponse
     @Operation(
             summary = "Get form field information",
@@ -134,7 +148,10 @@ public class AnalysisController {
         }
     }
 
-    @AutoJobPostMapping(value = "/annotation-info", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/annotation-info",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @JsonDataResponse
     @Operation(
             summary = "Get annotation information",
@@ -159,7 +176,10 @@ public class AnalysisController {
         }
     }
 
-    @AutoJobPostMapping(value = "/font-info", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/font-info",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @JsonDataResponse
     @Operation(
             summary = "Get font information",
@@ -185,7 +205,10 @@ public class AnalysisController {
         }
     }
 
-    @AutoJobPostMapping(value = "/security-info", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/security-info",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @JsonDataResponse
     @Operation(
             summary = "Get security information",

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

@@ -28,6 +28,7 @@ import lombok.RequiredArgsConstructor;
 
 import stirling.software.SPDF.model.api.general.BookletImpositionRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.TempFileManager;
@@ -44,7 +45,8 @@ public class BookletImpositionController {
 
     @AutoJobPostMapping(
             value = "/booklet-imposition",
-            consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Create a booklet with proper page imposition",
             description =

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

@@ -26,6 +26,7 @@ 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;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -126,7 +127,10 @@ public class CropController {
         return endpointConfiguration.isGroupEnabled("Ghostscript");
     }
 
-    @AutoJobPostMapping(value = "/crop", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/crop",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Crops a PDF document",
             description =

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

@@ -25,6 +25,7 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.SPDF.model.api.EditTableOfContentsRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.TempFileManager;
@@ -44,7 +45,8 @@ public class EditTableOfContentsController {
 
     @AutoJobPostMapping(
             value = "/extract-bookmarks",
-            consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Extract PDF Bookmarks",
             description = "Extracts bookmarks/table of contents from a PDF document as JSON.")
@@ -147,7 +149,8 @@ public class EditTableOfContentsController {
 
     @AutoJobPostMapping(
             value = "/edit-table-of-contents",
-            consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Edit Table of Contents",
             description = "Add or edit bookmarks/table of contents in a PDF document.")

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

@@ -3,13 +3,14 @@ package stirling.software.SPDF.controller.api;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 import java.util.regex.Pattern;
 
-import org.apache.pdfbox.multipdf.PDFMergerUtility;
 import org.apache.pdfbox.pdmodel.PDDocument;
 import org.apache.pdfbox.pdmodel.PDDocumentCatalog;
 import org.apache.pdfbox.pdmodel.PDDocumentInformation;
@@ -39,6 +40,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.general.MergePdfsRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -46,6 +48,11 @@ import stirling.software.common.util.PdfErrorUtils;
 import stirling.software.common.util.TempFile;
 import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;
+import stirling.software.jpdfium.PdfDocument;
+import stirling.software.jpdfium.PdfMerge;
+import stirling.software.jpdfium.doc.Bookmark;
+import stirling.software.jpdfium.doc.PdfBookmarkEditor;
+import stirling.software.jpdfium.doc.PdfBookmarkEditor.BookmarkTree;
 
 @GeneralApi
 @Slf4j
@@ -56,7 +63,6 @@ public class MergeController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    // Merges a list of PDDocument objects into a single PDDocument
     public PDDocument mergeDocuments(List<PDDocument> documents) throws IOException {
         PDDocument mergedDoc = pdfDocumentFactory.createNewDocument();
         boolean success = false;
@@ -75,11 +81,8 @@ public class MergeController {
         }
     }
 
-    // Re-order files to match the explicit order provided by the front-end.
-    // fileOrder is newline-delimited original filenames in the desired order.
     private static MultipartFile[] reorderFilesByProvidedOrder(
             MultipartFile[] files, String fileOrder) {
-        // Split by various line endings and trim each entry
         String[] desired =
                 stirling.software.common.util.RegexPatternUtils.getInstance()
                         .getNewlineSplitPattern()
@@ -106,7 +109,6 @@ public class MergeController {
         return ordered.toArray(new MultipartFile[0]);
     }
 
-    // Returns a comparator for sorting MultipartFile arrays based on the given sort type
     private Comparator<MultipartFile> getSortComparator(String sortType) {
         return switch (sortType) {
             case "byFileName" ->
@@ -154,18 +156,16 @@ public class MergeController {
                             return 0;
                         }
                     };
-            case "orderProvided" -> (file1, file2) -> 0; // Default is the order provided
-            default -> (file1, file2) -> 0; // Default is the order provided
+            case "orderProvided" -> (file1, file2) -> 0;
+            default -> (file1, file2) -> 0;
         };
     }
 
-    // Parse client file IDs from JSON string
     private String[] parseClientFileIds(String clientFileIds) {
         if (clientFileIds == null || clientFileIds.trim().isEmpty()) {
             return new String[0];
         }
         try {
-            // Simple JSON array parsing - remove brackets and split by comma
             String trimmed = clientFileIds.trim();
             if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
                 String inside = trimmed.substring(1, trimmed.length() - 1).trim();
@@ -185,39 +185,29 @@ public class MergeController {
         return new String[0];
     }
 
-    // Adds a table of contents to the merged document using filenames as chapter titles
     private void addTableOfContents(PDDocument mergedDocument, MultipartFile[] files) {
-        // Create the document outline
         PDDocumentOutline outline = new PDDocumentOutline();
         mergedDocument.getDocumentCatalog().setDocumentOutline(outline);
 
-        int pageIndex = 0; // Current page index in the merged document
-
-        // Iterate through the original files
+        int pageIndex = 0;
         for (MultipartFile file : files) {
-            // Get the filename without extension to use as bookmark title
             String filename = file.getOriginalFilename();
             String title = GeneralUtils.removeExtension(filename);
 
-            // Create an outline item for this file
             PDOutlineItem item = new PDOutlineItem();
             item.setTitle(title);
 
-            // Set the destination to the first page of this file in the merged document
             if (pageIndex < mergedDocument.getNumberOfPages()) {
                 PDPage page = mergedDocument.getPage(pageIndex);
                 item.setDestination(page);
             }
-
-            // Add the item to the outline
             outline.addLast(item);
 
-            // Increment page index for the next file
             try (PDDocument doc = pdfDocumentFactory.load(file)) {
                 pageIndex += doc.getNumberOfPages();
             } catch (IOException e) {
                 ExceptionUtils.logException("document loading for TOC generation", e);
-                pageIndex++; // Increment by at least one if we can't determine page count
+                pageIndex++;
             }
         }
     }
@@ -235,7 +225,6 @@ public class MergeController {
                     }
                 }
 
-                // Fallback to XMP metadata if Info dates are missing
                 PDMetadata metadata = doc.getDocumentCatalog().getMetadata();
                 if (metadata != null) {
                     try (InputStream is = metadata.createInputStream()) {
@@ -271,7 +260,10 @@ public class MergeController {
         return -1;
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/merge-pdfs")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/merge-pdfs",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Merge multiple PDF files into one",
@@ -283,7 +275,7 @@ public class MergeController {
             @ModelAttribute MergePdfsRequest request,
             @RequestParam(value = "fileOrder", required = false) String fileOrder)
             throws IOException {
-        List<File> filesToDelete = new ArrayList<>(); // List of temporary files to delete
+        List<File> filesToDelete = new ArrayList<>();
         TempFile outputTempFile = null;
 
         boolean removeCertSign = Boolean.TRUE.equals(request.getRemoveCertSign());
@@ -294,48 +286,35 @@ public class MergeController {
             files = new MultipartFile[0];
         }
 
-        // If front-end provided explicit visible order, honor it and override backend sorting
         if (fileOrder != null && !fileOrder.isBlank()) {
             log.info("Reordering files based on fileOrder parameter");
             files = reorderFilesByProvidedOrder(files, fileOrder);
         } else {
             log.info("Sorting files based on sortType: {}", request.getSortType());
-            Arrays.sort(
-                    files,
-                    getSortComparator(
-                            request.getSortType())); // Sort files based on requested sort type
+            Arrays.sort(files, getSortComparator(request.getSortType()));
         }
 
         try (TempFile mt = new TempFile(tempFileManager, ".pdf")) {
 
-            PDFMergerUtility mergerUtility = new PDFMergerUtility();
-            long totalSize = 0;
+            List<Path> inputPaths = new ArrayList<>(files.length);
             List<Integer> invalidIndexes = new ArrayList<>();
             for (int index = 0; index < files.length; index++) {
                 MultipartFile multipartFile = files[index];
-                totalSize += multipartFile.getSize();
-                File tempFile =
-                        tempFileManager.convertMultipartFileToFile(
-                                multipartFile); // Convert MultipartFile to File
-                filesToDelete.add(tempFile); // Add temp file to the list for later deletion
+                File tempFile = tempFileManager.convertMultipartFileToFile(multipartFile);
+                filesToDelete.add(tempFile);
+                inputPaths.add(tempFile.toPath());
 
-                // Pre-validate each PDF so we can report which one(s) are broken
-                // Use the original MultipartFile to avoid deleting the tempFile during validation
-                try (PDDocument ignored = pdfDocumentFactory.load(multipartFile)) {
-                    // OK
-                } catch (IOException e) {
+                try (PdfDocument ignored = PdfDocument.open(tempFile.toPath())) {
+                } catch (Exception e) {
                     ExceptionUtils.logException("PDF pre-validate", e);
                     invalidIndexes.add(index);
                 }
-                mergerUtility.addSource(tempFile); // Add source file to the merger utility
             }
 
-            mergerUtility.setDestinationFileName(mt.getFile().getAbsolutePath());
-
+            int[] pageCounts;
             try {
-                mergerUtility.mergeDocuments(
-                        pdfDocumentFactory.getStreamCacheFunction(
-                                totalSize)); // Merge the documents
+                pageCounts =
+                        mergeWithJpdfium(inputPaths, files, generateToc, mt.getFile().toPath());
             } catch (IOException e) {
                 ExceptionUtils.logException("PDF merge", e);
                 if (PdfErrorUtils.isCorruptedPdfError(e)) {
@@ -344,10 +323,26 @@ public class MergeController {
                 throw e;
             }
 
-            // Load the merged PDF document and operate on it inside try-with-resources
-            try (PDDocument mergedDocument = pdfDocumentFactory.load(mt.getFile())) {
-                // Remove signatures if removeCertSign is true
-                if (removeCertSign) {
+            boolean sigFlattenNeeded = false;
+            if (removeCertSign) {
+                try (PdfDocument check = PdfDocument.open(mt.getFile().toPath())) {
+                    sigFlattenNeeded = !check.signatures().isEmpty();
+                } catch (Exception e) {
+                    log.debug(
+                            "JPDFium signature pre-check failed; falling back to PDFBox flatten:"
+                                    + " {}",
+                            e.getMessage());
+                    sigFlattenNeeded = true;
+                }
+                if (!sigFlattenNeeded) {
+                    log.info(
+                            "removeCertSign requested but merged document has no signature"
+                                    + " fields; skipping PDFBox flatten pass");
+                }
+            }
+
+            if (sigFlattenNeeded) {
+                try (PDDocument mergedDocument = pdfDocumentFactory.load(mt.getFile())) {
                     PDDocumentCatalog catalog = mergedDocument.getDocumentCatalog();
                     PDAcroForm acroForm = catalog.getAcroForm();
                     if (acroForm != null) {
@@ -355,24 +350,26 @@ public class MergeController {
                                 acroForm.getFields().stream()
                                         .filter(PDSignatureField.class::isInstance)
                                         .toList();
-
                         if (!fieldsToRemove.isEmpty()) {
-                            acroForm.flatten(
-                                    fieldsToRemove,
-                                    false); // Flatten the fields, effectively removing them
+                            acroForm.flatten(fieldsToRemove, false);
                         }
                     }
+                    outputTempFile = new TempFile(tempFileManager, ".pdf");
+                    try {
+                        mergedDocument.save(outputTempFile.getFile());
+                    } catch (Exception e) {
+                        outputTempFile.close();
+                        outputTempFile = null;
+                        throw e;
+                    }
                 }
-
-                // Add table of contents if generateToc is true
-                if (generateToc && files.length > 0) {
-                    addTableOfContents(mergedDocument, files);
-                }
-
-                // Save the modified document to a temporary file
+            } else {
                 outputTempFile = new TempFile(tempFileManager, ".pdf");
                 try {
-                    mergedDocument.save(outputTempFile.getFile());
+                    Files.copy(
+                            mt.getFile().toPath(),
+                            outputTempFile.getFile().toPath(),
+                            java.nio.file.StandardCopyOption.REPLACE_EXISTING);
                 } catch (Exception e) {
                     outputTempFile.close();
                     outputTempFile = null;
@@ -391,7 +388,7 @@ public class MergeController {
             throw ex;
         } finally {
             for (File file : filesToDelete) {
-                tempFileManager.deleteTempFile(file); // Delete temporary files
+                tempFileManager.deleteTempFile(file);
             }
         }
 
@@ -401,4 +398,113 @@ public class MergeController {
 
         return WebResponseUtils.pdfFileToWebResponse(outputTempFile, mergedFileName);
     }
+
+    private int[] mergeWithJpdfium(
+            List<Path> inputPaths, MultipartFile[] files, boolean generateToc, Path outputPath)
+            throws IOException {
+        if (inputPaths.isEmpty()) {
+            try (PdfDocument empty = PdfDocument.open(new byte[0])) {
+                empty.save(outputPath);
+            } catch (Exception ignored) {
+                Files.write(outputPath, new byte[0]);
+            }
+            return new int[0];
+        }
+
+        List<PdfDocument> docs = new ArrayList<>(inputPaths.size());
+        int[] pageCounts = new int[inputPaths.size()];
+        int[] pageOffsets = new int[inputPaths.size()];
+        List<List<Bookmark>> sourceBookmarks = new ArrayList<>(inputPaths.size());
+        int runningOffset = 0;
+        try {
+            for (int i = 0; i < inputPaths.size(); i++) {
+                Path p = inputPaths.get(i);
+                PdfDocument doc = PdfDocument.open(p);
+                docs.add(doc);
+                pageCounts[i] = doc.pageCount();
+                pageOffsets[i] = runningOffset;
+                sourceBookmarks.add(doc.bookmarks());
+                runningOffset += pageCounts[i];
+            }
+
+            BookmarkTree combinedTree =
+                    buildCombinedBookmarkTree(files, pageOffsets, sourceBookmarks, generateToc);
+
+            try (PdfDocument merged = PdfMerge.merge(docs)) {
+                if (combinedTree.entries().isEmpty()) {
+                    merged.save(outputPath);
+                } else {
+                    PdfBookmarkEditor.setBookmarks(merged, combinedTree, outputPath);
+                }
+            }
+        } catch (RuntimeException e) {
+            throw new IOException("JPDFium merge failed", e);
+        } finally {
+            for (PdfDocument doc : docs) {
+                try {
+                    doc.close();
+                } catch (Exception ignored) {
+                }
+            }
+        }
+        return pageCounts;
+    }
+
+    private BookmarkTree buildCombinedBookmarkTree(
+            MultipartFile[] files,
+            int[] pageOffsets,
+            List<List<Bookmark>> sourceBookmarks,
+            boolean generateToc) {
+        BookmarkTree.Builder builder = BookmarkTree.builder();
+
+        if (generateToc) {
+            for (int i = 0; i < files.length; i++) {
+                String filename = files[i].getOriginalFilename();
+                String title = GeneralUtils.removeExtension(filename);
+                if (title == null || title.isBlank()) {
+                    title = "Document " + (i + 1);
+                }
+                builder.add(title, pageOffsets[i]);
+            }
+        }
+
+        for (int i = 0; i < sourceBookmarks.size(); i++) {
+            int offset = pageOffsets[i];
+            for (Bookmark bm : sourceBookmarks.get(i)) {
+                addBookmarkFlat(builder, bm, offset);
+            }
+        }
+
+        return builder.build();
+    }
+
+    private void addBookmarkFlat(BookmarkTree.Builder builder, Bookmark root, int offset) {
+        final int maxNodes = 100_000;
+        java.util.Deque<Bookmark> stack = new java.util.ArrayDeque<>();
+        java.util.Set<Bookmark> visited =
+                java.util.Collections.newSetFromMap(new java.util.IdentityHashMap<>());
+        stack.push(root);
+        int processed = 0;
+        while (!stack.isEmpty() && processed < maxNodes) {
+            Bookmark bm = stack.pop();
+            if (!visited.add(bm)) {
+                continue;
+            }
+            processed++;
+            if (bm.isInternal() && bm.title() != null) {
+                builder.add(bm.title(), offset + bm.pageIndex());
+            }
+            if (bm.hasChildren()) {
+                List<Bookmark> children = bm.children();
+                for (int i = children.size() - 1; i >= 0; i--) {
+                    stack.push(children.get(i));
+                }
+            }
+        }
+        if (processed >= maxNodes) {
+            log.warn(
+                    "Source bookmark traversal hit {}-node cap; remaining bookmarks dropped",
+                    maxNodes);
+        }
+    }
 }

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

@@ -24,6 +24,7 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.SPDF.model.api.general.MergeMultiplePagesRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralFormCopyUtils;
@@ -41,7 +42,8 @@ public class MultiPageLayoutController {
 
     @AutoJobPostMapping(
             value = "/multi-page-layout",
-            consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Merge multiple pages of a PDF document into a single page",
             description =

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

@@ -25,6 +25,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.general.OverlayPdfsRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -39,7 +40,10 @@ public class PdfOverlayController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(value = "/overlay-pdfs", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/overlay-pdfs",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Overlay PDF files in various modes",

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

@@ -28,6 +28,7 @@ import stirling.software.SPDF.config.swagger.MultiFileResponse;
 import stirling.software.SPDF.model.api.general.PosterPdfRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -43,7 +44,10 @@ 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 = "multipart/form-data",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Split large PDF pages into smaller printable chunks",

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

@@ -6,8 +6,11 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 
+import org.apache.pdfbox.cos.COSName;
 import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDDocumentCatalog;
 import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.interactive.form.PDAcroForm;
 import org.springframework.core.io.Resource;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
@@ -25,8 +28,10 @@ import stirling.software.SPDF.model.api.PDFWithPageNums;
 import stirling.software.SPDF.model.api.general.RearrangePagesRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
+import stirling.software.common.util.FormUtils;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;
@@ -39,7 +44,10 @@ public class RearrangePagesPDFController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/remove-pages")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/remove-pages",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Remove pages from a PDF file",
@@ -67,6 +75,7 @@ public class RearrangePagesPDFController {
                 int pageIndex = pagesToRemove.get(i);
                 document.removePage(pageIndex);
             }
+            FormUtils.pruneOrphanedFormFields(document);
             return WebResponseUtils.pdfDocToWebResponse(
                     document,
                     GeneralUtils.generateFilename(
@@ -219,7 +228,10 @@ public class RearrangePagesPDFController {
         }
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/rearrange-pages")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/rearrange-pages",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Rearrange pages in a PDF file",
@@ -265,6 +277,17 @@ public class RearrangePagesPDFController {
                         rearrangedDocument.addPage(page);
                     }
 
+                    PDDocumentCatalog sourceCatalog = document.getDocumentCatalog();
+                    if (sourceCatalog != null) {
+                        PDAcroForm sourceForm = sourceCatalog.getAcroForm(null);
+                        if (sourceForm != null) {
+                            rearrangedDocument
+                                    .getDocumentCatalog()
+                                    .getCOSObject()
+                                    .setItem(COSName.ACRO_FORM, sourceForm.getCOSObject());
+                        }
+                    }
+
                     return WebResponseUtils.pdfDocToWebResponse(
                             rearrangedDocument,
                             GeneralUtils.generateFilename(

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

@@ -19,6 +19,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.general.RotatePDFRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -32,7 +33,10 @@ public class RotationController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/rotate-pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/rotate-pdf",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Rotate a PDF file",

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

@@ -25,6 +25,7 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.SPDF.model.api.general.ScalePagesRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -114,7 +115,10 @@ public class ScalePagesController {
         return sizeMap;
     }
 
-    @AutoJobPostMapping(value = "/scale-pages", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/scale-pages",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Change the size of a PDF page/document",
             description =

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

@@ -16,6 +16,7 @@ import stirling.software.SPDF.config.EndpointConfiguration;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.SettingsApi;
 import stirling.software.common.configuration.InstallationPathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.util.GeneralUtils;
 
@@ -27,7 +28,9 @@ public class SettingsController {
     private final ApplicationProperties applicationProperties;
     private final EndpointConfiguration endpointConfiguration;
 
-    @AutoJobPostMapping("/update-enable-analytics")
+    @AutoJobPostMapping(
+            value = "/update-enable-analytics",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Hidden
     public ResponseEntity<Map<String, Object>> updateApiKey(@RequestParam Boolean enabled)
             throws IOException {

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

@@ -1,7 +1,10 @@
 package stirling.software.SPDF.controller.api;
 
+import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -24,12 +27,15 @@ import stirling.software.SPDF.config.swagger.MultiFileResponse;
 import stirling.software.SPDF.model.api.SplitPagesRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
-import stirling.software.common.util.ExceptionUtils;
+import stirling.software.common.util.FormUtils;
 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 stirling.software.jpdfium.PdfDocument;
+import stirling.software.jpdfium.PdfSplit;
 
 @GeneralApi
 @Slf4j
@@ -39,7 +45,10 @@ public class SplitPDFController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/split-pages")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/split-pages",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Split a PDF file into separate documents",
@@ -54,9 +63,21 @@ public class SplitPDFController {
         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);
+            try (TempFile sourceTempFile = new TempFile(tempFileManager, ".pdf")) {
+                Files.copy(
+                        file.getInputStream(),
+                        sourceTempFile.getPath(),
+                        StandardCopyOption.REPLACE_EXISTING);
+
+                int totalPages;
+                List<Integer> pageNumbers;
+                boolean hasForm;
+                try (PDDocument document =
+                        pdfDocumentFactory.load(sourceTempFile.getFile(), true)) {
+                    totalPages = document.getNumberOfPages();
+                    pageNumbers = request.getPageNumbersList(document, false);
+                    hasForm = document.getDocumentCatalog().getAcroForm(null) != null;
+                }
                 if (!pageNumbers.contains(totalPages - 1)) {
                     pageNumbers = new ArrayList<>(pageNumbers);
                     pageNumbers.add(totalPages - 1);
@@ -69,33 +90,11 @@ public class SplitPDFController {
                 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;
-
-                            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;
-                        }
-                    }
+                    writeSplits(
+                            sourceTempFile.getFile(), pageNumbers, baseFilename, zipOut, hasForm);
                 }
             }
 
-            log.debug(
-                    "Successfully created zip file with split documents: {}",
-                    outputTempFile.getPath().toString());
             String zipFilename =
                     GeneralUtils.generateFilename(file.getOriginalFilename(), "_split.zip");
             return WebResponseUtils.zipFileToWebResponse(outputTempFile, zipFilename);
@@ -104,4 +103,72 @@ public class SplitPDFController {
             throw e;
         }
     }
+
+    private void writeSplits(
+            File source,
+            List<Integer> pageNumbers,
+            String baseFilename,
+            ZipOutputStream zipOut,
+            boolean hasForm)
+            throws IOException {
+        try (PdfDocument sourceDoc = PdfDocument.open(source.toPath())) {
+            int previousPageNumber = 0;
+            for (int splitIndex = 0; splitIndex < pageNumbers.size(); splitIndex++) {
+                int splitPoint = pageNumbers.get(splitIndex);
+                writeSplit(
+                        sourceDoc,
+                        previousPageNumber,
+                        splitPoint,
+                        baseFilename,
+                        splitIndex + 1,
+                        zipOut,
+                        hasForm);
+                previousPageNumber = splitPoint + 1;
+            }
+        }
+    }
+
+    private void writeSplit(
+            PdfDocument sourceDoc,
+            int fromIndex,
+            int toIndex,
+            String baseFilename,
+            int splitNumber,
+            ZipOutputStream zipOut,
+            boolean hasForm)
+            throws IOException {
+        try (TempFile splitTemp = new TempFile(tempFileManager, ".pdf")) {
+            try (PdfDocument splitDoc = PdfSplit.extractPageRange(sourceDoc, fromIndex, toIndex)) {
+                splitDoc.save(splitTemp.getPath());
+            }
+            Path finalPath = splitTemp.getPath();
+            TempFile prunedTemp = null;
+            try {
+                if (hasForm) {
+                    prunedTemp = new TempFile(tempFileManager, ".pdf");
+                    pruneForms(splitTemp.getFile(), prunedTemp.getFile());
+                    finalPath = prunedTemp.getPath();
+                }
+                writeEntry(zipOut, baseFilename, splitNumber, finalPath);
+            } finally {
+                if (prunedTemp != null) {
+                    prunedTemp.close();
+                }
+            }
+        }
+    }
+
+    private void pruneForms(File splitFile, File outputFile) throws IOException {
+        try (PDDocument doc = pdfDocumentFactory.load(splitFile)) {
+            FormUtils.pruneOrphanedFormFields(doc);
+            doc.save(outputFile);
+        }
+    }
+
+    private void writeEntry(ZipOutputStream zipOut, String baseFilename, int index, Path pdfPath)
+            throws IOException {
+        zipOut.putNextEntry(new ZipEntry(baseFilename + "_" + index + ".pdf"));
+        Files.copy(pdfPath, zipOut);
+        zipOut.closeEntry();
+    }
 }

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

@@ -1,6 +1,9 @@
 package stirling.software.SPDF.controller.api;
 
+import java.io.File;
 import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
@@ -8,9 +11,6 @@ import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
 
 import org.apache.pdfbox.pdmodel.PDDocument;
-import org.apache.pdfbox.pdmodel.PDPage;
-import org.apache.pdfbox.pdmodel.interactive.documentnavigation.outline.PDDocumentOutline;
-import org.apache.pdfbox.pdmodel.interactive.documentnavigation.outline.PDOutlineItem;
 import org.springframework.core.io.Resource;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
@@ -30,6 +30,7 @@ import stirling.software.SPDF.config.swagger.MultiFileResponse;
 import stirling.software.SPDF.model.api.SplitPdfByChaptersRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.PdfMetadata;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.service.PdfMetadataService;
@@ -38,6 +39,8 @@ 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 stirling.software.jpdfium.PdfDocument;
+import stirling.software.jpdfium.PdfSplit;
 
 @GeneralApi
 @Slf4j
@@ -50,77 +53,42 @@ public class SplitPdfByChaptersController {
 
     private final TempFileManager tempFileManager;
 
-    private static List<Bookmark> extractOutlineItems(
-            PDDocument sourceDocument,
-            PDOutlineItem current,
-            List<Bookmark> bookmarks,
-            PDOutlineItem nextParent,
+    private static void collectBookmarks(
+            List<stirling.software.jpdfium.doc.Bookmark> source,
+            List<Bookmark> out,
             int level,
-            int maxLevel)
-            throws Exception {
-
-        while (current != null) {
-
-            String currentTitle = current.getTitle().replace("/", "");
-            int firstPage =
-                    sourceDocument.getPages().indexOf(current.findDestinationPage(sourceDocument));
-            PDOutlineItem child = current.getFirstChild();
-            PDOutlineItem nextSibling = current.getNextSibling();
-            int endPage;
-            if (child != null && level < maxLevel) {
-                endPage =
-                        sourceDocument
-                                .getPages()
-                                .indexOf(child.findDestinationPage(sourceDocument));
-            } else if (nextSibling != null) {
-                endPage =
-                        sourceDocument
-                                .getPages()
-                                .indexOf(nextSibling.findDestinationPage(sourceDocument));
-            } else if (nextParent != null) {
-
-                endPage =
-                        sourceDocument
-                                .getPages()
-                                .indexOf(nextParent.findDestinationPage(sourceDocument));
-            } else {
-                endPage = -2;
-                /*
-                happens when we have something like this:
-                Outline Item 2
-                    Outline Item 2.1
-                        Outline Item 2.1.1
-                    Outline Item 2.2
-                        Outline 2.2.1
-                        Outline 2.2.2 <--- this item neither has an immediate next parent nor an immediate next sibling
-                Outline Item 3
-                 */
+            int maxLevel) {
+        for (stirling.software.jpdfium.doc.Bookmark bm : source) {
+            if (!bm.isInternal()) {
+                continue;
             }
-            if (!bookmarks.isEmpty()
-                    && bookmarks.get(bookmarks.size() - 1).getEndPage() == -2
-                    && firstPage
-                            >= bookmarks
-                                    .get(bookmarks.size() - 1)
-                                    .getStartPage()) { // for handling the above-mentioned case
-                Bookmark previousBookmark = bookmarks.get(bookmarks.size() - 1);
-                previousBookmark.setEndPage(firstPage);
+            String title = bm.title() == null ? "" : bm.title().replace("/", "");
+            int firstPage = Math.max(0, bm.pageIndex());
+            out.add(new Bookmark(title, firstPage, -2));
+            if (bm.hasChildren() && level < maxLevel) {
+                collectBookmarks(bm.children(), out, level + 1, maxLevel);
             }
-            bookmarks.add(new Bookmark(currentTitle, firstPage, endPage));
-
-            // Recursively process children
-            if (child != null && level < maxLevel) {
-                extractOutlineItems(
-                        sourceDocument, child, bookmarks, nextSibling, level + 1, maxLevel);
-            }
-
-            current = nextSibling;
         }
-        return bookmarks;
+    }
+
+    private static void assignEndPages(List<Bookmark> bookmarks, int totalPages) {
+        for (int i = 0; i < bookmarks.size(); i++) {
+            Bookmark current = bookmarks.get(i);
+            int next = -1;
+            for (int j = i + 1; j < bookmarks.size(); j++) {
+                if (bookmarks.get(j).getStartPage() >= current.getStartPage()) {
+                    next = bookmarks.get(j).getStartPage();
+                    break;
+                }
+            }
+            current.setEndPage(next == -1 ? totalPages : next);
+        }
     }
 
     @AutoJobPostMapping(
             value = "/split-pdf-by-chapters",
-            consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Split PDFs by Chapters",
@@ -132,46 +100,41 @@ public class SplitPdfByChaptersController {
         MultipartFile file = request.getFileInput();
 
         boolean includeMetadata = Boolean.TRUE.equals(request.getIncludeMetadata());
-        Integer bookmarkLevel =
-                request.getBookmarkLevel(); // levels start from 0 (top most bookmarks)
+        Integer bookmarkLevel = request.getBookmarkLevel();
         if (bookmarkLevel < 0) {
             throw ExceptionUtils.createIllegalArgumentException(
                     "error.invalidArgument", "Invalid argument: {0}", "bookmark level");
         }
 
-        try (PDDocument sourceDocument = pdfDocumentFactory.load(file)) {
-            PDDocumentOutline outline = sourceDocument.getDocumentCatalog().getDocumentOutline();
+        try (TempFile sourceTempFile = new TempFile(tempFileManager, ".pdf")) {
+            Files.copy(
+                    file.getInputStream(),
+                    sourceTempFile.getPath(),
+                    StandardCopyOption.REPLACE_EXISTING);
 
-            if (outline == null) {
-                log.warn("No outline found for {}", file.getOriginalFilename());
-                throw ExceptionUtils.createIllegalArgumentException(
-                        "error.pdfBookmarksNotFound", "No PDF bookmarks/outline found in document");
-            }
             List<Bookmark> bookmarks = new ArrayList<>();
-            try {
-                bookmarks =
-                        extractOutlineItems(
-                                sourceDocument,
-                                outline.getFirstChild(),
-                                bookmarks,
-                                outline.getFirstChild().getNextSibling(),
-                                0,
-                                bookmarkLevel);
-                // to handle last page edge case
-                bookmarks.get(bookmarks.size() - 1).setEndPage(sourceDocument.getNumberOfPages());
-
-            } catch (Exception e) {
-                ExceptionUtils.logException("outline extraction", e);
-                throw e;
+            int totalPages;
+            try (PdfDocument sourceDocument = PdfDocument.open(sourceTempFile.getPath())) {
+                totalPages = sourceDocument.pageCount();
+                List<stirling.software.jpdfium.doc.Bookmark> roots = sourceDocument.bookmarks();
+                if (roots == null || roots.isEmpty()) {
+                    log.warn("No outline found for {}", file.getOriginalFilename());
+                    throw ExceptionUtils.createIllegalArgumentException(
+                            "error.pdfBookmarksNotFound",
+                            "No PDF bookmarks/outline found in document");
+                }
+                collectBookmarks(roots, bookmarks, 0, bookmarkLevel);
+                if (bookmarks.isEmpty()) {
+                    log.warn("No outline found for {}", file.getOriginalFilename());
+                    throw ExceptionUtils.createIllegalArgumentException(
+                            "error.pdfBookmarksNotFound",
+                            "No PDF bookmarks/outline found in document");
+                }
+                assignEndPages(bookmarks, totalPages);
             }
 
             boolean allowDuplicates = Boolean.TRUE.equals(request.getAllowDuplicates());
             if (!allowDuplicates) {
-                /*
-                duplicates are generated when multiple bookmarks correspond to the same page,
-                if the user doesn't want duplicates mergeBookmarksThatCorrespondToSamePage() method will merge the titles of all
-                the bookmarks that correspond to the same page, and treat them as a single bookmark
-                */
                 bookmarks = mergeBookmarksThatCorrespondToSamePage(bookmarks);
             }
             for (Bookmark bookmark : bookmarks) {
@@ -182,7 +145,15 @@ public class SplitPdfByChaptersController {
                         bookmark.getEndPage());
             }
 
-            TempFile zipTempFile = createZipFile(sourceDocument, bookmarks, includeMetadata);
+            PdfMetadata metadata = null;
+            if (includeMetadata) {
+                try (PDDocument metaDoc = pdfDocumentFactory.load(sourceTempFile.getFile())) {
+                    metadata = pdfMetadataService.extractMetadataFromPdf(metaDoc);
+                }
+            }
+
+            TempFile zipTempFile =
+                    createZipFile(sourceTempFile.getFile(), bookmarks, metadata, totalPages);
             String filename = GeneralUtils.generateFilename(file.getOriginalFilename(), "");
             return WebResponseUtils.zipFileToWebResponse(zipTempFile, filename + ".zip");
         }
@@ -214,45 +185,23 @@ public class SplitPdfByChaptersController {
     }
 
     private TempFile createZipFile(
-            PDDocument sourceDocument, List<Bookmark> bookmarks, boolean includeMetadata)
+            File sourceFile, List<Bookmark> bookmarks, PdfMetadata metadata, int totalPages)
             throws Exception {
-        PdfMetadata metadata =
-                includeMetadata ? pdfMetadataService.extractMetadataFromPdf(sourceDocument) : null;
         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());
-
-                        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"
-                        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;
-                    }
-                }
+        try (PdfDocument sourceDocument = PdfDocument.open(sourceFile.toPath());
+                ZipOutputStream zipOut =
+                        new ZipOutputStream(Files.newOutputStream(zipTempFile.getPath()))) {
+            for (int i = 0; i < bookmarks.size(); i++) {
+                Bookmark bookmark = bookmarks.get(i);
+                writeChapter(
+                        sourceDocument,
+                        bookmark,
+                        i,
+                        fileNumberFormatter,
+                        metadata,
+                        zipOut,
+                        totalPages);
             }
             log.info(
                     "Successfully created zip file with split documents: {}",
@@ -263,6 +212,50 @@ public class SplitPdfByChaptersController {
             throw e;
         }
     }
+
+    private void writeChapter(
+            PdfDocument sourceDocument,
+            Bookmark bookmark,
+            int index,
+            String fileNumberFormatter,
+            PdfMetadata metadata,
+            ZipOutputStream zipOut,
+            int totalPages)
+            throws Exception {
+        boolean isSinglePage = (bookmark.getStartPage() == bookmark.getEndPage());
+        int from = Math.min(Math.max(0, bookmark.getStartPage()), totalPages - 1);
+        int rawEnd = isSinglePage ? bookmark.getEndPage() : bookmark.getEndPage() - 1;
+        int to = Math.min(Math.max(from, rawEnd), totalPages - 1);
+        try (TempFile splitTemp = new TempFile(tempFileManager, ".pdf")) {
+            try (PdfDocument splitDoc = PdfSplit.extractPageRange(sourceDocument, from, to)) {
+                splitDoc.save(splitTemp.getPath());
+            }
+            Path finalPath = splitTemp.getPath();
+            TempFile metaTemp = null;
+            try {
+                if (metadata != null) {
+                    metaTemp = new TempFile(tempFileManager, ".pdf");
+                    try (PDDocument doc = pdfDocumentFactory.load(splitTemp.getFile())) {
+                        pdfMetadataService.setMetadataToPdf(doc, metadata);
+                        doc.save(metaTemp.getFile());
+                    }
+                    finalPath = metaTemp.getPath();
+                }
+                String fileName =
+                        String.format(Locale.ROOT, fileNumberFormatter, index)
+                                + bookmark.getTitle()
+                                + ".pdf";
+                zipOut.putNextEntry(new ZipEntry(fileName));
+                Files.copy(finalPath, zipOut);
+                zipOut.closeEntry();
+                log.debug("Wrote split document {} to zip file", fileName);
+            } finally {
+                if (metaTemp != null) {
+                    metaTemp.close();
+                }
+            }
+        }
+    }
 }
 
 @Data

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

@@ -33,6 +33,7 @@ import stirling.software.SPDF.model.SplitTypes;
 import stirling.software.SPDF.model.api.SplitPdfBySectionsRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -50,7 +51,8 @@ public class SplitPdfBySectionsController {
 
     @AutoJobPostMapping(
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
-            value = "/split-pdf-by-sections")
+            value = "/split-pdf-by-sections",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Split PDF pages into smaller sections",

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

@@ -1,13 +1,16 @@
 package stirling.software.SPDF.controller.api;
 
-import java.io.ByteArrayOutputStream;
+import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
+import java.util.List;
 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.core.io.Resource;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
@@ -16,7 +19,6 @@ import org.springframework.web.multipart.MultipartFile;
 
 import io.swagger.v3.oas.annotations.Operation;
 
-import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
@@ -24,12 +26,16 @@ import stirling.software.SPDF.config.swagger.MultiFileResponse;
 import stirling.software.SPDF.model.api.general.SplitPdfBySizeOrCountRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
+import stirling.software.common.util.FormUtils;
 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 stirling.software.jpdfium.PdfDocument;
+import stirling.software.jpdfium.PdfSplit;
 
 @GeneralApi
 @Slf4j
@@ -41,7 +47,8 @@ public class SplitPdfBySizeController {
 
     @AutoJobPostMapping(
             value = "/split-by-size-or-count",
-            consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Auto split PDF pages into separate documents based on size or count",
@@ -54,52 +61,37 @@ public class SplitPdfBySizeController {
     public ResponseEntity<Resource> autoSplitPdf(
             @ModelAttribute SplitPdfBySizeOrCountRequest request) throws Exception {
 
-        log.debug("Starting PDF split process with request: {}", request);
         MultipartFile file = request.getFileInput();
-
         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 sourceTempFile = new TempFile(tempFileManager, ".pdf");
+                    ZipOutputStream zipOut =
+                            new ZipOutputStream(Files.newOutputStream(zipTempFile.getPath()))) {
+                Files.copy(
+                        file.getInputStream(),
+                        sourceTempFile.getPath(),
+                        StandardCopyOption.REPLACE_EXISTING);
 
-                int type = request.getSplitType();
-                String value = request.getSplitValue();
-                log.debug("Split type: {}, Split value: {}", type, value);
+                boolean hasForm;
+                try (PDDocument acroDoc = pdfDocumentFactory.load(sourceTempFile.getFile(), true)) {
+                    hasForm = acroDoc.getDocumentCatalog().getAcroForm(null) != null;
+                }
 
-                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);
+                try (PdfDocument sourceDocument = PdfDocument.open(sourceTempFile.getPath())) {
+                    List<int[]> ranges = computeRanges(request, sourceDocument);
+
+                    int fileIndex = 1;
+                    for (int[] range : ranges) {
+                        if (range.length == 0) {
+                            continue;
+                        }
+                        writeRange(sourceDocument, range, zipOut, filename, fileIndex++, hasForm);
+                    }
                 }
-                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);
@@ -108,387 +100,191 @@ public class SplitPdfBySizeController {
         }
     }
 
-    private void handleSplitBySize(
-            PDDocument sourceDocument, long maxBytes, ZipOutputStream zipOut, String baseFilename)
+    private List<int[]> computeRanges(SplitPdfBySizeOrCountRequest request, PdfDocument sourceDoc)
             throws IOException {
-        log.debug("Starting handleSplitBySize with maxBytes={}", maxBytes);
+        int type = request.getSplitType();
+        String value = request.getSplitValue();
+        if (type == 0) {
+            return computeSizeRanges(sourceDoc, GeneralUtils.convertSizeToBytes(value));
+        } else if (type == 1) {
+            return computePageCountRanges(sourceDoc, Integer.parseInt(value));
+        } else if (type == 2) {
+            return computeDocCountRanges(sourceDoc, Integer.parseInt(value));
+        }
+        throw ExceptionUtils.createIllegalArgumentException(
+                "error.invalidArgument", "Invalid argument: {0}", "split type: " + type);
+    }
 
-        @Getter
-        class DocHolder implements AutoCloseable {
-            private PDDocument doc;
-
-            public DocHolder(PDDocument doc) {
-                this.doc = doc;
-            }
-
-            public void setDoc(PDDocument doc) {
-                if (this.doc != null) {
-                    try {
-                        this.doc.close();
-                    } catch (IOException e) {
-                        log.error("Error closing document", e);
+    private void writeRange(
+            PdfDocument sourceDoc,
+            int[] range,
+            ZipOutputStream zipOut,
+            String baseFilename,
+            int fileIndex,
+            boolean hasForm)
+            throws IOException {
+        try (TempFile splitTemp = new TempFile(tempFileManager, ".pdf")) {
+            extractRangeToFile(sourceDoc, range, splitTemp.getPath());
+            Path finalPath = splitTemp.getPath();
+            TempFile prunedTemp = null;
+            try {
+                if (hasForm) {
+                    prunedTemp = new TempFile(tempFileManager, ".pdf");
+                    try (PDDocument doc = pdfDocumentFactory.load(splitTemp.getFile())) {
+                        FormUtils.pruneOrphanedFormFields(doc);
+                        doc.save(prunedTemp.getFile());
                     }
+                    finalPath = prunedTemp.getPath();
                 }
-                this.doc = doc;
-            }
-
-            @Override
-            public void close() throws IOException {
-                if (doc != null) {
-                    doc.close();
+                writeEntry(zipOut, baseFilename, fileIndex, finalPath);
+            } finally {
+                if (prunedTemp != null) {
+                    prunedTemp.close();
                 }
             }
         }
+    }
 
-        int fileIndex = 1;
-        try (DocHolder holder =
-                new DocHolder(
-                        pdfDocumentFactory.createNewDocumentBasedOnOldDocument(sourceDocument))) {
-            int totalPages = sourceDocument.getNumberOfPages();
-            int pageAdded = 0;
+    private void extractRangeToFile(PdfDocument sourceDoc, int[] range, Path outputPath)
+            throws IOException {
+        int from = range[0];
+        int to = range[range.length - 1];
+        try (PdfDocument split = PdfSplit.extractPageRange(sourceDoc, from, to)) {
+            split.save(outputPath);
+        }
+    }
 
-            // Smart size check frequency - check more often with larger documents
-            int baseCheckFrequency = 5;
+    private void writeEntry(
+            ZipOutputStream zipOut, String baseFilename, int fileIndex, Path pdfPath)
+            throws IOException {
+        zipOut.putNextEntry(new ZipEntry(baseFilename + "_" + fileIndex + ".pdf"));
+        Files.copy(pdfPath, zipOut);
+        zipOut.closeEntry();
+    }
 
+    /** Returns contiguous page-index ranges fitting within {@code maxBytes}. */
+    private List<int[]> computeSizeRanges(PdfDocument sourceDoc, long maxBytes) throws IOException {
+        List<int[]> ranges = new ArrayList<>();
+        int totalPages = sourceDoc.pageCount();
+        int baseCheckFrequency = 5;
+        int rangeStart = 0;
+        int rangeEnd = -1;
+        try (TempFile probe = new TempFile(tempFileManager, ".pdf")) {
+            File probeFile = probe.getFile();
             for (int pageIndex = 0; pageIndex < totalPages; pageIndex++) {
-                PDPage page = sourceDocument.getPage(pageIndex);
-                log.debug("Processing page {} of {}", pageIndex + 1, totalPages);
-
-                // Add the page to current document
-                PDPage newPage = new PDPage(page.getCOSObject());
-                holder.getDoc().addPage(newPage);
-                pageAdded++;
-
-                // Dynamic size checking based on document size and page count
+                rangeEnd = pageIndex;
+                int pageAdded = rangeEnd - rangeStart + 1;
                 boolean shouldCheckSize =
                         (pageAdded % baseCheckFrequency == 0)
                                 || (pageIndex == totalPages - 1)
-                                || (pageAdded >= 20); // Always check after 20 pages
-
-                if (shouldCheckSize) {
-                    log.debug("Performing size check after {} pages", pageAdded);
-                    long actualSize;
-                    try (ByteArrayOutputStream checkSizeStream = new ByteArrayOutputStream()) {
-                        holder.getDoc().save(checkSizeStream);
-                        actualSize = checkSizeStream.size();
-                    }
-                    log.debug(
-                            "Current document size: {} bytes (max: {} bytes)",
-                            actualSize,
-                            maxBytes);
-
-                    if (actualSize > maxBytes) {
-                        // We exceeded the limit - remove the last page and save
-                        if (holder.getDoc().getNumberOfPages() > 1) {
-                            holder.getDoc().removePage(holder.getDoc().getNumberOfPages() - 1);
-                            pageIndex--; // Process this page again in the next document
-                            log.debug("Size limit exceeded - removed last page");
-                        }
-
-                        log.debug(
-                                "Saving document with {} pages as part {}",
-                                holder.getDoc().getNumberOfPages(),
-                                fileIndex);
-                        saveDocumentToZip(holder.getDoc(), zipOut, baseFilename, fileIndex++);
-                        holder.setDoc(new PDDocument());
-                        pageAdded = 0;
-                    } else if (pageIndex < totalPages - 1) {
-                        // We're under the limit, calculate if we might fit more pages
-                        // Try to predict how many more similar pages might fit
-                        if (actualSize < maxBytes * 0.75 && pageAdded > 0) {
-                            // Rather than using a ratio, look ahead to test actual upcoming pages
-                            int pagesToLookAhead = Math.min(5, totalPages - pageIndex - 1);
-
-                            if (pagesToLookAhead > 0) {
-                                log.debug(
-                                        "Testing {} upcoming pages for potential addition",
-                                        pagesToLookAhead);
-
-                                // Create a temp document with current pages + look-ahead pages
-                                try (PDDocument testDoc = new PDDocument()) {
-                                    // First copy existing pages
-                                    for (int i = 0; i < holder.getDoc().getNumberOfPages(); i++) {
-                                        testDoc.addPage(
-                                                new PDPage(
-                                                        holder.getDoc().getPage(i).getCOSObject()));
-                                    }
-
-                                    // Try adding look-ahead pages one by one
-                                    int extraPagesAdded = 0;
-                                    for (int i = 0; i < pagesToLookAhead; i++) {
-                                        int testPageIndex = pageIndex + 1 + i;
-                                        PDPage testPage = sourceDocument.getPage(testPageIndex);
-                                        testDoc.addPage(new PDPage(testPage.getCOSObject()));
-
-                                        // Check if we're still under size
-                                        long testSize;
-                                        try (ByteArrayOutputStream testStream =
-                                                new ByteArrayOutputStream()) {
-                                            testDoc.save(testStream);
-                                            testSize = testStream.size();
-                                        }
-
-                                        if (testSize <= maxBytes) {
-                                            extraPagesAdded++;
-                                            log.debug(
-                                                    "Test: Can add page {} (size would be {})",
-                                                    testPageIndex + 1,
-                                                    testSize);
-                                        } else {
-                                            log.debug(
-                                                    "Test: Cannot add page {} (size would be {})",
-                                                    testPageIndex + 1,
-                                                    testSize);
-                                            break;
-                                        }
-                                    }
-                                    // Add the pages we verified would fit
-                                    if (extraPagesAdded > 0) {
-                                        log.debug(
-                                                "Adding {} verified pages ahead", extraPagesAdded);
-                                        for (int i = 0; i < extraPagesAdded; i++) {
-                                            int extraPageIndex = pageIndex + 1 + i;
-                                            PDPage extraPage =
-                                                    sourceDocument.getPage(extraPageIndex);
-                                            holder.getDoc()
-                                                    .addPage(new PDPage(extraPage.getCOSObject()));
-                                        }
-                                        pageIndex += extraPagesAdded;
-                                        pageAdded += extraPagesAdded;
-                                    }
-                                }
-                            }
-                        }
-                    }
+                                || (pageAdded >= 20);
+                if (!shouldCheckSize) {
+                    continue;
                 }
-            }
+                long actualSize = saveRange(sourceDoc, rangeStart, rangeEnd, probeFile);
 
-            // Save final document if it has any pages
-            if (holder.getDoc() != null && holder.getDoc().getNumberOfPages() > 0) {
-                log.debug(
-                        "Saving final document with {} pages as part {}",
-                        holder.getDoc().getNumberOfPages(),
-                        fileIndex);
-                saveDocumentToZip(holder.getDoc(), zipOut, baseFilename, fileIndex++);
-                holder.setDoc(null);
-            }
-        }
-
-        log.debug("Completed handleSplitBySize with {} document parts created", fileIndex - 1);
-    }
-
-    private void handleSplitByPageCount(
-            PDDocument sourceDocument, int pageCount, ZipOutputStream zipOut, String baseFilename)
-            throws IOException {
-        log.debug("Starting handleSplitByPageCount with pageCount={}", pageCount);
-        int currentPageCount = 0;
-        PDDocument currentDoc = null;
-        int fileIndex = 1;
-
-        try {
-            log.debug("Creating initial output document");
-            try {
-                currentDoc = pdfDocumentFactory.createNewDocumentBasedOnOldDocument(sourceDocument);
-                log.debug("Successfully created initial output document");
-            } catch (Exception e) {
-                ExceptionUtils.logException("initial output document creation", e);
-                throw ExceptionUtils.createFileProcessingException("split", e);
-            }
-
-            int pageIndex = 0;
-            int totalPages = sourceDocument.getNumberOfPages();
-            log.debug("Processing {} pages", totalPages);
-
-            try {
-                for (PDPage page : sourceDocument.getPages()) {
-                    pageIndex++;
-                    log.debug("Processing page {} of {}", pageIndex, totalPages);
-
-                    try {
-                        log.debug("Adding page {} to current document", pageIndex);
-                        currentDoc.addPage(page);
-                        log.debug("Successfully added page {} to current document", pageIndex);
-                    } catch (Exception e) {
-                        log.error("Error adding page {} to current document", pageIndex, e);
-                        throw ExceptionUtils.createFileProcessingException("split", e);
+                if (actualSize > maxBytes) {
+                    if (pageAdded > 1) {
+                        rangeEnd = pageIndex - 1;
+                        pageIndex--;
                     }
-
-                    currentPageCount++;
-                    log.debug("Current page count: {}/{}", currentPageCount, pageCount);
-
-                    if (currentPageCount == pageCount) {
-                        log.debug(
-                                "Reached target page count ({}), saving current document as part {}",
-                                pageCount,
-                                fileIndex);
-                        try {
-                            saveDocumentToZip(currentDoc, zipOut, baseFilename, fileIndex++);
-                            currentDoc = null; // Document is closed by saveDocumentToZip
-                            log.debug("Successfully saved document part {}", fileIndex - 1);
-                        } catch (Exception e) {
-                            log.error("Error saving document part {}", fileIndex - 1, e);
-                            throw e;
-                        }
-
-                        try {
-                            log.debug("Creating new document for next part");
-                            currentDoc = new PDDocument();
-                            log.debug("Successfully created new document");
-                        } catch (Exception e) {
-                            log.error("Error creating new document for next part", e);
-                            throw ExceptionUtils.createFileProcessingException("split", e);
-                        }
-
-                        currentPageCount = 0;
-                        log.debug("Reset current page count to 0");
-                    }
-                }
-            } catch (Exception e) {
-                log.error("Error iterating through pages", e);
-                throw ExceptionUtils.createFileProcessingException("split", e);
-            }
-
-            // Add the last document if it contains any pages
-            try {
-                if (currentDoc != null && currentDoc.getPages().getCount() != 0) {
-                    log.debug(
-                            "Saving final document with {} pages as part {}",
-                            currentDoc.getPages().getCount(),
-                            fileIndex);
-                    try {
-                        saveDocumentToZip(currentDoc, zipOut, baseFilename, fileIndex++);
-                        currentDoc = null; // Document is closed by saveDocumentToZip
-                        log.debug("Successfully saved final document part {}", fileIndex - 1);
-                    } catch (Exception e) {
-                        log.error("Error saving final document part {}", fileIndex - 1, e);
-                        throw e;
-                    }
-                } else {
-                    log.debug("Final document has no pages, skipping");
-                }
-            } catch (Exception e) {
-                log.error("Error checking or saving final document", e);
-                throw ExceptionUtils.createFileProcessingException("split", e);
-            }
-        } finally {
-            if (currentDoc != null) {
-                try {
-                    log.debug("Closing remaining document");
-                    currentDoc.close();
-                    log.debug("Successfully closed remaining document");
-                } catch (Exception e) {
-                    log.error("Error closing remaining document", e);
+                    ranges.add(buildRange(rangeStart, rangeEnd));
+                    rangeStart = rangeEnd + 1;
+                    rangeEnd = rangeStart - 1;
+                } else if (pageIndex < totalPages - 1 && actualSize < maxBytes * 0.75) {
+                    int extra =
+                            lookAheadFit(
+                                    sourceDoc,
+                                    rangeStart,
+                                    pageIndex,
+                                    maxBytes,
+                                    totalPages,
+                                    probeFile);
+                    pageIndex += extra;
+                    rangeEnd = pageIndex;
                 }
             }
         }
-
-        log.debug("Completed handleSplitByPageCount with {} document parts created", fileIndex - 1);
+        if (rangeEnd >= rangeStart) {
+            ranges.add(buildRange(rangeStart, rangeEnd));
+        }
+        return ranges;
     }
 
-    private void handleSplitByDocCount(
-            PDDocument sourceDocument,
-            int documentCount,
-            ZipOutputStream zipOut,
-            String baseFilename)
+    private long saveRange(PdfDocument sourceDoc, int from, int to, File output)
             throws IOException {
-        log.debug("Starting handleSplitByDocCount with documentCount={}", documentCount);
-        int totalPageCount = sourceDocument.getNumberOfPages();
-        log.debug("Total pages in source document: {}", totalPageCount);
+        try (PdfDocument split = PdfSplit.extractPageRange(sourceDoc, from, to)) {
+            split.save(output.toPath());
+        }
+        return output.length();
+    }
 
-        int pagesPerDocument = totalPageCount / documentCount;
-        int extraPages = totalPageCount % documentCount;
-        log.debug("Pages per document: {}, Extra pages: {}", pagesPerDocument, extraPages);
+    private int lookAheadFit(
+            PdfDocument sourceDoc,
+            int rangeStart,
+            int currentEnd,
+            long maxBytes,
+            int totalPages,
+            File probeFile)
+            throws IOException {
+        int pagesToLookAhead = Math.min(5, totalPages - currentEnd - 1);
+        int extra = 0;
+        for (int i = 0; i < pagesToLookAhead; i++) {
+            int trialEnd = currentEnd + 1 + i;
+            long size = saveRange(sourceDoc, rangeStart, trialEnd, probeFile);
+            if (size > maxBytes) {
+                break;
+            }
+            extra++;
+        }
+        return extra;
+    }
 
-        int currentPageIndex = 0;
-        int fileIndex = 1;
+    private List<int[]> computePageCountRanges(PdfDocument sourceDoc, int pageCount) {
+        if (pageCount <= 0) {
+            throw ExceptionUtils.createIllegalArgumentException(
+                    "error.invalidArgument", "Invalid argument: {0}", "page count: " + pageCount);
+        }
+        int totalPages = sourceDoc.pageCount();
+        List<int[]> ranges = new ArrayList<>();
+        int start = 0;
+        while (start < totalPages) {
+            int end = Math.min(start + pageCount - 1, totalPages - 1);
+            ranges.add(buildRange(start, end));
+            start = end + 1;
+        }
+        return ranges;
+    }
 
+    private List<int[]> computeDocCountRanges(PdfDocument sourceDoc, int documentCount) {
+        if (documentCount <= 0) {
+            throw ExceptionUtils.createIllegalArgumentException(
+                    "error.invalidArgument",
+                    "Invalid argument: {0}",
+                    "document count: " + documentCount);
+        }
+        int totalPages = sourceDoc.pageCount();
+        int pagesPerDocument = totalPages / documentCount;
+        int extraPages = totalPages % documentCount;
+        List<int[]> ranges = new ArrayList<>();
+        int cursor = 0;
         for (int i = 0; i < documentCount; i++) {
-            log.debug("Creating document {} of {}", i + 1, documentCount);
-            PDDocument currentDoc = null;
-            try {
-                currentDoc = pdfDocumentFactory.createNewDocumentBasedOnOldDocument(sourceDocument);
-                log.debug("Successfully created document {} of {}", i + 1, documentCount);
-
-                int pagesToAdd = pagesPerDocument + (i < extraPages ? 1 : 0);
-                log.debug("Adding {} pages to document {}", pagesToAdd, i + 1);
-
-                for (int j = 0; j < pagesToAdd; j++) {
-                    try {
-                        log.debug(
-                                "Adding page {} (index {}) to document {}",
-                                j + 1,
-                                currentPageIndex,
-                                i + 1);
-                        currentDoc.addPage(sourceDocument.getPage(currentPageIndex));
-                        log.debug("Successfully added page {} to document {}", j + 1, i + 1);
-                        currentPageIndex++;
-                    } catch (Exception e) {
-                        log.error("Error adding page {} to document {}", j + 1, i + 1, e);
-                        throw ExceptionUtils.createFileProcessingException("split", e);
-                    }
-                }
-
-                try {
-                    log.debug("Saving document {} with {} pages", i + 1, pagesToAdd);
-                    saveDocumentToZip(currentDoc, zipOut, baseFilename, fileIndex++);
-                    // saveDocumentToZip closes the document
-                    currentDoc = null;
-                    log.debug("Successfully saved document {}", i + 1);
-                } catch (Exception e) {
-                    log.error("Error saving document {}", i + 1, e);
-                    throw e;
-                }
-            } catch (Exception e) {
-                log.error("Error creating document {} of {}", i + 1, documentCount, e);
-                throw ExceptionUtils.createFileProcessingException("split", e);
-            } finally {
-                if (currentDoc != null) {
-                    try {
-                        currentDoc.close();
-                    } catch (IOException e) {
-                        log.error("Error closing document {} of {}", i + 1, documentCount, e);
-                    }
-                }
+            int pagesToAdd = pagesPerDocument + (i < extraPages ? 1 : 0);
+            if (pagesToAdd == 0) {
+                continue;
             }
+            int end = cursor + pagesToAdd - 1;
+            ranges.add(buildRange(cursor, end));
+            cursor = end + 1;
         }
-
-        log.debug("Completed handleSplitByDocCount with {} documents created", documentCount);
+        return ranges;
     }
 
-    private void saveDocumentToZip(
-            PDDocument document, ZipOutputStream zipOut, String baseFilename, int index)
-            throws IOException {
-        log.debug("Starting saveDocumentToZip for document part {}", index);
-        try (ByteArrayOutputStream outStream = new ByteArrayOutputStream()) {
-
-            try (PDDocument doc = document) {
-                log.debug("Saving document part {} to byte array", index);
-                doc.save(outStream);
-                log.debug(
-                        "Successfully saved document part {} ({} bytes)", index, outStream.size());
-            } catch (Exception e) {
-                log.error("Error saving document part {} to byte array", index, e);
-                throw ExceptionUtils.createFileProcessingException("split", e);
-            }
-
-            try {
-                // Create a new zip entry
-                String entryName = baseFilename + "_" + index + ".pdf";
-                log.debug("Creating ZIP entry: {}", entryName);
-                ZipEntry zipEntry = new ZipEntry(entryName);
-                zipOut.putNextEntry(zipEntry);
-
-                byte[] bytes = outStream.toByteArray();
-                log.debug("Writing {} bytes to ZIP entry", bytes.length);
-                zipOut.write(bytes);
-
-                log.debug("Closing ZIP entry");
-                zipOut.closeEntry();
-                log.debug("Successfully added document part {} to ZIP", index);
-            } catch (Exception e) {
-                log.error("Error adding document part {} to ZIP", index, e);
-                throw ExceptionUtils.createFileProcessingException("split", e);
-            }
+    private static int[] buildRange(int start, int end) {
+        int[] range = new int[end - start + 1];
+        for (int i = 0; i < range.length; i++) {
+            range[i] = start + i;
         }
+        return range;
     }
 }

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

@@ -20,6 +20,7 @@ import lombok.RequiredArgsConstructor;
 import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
@@ -35,7 +36,8 @@ public class ToSinglePageController {
 
     @AutoJobPostMapping(
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
-            value = "/pdf-to-single-page")
+            value = "/pdf-to-single-page",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Convert a multi-page PDF into a single long page PDF",

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

@@ -28,6 +28,7 @@ import stirling.software.SPDF.config.EndpointConfiguration;
 import stirling.software.SPDF.model.api.converters.ConvertEbookToPdfRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.ProcessExecutor;
@@ -56,7 +57,10 @@ public class ConvertEbookToPDFController {
         return endpointConfiguration.isGroupEnabled("Ghostscript");
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/ebook/pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/ebook/pdf",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Convert an eBook file to PDF",
             description =

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

@@ -25,6 +25,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.converters.EmlToPdfRequest;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.CustomHtmlSanitizer;
@@ -43,7 +44,10 @@ public class ConvertEmlToPDF {
     private final TempFileManager tempFileManager;
     private final CustomHtmlSanitizer customHtmlSanitizer;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/eml/pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/eml/pdf",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Convert EML/MSG to PDF",

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

@@ -17,6 +17,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.converters.HTMLToPdfRequest;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.*;
@@ -33,7 +34,10 @@ public class ConvertHtmlToPDF {
 
     private final CustomHtmlSanitizer customHtmlSanitizer;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/html/pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/html/pdf",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Convert an HTML or ZIP (containing HTML and CSS) to PDF",

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

@@ -40,6 +40,7 @@ import stirling.software.SPDF.model.api.converters.ConvertToImageRequest;
 import stirling.software.SPDF.model.api.converters.ConvertToPdfRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.CbrUtils;
 import stirling.software.common.util.CbzUtils;
@@ -72,7 +73,10 @@ public class ConvertImgPDFController {
         return endpointConfiguration.isGroupEnabled("Ghostscript");
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/img")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/img",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Convert PDF to image(s)",
@@ -239,7 +243,10 @@ public class ConvertImgPDFController {
         }
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/img/pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/img/pdf",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Convert images to a PDF file",

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

@@ -26,6 +26,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.GeneralFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.*;
@@ -41,7 +42,10 @@ public class ConvertMarkdownToPdf {
 
     private final CustomHtmlSanitizer customHtmlSanitizer;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/markdown/pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/markdown/pdf",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Convert a Markdown file to PDF",

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

@@ -29,6 +29,7 @@ import stirling.software.SPDF.config.EndpointConfiguration;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.GeneralFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.CustomHtmlSanitizer;
@@ -200,7 +201,10 @@ public class ConvertOfficeController {
                 .matches();
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/file/pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/file/pdf",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Convert a file to a PDF using LibreOffice",
             description =

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

@@ -27,6 +27,7 @@ import stirling.software.SPDF.model.api.converters.ConvertPdfToEpubRequest.Outpu
 import stirling.software.SPDF.model.api.converters.ConvertPdfToEpubRequest.TargetDevice;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.ProcessExecutor;
 import stirling.software.common.util.ProcessExecutor.ProcessExecutorResult;
@@ -81,7 +82,10 @@ public class ConvertPDFToEpubController {
         return command;
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/epub")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/epub",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Convert PDF to EPUB/AZW3",
             description =

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

@@ -25,6 +25,7 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.SPDF.model.api.PDFWithPageNums;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.TempFile;
@@ -45,7 +46,10 @@ public class ConvertPDFToExcelController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(value = "/pdf/xlsx", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/pdf/xlsx",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Convert a PDF to an Excel spreadsheet (XLSX)",
             description =

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

@@ -13,6 +13,7 @@ import lombok.RequiredArgsConstructor;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.util.PDFToFile;
 import stirling.software.common.util.TempFileManager;
@@ -24,7 +25,10 @@ public class ConvertPDFToHtml {
     private final TempFileManager tempFileManager;
     private final RuntimePathConfig runtimePathConfig;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/html")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/html",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Convert PDF to HTML",
             description =

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

@@ -22,6 +22,7 @@ import stirling.software.SPDF.model.api.converters.PdfToWordRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
@@ -38,7 +39,10 @@ public class ConvertPDFToOffice {
     private final TempFileManager tempFileManager;
     private final RuntimePathConfig runtimePathConfig;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/presentation")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/presentation",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Convert PDF to Presentation format",
             description =
@@ -53,7 +57,10 @@ public class ConvertPDFToOffice {
         return pdfToFile.processPdfToOfficeFormat(inputFile, outputFormat, "impress_pdf_import");
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/text")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/text",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Convert PDF to Text or RTF format",
             description =
@@ -83,7 +90,10 @@ public class ConvertPDFToOffice {
         }
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/word")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/word",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Convert PDF to Word document",
             description =
@@ -97,7 +107,10 @@ public class ConvertPDFToOffice {
         return pdfToFile.processPdfToOfficeFormat(inputFile, outputFormat, "writer_pdf_import");
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/xml")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/xml",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Convert PDF to XML",
             description =

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

@@ -90,6 +90,7 @@ import stirling.software.SPDF.model.api.converters.PdfToPdfARequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.ProcessExecutor;
 import stirling.software.common.util.ProcessExecutor.ProcessExecutorResult;
@@ -572,7 +573,10 @@ public class ConvertPDFToPDFA {
         }
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/pdfa")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/pdfa",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Convert a PDF to a PDF/A or PDF/X",
             description =

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

@@ -32,6 +32,7 @@ import stirling.software.SPDF.model.json.PdfJsonMetadata;
 import stirling.software.SPDF.service.PdfJsonConversionService;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.GeneralFile;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.JobOwnershipService;
@@ -54,7 +55,10 @@ public class ConvertPdfJsonController {
     @Autowired(required = false)
     private JobOwnershipService jobOwnershipService;
 
-    @AutoJobPostMapping(consumes = "multipart/form-data", value = "/pdf/text-editor")
+    @AutoJobPostMapping(
+            consumes = "multipart/form-data",
+            value = "/pdf/text-editor",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Convert PDF to Text Editor Format",
             description =
@@ -92,7 +96,10 @@ public class ConvertPdfJsonController {
         }
     }
 
-    @AutoJobPostMapping(consumes = "multipart/form-data", value = "/text-editor/pdf")
+    @AutoJobPostMapping(
+            consumes = "multipart/form-data",
+            value = "/text-editor/pdf",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Convert Text Editor Format to PDF",
@@ -123,7 +130,10 @@ public class ConvertPdfJsonController {
         return WebResponseUtils.pdfFileToWebResponse(tempOut, docName);
     }
 
-    @AutoJobPostMapping(consumes = "multipart/form-data", value = "/pdf/text-editor/metadata")
+    @AutoJobPostMapping(
+            consumes = "multipart/form-data",
+            value = "/pdf/text-editor/metadata",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Extract PDF metadata for text editor lazy loading",
             description =
@@ -165,7 +175,8 @@ public class ConvertPdfJsonController {
 
     @AutoJobPostMapping(
             value = "/pdf/text-editor/partial/{jobId}",
-            consumes = MediaType.APPLICATION_JSON_VALUE)
+            consumes = MediaType.APPLICATION_JSON_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Apply incremental edits from text editor to a cached PDF",
@@ -184,8 +195,6 @@ public class ConvertPdfJsonController {
 
         validateJobAccess(jobId);
 
-        byte[] pdfBytes = pdfJsonConversionService.exportUpdatedPages(jobId, document);
-
         String baseName =
                 (filename != null && !filename.isBlank())
                         ? FILE_EXTENSION_PATTERN
@@ -197,13 +206,18 @@ public class ConvertPdfJsonController {
                                 .orElse("document");
         String docName = baseName.endsWith(".pdf") ? baseName : baseName + ".pdf";
         TempFile tempOut = tempFileManager.createManagedTempFile(".pdf");
+        try (OutputStream os = Files.newOutputStream(tempOut.getPath())) {
+            pdfJsonConversionService.exportUpdatedPages(jobId, document, os);
+        } catch (Exception e) {
+            tempOut.close();
+            throw e;
+        }
         try {
-            Files.write(tempOut.getPath(), pdfBytes);
+            return WebResponseUtils.pdfFileToWebResponse(tempOut, docName);
         } catch (Exception e) {
             tempOut.close();
             throw e;
         }
-        return WebResponseUtils.pdfFileToWebResponse(tempOut, docName);
     }
 
     @GetMapping(value = "/pdf/text-editor/page/{jobId}/{pageNumber}")
@@ -266,7 +280,8 @@ public class ConvertPdfJsonController {
 
     @AutoJobPostMapping(
             value = "/pdf/text-editor/clear-cache/{jobId}",
-            consumes = MediaType.ALL_VALUE)
+            consumes = MediaType.ALL_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Clear cached PDF document for text editor",
             description =

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

@@ -49,7 +49,10 @@ public class ConvertPdfToVideoController {
 
     // ffmpeg disabled due to raised CVEs
     /*
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/video")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/video",
+            resourceWeight = ResourceWeight.XLARGE_WEIGHT)
     @Operation(
             summary = "Convert PDF to Video Slideshow",
             description =

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

@@ -28,6 +28,7 @@ import stirling.software.SPDF.model.api.converters.SvgToPdfRequest;
 import stirling.software.SPDF.utils.SvgToPdf;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.SvgSanitizer;
@@ -44,7 +45,10 @@ public class ConvertSvgToPDF {
     private final SvgSanitizer svgSanitizer;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/svg/pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/svg/pdf",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Convert SVG to PDF",

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

@@ -32,6 +32,7 @@ import stirling.software.SPDF.model.api.converters.UrlToPdfRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
@@ -57,7 +58,10 @@ public class ConvertWebsiteToPDF {
 
     private static final Pattern NUMERIC_HTML_ENTITY_PATTERN = Pattern.compile("&#(x?[0-9a-f]+);");
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/url/pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/url/pdf",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Convert a URL to a PDF",
             description =

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

@@ -4,13 +4,13 @@ import java.io.ByteArrayOutputStream;
 import java.io.StringWriter;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
 
 import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVPrinter;
 import org.apache.commons.csv.QuoteMode;
 import org.apache.pdfbox.pdmodel.PDDocument;
 import org.springframework.http.ContentDisposition;
@@ -26,26 +26,27 @@ import lombok.extern.slf4j.Slf4j;
 
 import stirling.software.SPDF.config.swagger.CsvConversionResponse;
 import stirling.software.SPDF.model.api.PDFWithPageNums;
-import stirling.software.SPDF.pdf.FlexibleCSVWriter;
+import stirling.software.SPDF.pdf.parser.PdfModels.TableFragment;
+import stirling.software.SPDF.pdf.parser.TabulaTableParser;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.WebResponseUtils;
 
-import technology.tabula.ObjectExtractor;
-import technology.tabula.Page;
-import technology.tabula.Table;
-import technology.tabula.extractors.SpreadsheetExtractionAlgorithm;
-
 @ConvertApi
 @Slf4j
 @RequiredArgsConstructor
 public class ExtractCSVController {
 
     private final CustomPDFDocumentFactory pdfDocumentFactory;
+    private final TabulaTableParser tabulaTableParser;
 
-    @AutoJobPostMapping(value = "/pdf/csv", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/pdf/csv",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @CsvConversionResponse
     @Operation(
             summary = "Extracts a CSV document from a PDF",
@@ -58,24 +59,23 @@ public class ExtractCSVController {
 
         try (PDDocument document = pdfDocumentFactory.load(request)) {
             List<Integer> pages = request.getPageNumbersList(document, true);
-            SpreadsheetExtractionAlgorithm sea = new SpreadsheetExtractionAlgorithm();
             CSVFormat format =
                     CSVFormat.EXCEL.builder().setEscape('"').setQuoteMode(QuoteMode.ALL).build();
 
             for (int pageNum : pages) {
-                try (ObjectExtractor extractor = new ObjectExtractor(document)) {
-                    log.info("{}", pageNum);
-                    Page page = extractor.extract(pageNum);
-                    List<Table> tables = sea.extract(page);
+                log.info("{}", pageNum);
+                List<TableFragment> fragments = tabulaTableParser.parse(document, pageNum);
 
-                    for (int i = 0; i < tables.size(); i++) {
-                        StringWriter sw = new StringWriter();
-                        FlexibleCSVWriter csvWriter = new FlexibleCSVWriter(format);
-                        csvWriter.write(sw, Collections.singletonList(tables.get(i)));
-
-                        String entryName = generateEntryName(baseName, pageNum, i + 1);
-                        csvEntries.add(new CsvEntry(entryName, sw.toString()));
+                for (int i = 0; i < fragments.size(); i++) {
+                    StringWriter sw = new StringWriter();
+                    try (CSVPrinter printer = format.print(sw)) {
+                        for (List<String> row : fragments.get(i).rawRows()) {
+                            printer.printRecord(row);
+                        }
                     }
+                    csvEntries.add(
+                            new CsvEntry(
+                                    generateEntryName(baseName, pageNum, i + 1), sw.toString()));
                 }
             }
 

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

@@ -26,6 +26,7 @@ import stirling.software.SPDF.config.EndpointConfiguration;
 import stirling.software.SPDF.model.api.converters.PdfVectorExportRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.ConvertApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.ProcessExecutor;
@@ -45,7 +46,10 @@ public class PdfVectorExportController {
     private final TempFileManager tempFileManager;
     private final EndpointConfiguration endpointConfiguration;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/vector/pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/vector/pdf",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Convert PostScript formats to PDF",
             description =
@@ -92,7 +96,10 @@ public class PdfVectorExportController {
         return WebResponseUtils.pdfFileToWebResponse(outputTemp, outputName);
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/pdf/vector")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/pdf/vector",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Convert PDF to vector format",
             description =

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

@@ -27,6 +27,7 @@ import stirling.software.SPDF.model.api.filter.PageRotationRequest;
 import stirling.software.SPDF.model.api.filter.PageSizeRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.FilterApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.PdfUtils;
@@ -42,7 +43,8 @@ public class FilterController {
 
     @AutoJobPostMapping(
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
-            value = "/filter-contains-text")
+            value = "/filter-contains-text",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Checks if a PDF contains set text, returns true if does",
             description = "Input:PDF Output:Boolean Type:SISO")
@@ -75,7 +77,8 @@ public class FilterController {
 
     @AutoJobPostMapping(
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
-            value = "/filter-contains-image")
+            value = "/filter-contains-image",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Checks if a PDF contains an image",
             description = "Input:PDF Output:Boolean Type:SISO")
@@ -107,7 +110,8 @@ public class FilterController {
 
     @AutoJobPostMapping(
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
-            value = "/filter-page-count")
+            value = "/filter-page-count",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Checks if a PDF is greater, less or equal to a setPageCount",
             description = "Input:PDF Output:Boolean Type:SISO")
@@ -138,7 +142,10 @@ public class FilterController {
                 : ResponseEntity.noContent().build();
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/filter-page-size")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/filter-page-size",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Checks if a PDF is of a certain size",
             description = "Input:PDF Output:Boolean Type:SISO")
@@ -175,7 +182,10 @@ public class FilterController {
                 : ResponseEntity.noContent().build();
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/filter-file-size")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/filter-file-size",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Checks if a PDF is a set file size",
             description = "Input:PDF Output:Boolean Type:SISO")
@@ -205,7 +215,8 @@ public class FilterController {
 
     @AutoJobPostMapping(
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
-            value = "/filter-page-rotation")
+            value = "/filter-page-rotation",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Checks if a PDF is of a certain rotation",
             description = "Input:PDF Output:Boolean Type:SISO")

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

@@ -23,6 +23,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.misc.AddCommentsRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.comments.AnnotationLocation;
 import stirling.software.common.model.api.comments.StickyNoteSpec;
 import stirling.software.common.service.CustomPDFDocumentFactory;
@@ -66,7 +67,10 @@ public class AddCommentsController {
     private final PdfTextLocator pdfTextLocator;
     private final ObjectMapper objectMapper;
 
-    @AutoJobPostMapping(value = "/add-comments", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/add-comments",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Add sticky-note comments to a PDF at specified positions or anchored text",

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

@@ -28,6 +28,7 @@ import stirling.software.SPDF.model.api.misc.RenameAttachmentRequest;
 import stirling.software.SPDF.service.AttachmentServiceInterface;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -48,7 +49,10 @@ public class AttachmentController {
 
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/add-attachments")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/add-attachments",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Add attachments to PDF",

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

@@ -23,6 +23,7 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.SPDF.model.api.misc.ExtractHeaderRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.RegexPatternUtils;
 import stirling.software.common.util.TempFileManager;
@@ -39,7 +40,10 @@ public class AutoRenameController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/auto-rename")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/auto-rename",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @Operation(
             summary = "Extract header from PDF file",
             description =

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

@@ -38,6 +38,7 @@ import stirling.software.SPDF.config.swagger.MultiFileResponse;
 import stirling.software.SPDF.model.api.misc.AutoSplitPdfRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
@@ -267,7 +268,10 @@ public class AutoSplitPdfController {
         return QR_DETECTION_DPI;
     }
 
-    @AutoJobPostMapping(value = "/auto-split-pdf", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/auto-split-pdf",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Auto split PDF pages into separate documents",

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

@@ -31,6 +31,7 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.SPDF.model.api.misc.RemoveBlankPagesRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ApplicationContextProvider;
@@ -81,7 +82,10 @@ public class BlankPageController {
         return whitePixelPercentage >= whitePercent;
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/remove-blanks")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/remove-blanks",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Remove blank pages from a PDF file",
             description =

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

@@ -49,6 +49,7 @@ import stirling.software.SPDF.config.EndpointConfiguration;
 import stirling.software.SPDF.model.api.misc.OptimizePdfRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.service.LineArtConversionService;
 import stirling.software.common.util.ExceptionUtils;
@@ -922,7 +923,10 @@ public class CompressController {
         return Math.min(9, currentLevel + 1);
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/compress-pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/compress-pdf",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Optimize PDF file",
             description =

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

@@ -22,6 +22,7 @@ import lombok.extern.slf4j.Slf4j;
 
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
@@ -38,7 +39,10 @@ public class DecompressPdfController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(value = "/decompress-pdf", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/decompress-pdf",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Decompress PDF streams",
             description = "Fully decompresses all PDF streams including text content")

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

@@ -32,6 +32,7 @@ import stirling.software.SPDF.config.swagger.MultiFileResponse;
 import stirling.software.SPDF.model.api.misc.ExtractImageScansRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ApplicationContextProvider;
@@ -56,7 +57,8 @@ public class ExtractImageScansController {
 
     @AutoJobPostMapping(
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
-            value = "/extract-image-scans")
+            value = "/extract-image-scans",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Extract image scans from an input file",

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

@@ -34,6 +34,7 @@ import stirling.software.SPDF.config.swagger.MultiFileResponse;
 import stirling.software.SPDF.model.api.PDFExtractImagesRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -49,7 +50,10 @@ public class ExtractImagesController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/extract-images")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/extract-images",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Extract images from a PDF file",

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

@@ -27,6 +27,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.misc.FlattenRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ApplicationContextProvider;
@@ -42,7 +43,10 @@ public class FlattenController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/flatten")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/flatten",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Flatten PDF form fields or full page",

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

@@ -25,6 +25,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.misc.MetadataRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.service.PdfMetadataService;
 import stirling.software.common.util.GeneralUtils;
@@ -56,7 +57,10 @@ public class MetadataController {
         binder.registerCustomEditor(Map.class, "allRequestParams", new StringToMapPropertyEditor());
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/update-metadata")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/update-metadata",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Update metadata of a PDF file",

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

@@ -38,6 +38,7 @@ import stirling.software.SPDF.model.api.misc.ProcessPdfWithOcrRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
@@ -82,7 +83,10 @@ public class OCRController {
                 .toList();
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/ocr-pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/ocr-pdf",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Process a PDF file with OCR",
             description =

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

@@ -22,6 +22,7 @@ import stirling.software.SPDF.model.api.misc.OverlayImageRequest;
 import stirling.software.SPDF.utils.SvgOverlayUtil;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.TempFile;
@@ -36,7 +37,10 @@ public class OverlayImageController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/add-image")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/add-image",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Overlay image onto a PDF file",
             description =

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

@@ -26,6 +26,7 @@ import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.misc.AddPageNumbersRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.TempFile;
@@ -39,7 +40,10 @@ public class PageNumbersController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(value = "/add-page-numbers", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/add-page-numbers",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Add page numbers to a PDF document",

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

@@ -25,6 +25,7 @@ import lombok.extern.slf4j.Slf4j;
 
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.GeneralApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
@@ -41,7 +42,10 @@ public class RemoveImagesController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/remove-image-pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/remove-image-pdf",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Remove images from PDF",
             description =

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

@@ -19,6 +19,7 @@ import stirling.software.SPDF.config.EndpointConfiguration;
 import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
@@ -46,7 +47,10 @@ public class RepairController {
         return endpointConfiguration.isGroupEnabled("qpdf");
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/repair")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/repair",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Repair a PDF file",

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

@@ -19,6 +19,7 @@ import stirling.software.SPDF.model.api.misc.ReplaceAndInvertColorRequest;
 import stirling.software.SPDF.service.misc.ReplaceAndInvertColorService;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.TempFile;
 import stirling.software.common.util.TempFileManager;
@@ -33,7 +34,8 @@ public class ReplaceAndInvertColorController {
 
     @AutoJobPostMapping(
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
-            value = "/replace-invert-pdf")
+            value = "/replace-invert-pdf",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Replace-Invert Color PDF",
             description =

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

@@ -46,6 +46,7 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.SPDF.model.api.misc.ScannerEffectRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ApplicationContextProvider;
@@ -559,7 +560,10 @@ public class ScannerEffectController {
         }
     }
 
-    @AutoJobPostMapping(value = "/scanner-effect", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/scanner-effect",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @Operation(
             summary = "Apply scanner effect to PDF",
             description =

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

@@ -21,6 +21,7 @@ import lombok.RequiredArgsConstructor;
 import stirling.software.SPDF.config.swagger.JavaScriptResponse;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.TempFile;
@@ -34,7 +35,10 @@ public class ShowJavascript {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/show-javascript")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/show-javascript",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @JavaScriptResponse
     @Operation(
             summary = "Grabs all JS from a PDF and returns a single JS file with all code",

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

@@ -46,6 +46,7 @@ import lombok.RequiredArgsConstructor;
 import stirling.software.SPDF.model.api.misc.AddStampRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -86,7 +87,10 @@ public class StampController {
                 });
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/add-stamp")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/add-stamp",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Add stamp to a PDF file",
             description =

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

@@ -23,6 +23,7 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.MiscApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
@@ -42,7 +43,10 @@ public class UnlockPDFFormsController {
         this.tempFileManager = tempFileManager;
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/unlock-pdf-forms")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/unlock-pdf-forms",
+            resourceWeight = ResourceWeight.SMALL_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Remove read-only property from form fields",

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

@@ -26,6 +26,7 @@ import stirling.software.SPDF.model.PipelineResult;
 import stirling.software.SPDF.model.api.HandleDataRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.PipelineApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.PostHogService;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.TempFile;
@@ -49,7 +50,10 @@ public class PipelineController {
 
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(value = "/handleData", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/handleData",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @MultiFileResponse
     @Operation(
             summary = "Execute automated PDF processing pipeline",

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

@@ -75,6 +75,7 @@ import lombok.extern.slf4j.Slf4j;
 import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.security.SignPDFWithCertRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.service.ServerCertificateServiceInterface;
 import stirling.software.common.util.ExceptionUtils;
@@ -160,7 +161,8 @@ public class CertSignController {
                 MediaType.MULTIPART_FORM_DATA_VALUE,
                 MediaType.APPLICATION_FORM_URLENCODED_VALUE
             },
-            value = "/cert-sign")
+            value = "/cert-sign",
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Sign PDF with a Digital Certificate",

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

@@ -56,6 +56,7 @@ import stirling.software.SPDF.model.api.security.PDFVerificationResult;
 import stirling.software.SPDF.service.VeraPDFService;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.SecurityApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
@@ -1061,7 +1062,10 @@ public class GetInfoOnPDF {
         return stats;
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/get-info-on-pdf")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/get-info-on-pdf",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @Operation(
             summary = "Get comprehensive PDF information",
             description =

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

@@ -20,6 +20,7 @@ import stirling.software.SPDF.model.api.security.AddPasswordRequest;
 import stirling.software.SPDF.model.api.security.PDFPasswordRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.SecurityApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
 import stirling.software.common.util.GeneralUtils;
@@ -33,7 +34,10 @@ public class PasswordController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/remove-password")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/remove-password",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Remove password from a PDF file",
@@ -62,7 +66,10 @@ public class PasswordController {
         }
     }
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/add-password")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/add-password",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Add password to a PDF file",

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

@@ -59,6 +59,7 @@ import stirling.software.SPDF.utils.text.TextFinderUtils;
 import stirling.software.SPDF.utils.text.WidthCalculator;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.SecurityApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.security.RedactionArea;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.ExceptionUtils;
@@ -101,7 +102,10 @@ public class RedactController {
                 new StringToArrayListPropertyEditor<>(RedactionArea.class));
     }
 
-    @AutoJobPostMapping(value = "/redact", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/redact",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @StandardPdfResponse
     @Operation(
             operationId = "redactPdfManual",
@@ -494,7 +498,10 @@ public class RedactController {
         return pageNumbers;
     }
 
-    @AutoJobPostMapping(value = "/auto-redact", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @AutoJobPostMapping(
+            value = "/auto-redact",
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            resourceWeight = ResourceWeight.LARGE_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Redact PDF automatically",

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

@@ -20,6 +20,7 @@ import lombok.RequiredArgsConstructor;
 import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.common.annotations.AutoJobPostMapping;
 import stirling.software.common.annotations.api.SecurityApi;
+import stirling.software.common.enumeration.ResourceWeight;
 import stirling.software.common.model.api.PDFFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.util.GeneralUtils;
@@ -33,7 +34,10 @@ public class RemoveCertSignController {
     private final CustomPDFDocumentFactory pdfDocumentFactory;
     private final TempFileManager tempFileManager;
 
-    @AutoJobPostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE, value = "/remove-cert-sign")
+    @AutoJobPostMapping(
+            consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
+            value = "/remove-cert-sign",
+            resourceWeight = ResourceWeight.MEDIUM_WEIGHT)
     @StandardPdfResponse
     @Operation(
             summary = "Remove digital signature from PDF",