chore: update dependencies

fix(libreoffice): wrong HTTP status codes if invalid PDF formats
chore: update Go dependencies
2026-08-08 08:32:16 +01:00 · 2024-02-07 10:44:30 +01:00 · 2024-01-18 12:15:39 +01:00 · 2024-01-18 12:15:39 +01:00 · 2024-01-10 11:55:05 +01:00 · 2024-01-08 11:44:56 +01:00
144 changed files with 17214 additions and 23997 deletions
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -0,0 +1,8 @@
+version: 2
+updates:
+
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
--- a/.github/stale.yml
+++ b/.github/stale.yml
@@ -0,0 +1,18 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 15
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - bug
+  - documentation
+  - enhancement
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false
--- a/.github/workflows/continuous_delivery.yml
+++ b/.github/workflows/continuous_delivery.yml
@@ -5,23 +5,22 @@ on:
    types: [ published ]

 jobs:
-
  release:
    name: Release Docker image
    runs-on: ubuntu-latest
    steps:
      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v3
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v3
      - name: Checkout source code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
      - name: Log in to Docker Hub Container Registry
-        uses: docker/login-action@v1
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Build and push Docker image
+      - name: Build and push Docker image for release
        run: |
          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }}
-          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }} DOCKER_REGISTRY=thecodingmachine
+          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }} DOCKER_REPOSITORY=thecodingmachine
--- a/.github/workflows/continuous_integration.yml
+++ b/.github/workflows/continuous_integration.yml
@@ -14,12 +14,17 @@ jobs:
    name: Lint
    runs-on: ubuntu-latest
    steps:
-      - name: Checkout source code
-        uses: actions/checkout@v2
-      - name: Run linters
-        uses: golangci/golangci-lint-action@v2
+      - name: Setup Go
+        uses: actions/setup-go@v5
        with:
-          version: v1.39
+          go-version: '1.21'
+          cache: false
+      - name: Checkout source code
+        uses: actions/checkout@v4
+      - name: Run linters
+        uses: golangci/golangci-lint-action@v3
+        with:
+          version: v1.55.2

  tests:
    needs:
@@ -30,14 +35,37 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v3
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v3
      - name: Checkout source code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
      - name: Build testing environment
        run: make build build-tests
      - name: Run tests
        run: |
          make tests-once
-          bash <(curl -s https://codecov.io/bash)
+          bash <(curl -s https://codecov.io/bash)
+
+  multiarch_build:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs:
+      - Tests
+    name: Multi-arch build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Checkout source code
+        uses: actions/checkout@v4
+      - name: Log in to Docker Hub Container Registry
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push Docker image for main branch
+        run: |
+          make release GOTENBERG_VERSION=edge
+          make release GOTENBERG_VERSION=edge DOCKER_REPOSITORY=thecodingmachine
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 /coverage.html
-/coverage.txt
+/coverage.txt
+/TODO.txt
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,11 +1,19 @@
+linters-settings:
+  gci:
+    sections:
+      - standard
+      - default
+      - prefix(github.com/gotenberg/gotenberg/v8)
+    skip-generated: true
+    custom-order: true
+
 linters:
  disable-all: true
  enable:
    - bodyclose
-    - deadcode
    - errcheck
-    - gofmt
-    - goimports
+    - gci
+    - gofumpt
    - gosec
    - gosimple
    - govet
@@ -13,14 +21,12 @@ linters:
    - misspell
    - prealloc
    - staticcheck
-    - structcheck
    - typecheck
    - unconvert
    - unused
-    - varcheck

 run:
-  deadline: 5m
+  timeout: 5m
  issues-exit-code: 1
  tests: false

--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2021 Julien Neuhart
+Copyright (c) 2024 Julien Neuhart

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/127
+++ b/127
@@ -5,13 +5,14 @@ help: ## Show the help
 .PHONY: it
 it: build build-tests ## Initialize the development environment

-GOLANG_VERSION=1.16
-DOCKER_REGISTRY=gotenberg
+GOLANG_VERSION=1.21
+DOCKER_REPOSITORY=gotenberg
 GOTENBERG_VERSION=snapshot
 GOTENBERG_USER_GID=1001
 GOTENBERG_USER_UID=1001
-PDFTK_VERSION=1353200058 # See https://gitlab.com/pdftk-java/pdftk/-/releases - Binary package.
-GOLANGCI_LINT_VERSION=v1.39.0 # See https://github.com/golangci/golangci-lint/releases.
+NOTO_COLOR_EMOJI_VERSION=v2.042 # See https://github.com/googlefonts/noto-emoji/releases.
+PDFTK_VERSION=v3.3.3 # See https://gitlab.com/pdftk-java/pdftk/-/releases - Binary package.
+GOLANGCI_LINT_VERSION=v1.55.2 # See https://github.com/golangci/golangci-lint/releases.

 .PHONY: build
 build: ## Build the Gotenberg's Docker image
@@ -20,114 +21,156 @@ build: ## Build the Gotenberg's Docker image
 	--build-arg GOTENBERG_VERSION=$(GOTENBERG_VERSION) \
 	--build-arg GOTENBERG_USER_GID=$(GOTENBERG_USER_GID) \
 	--build-arg GOTENBERG_USER_UID=$(GOTENBERG_USER_UID) \
+	--build-arg NOTO_COLOR_EMOJI_VERSION=$(NOTO_COLOR_EMOJI_VERSION) \
 	--build-arg PDFTK_VERSION=$(PDFTK_VERSION) \
-	-t $(DOCKER_REGISTRY)/gotenberg:$(GOTENBERG_VERSION) \
+	-t $(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION) \
 	-f build/Dockerfile .

 GOTENBERG_GRACEFUL_SHUTDOWN_DURATION=30s
 API_PORT=3000
 API_PORT_FROM_ENV=
-API_READ_TIMEOUT=30s
-API_PROCESS_TIMEOUT=30s
-API_WRITE_TIMEOUT=30s
+API_START_TIMEOUT=30s
+API_TIMEOUT=30s
 API_ROOT_PATH=/
 API_TRACE_HEADER=Gotenberg-Trace
 API_DISABLE_HEALTH_CHECK_LOGGING=false
-API_WEBHOOK_ALLOW_LIST=
-API_WEBHOOK_DENY_LIST=
-API_WEBHOOK_ERROR_ALLOW_LIST=
-API_WEBHOOK_ERROR_DENY_LIST=
-API_WEBHOOK_MAX_RETRY=4
-API_WEBHOOK_RETRY_MIN_WAIT=1s
-API_WEBHOOK_RETRY_MAX_WAIT=30s
-API_DISABLE_WEBHOOK=false
-CHROMIUM_USER_AGENT=
+CHROMIUM_RESTART_AFTER=0
+CHROMIUM_AUTO_START=false
+CHROMIUM_START_TIMEOUT=20s
 CHROMIUM_INCOGNITO=false
+CHROMIUM_ALLOW_INSECURE_LOCALHOST=false
 CHROMIUM_IGNORE_CERTIFICATE_ERRORS=false
+CHROMIUM_DISABLE_WEB_SECURITY=false
+CHROMIUM_ALLOW_FILE_ACCESS_FROM_FILES=false
+CHROMIUM_HOST_RESOLVER_RULES=
+CHROMIUM_PROXY_SERVER=
 CHROMIUM_ALLOW_LIST=
 CHROMIUM_DENY_LIST="^file:///[^tmp].*"
+CHROMIUM_CLEAR_CACHE=false
+CHROMIUM_CLEAR_COOKIES=false
+CHROMIUM_DISABLE_JAVASCRIPT=false
 CHROMIUM_DISABLE_ROUTES=false
-LIBREOFFICE_DISABLES_ROUTES=false
+LIBREOFFICE_RESTART_AFTER=10
+LIBREOFFICE_AUTO_START=false
+LIBREOFFICE_START_TIMEOUT=20s
+LIBREOFFICE_DISABLE_ROUTES=false
 LOG_LEVEL=info
 LOG_FORMAT=auto
+LOG_FIELDS_PREFIX=
 PDFENGINES_ENGINES=
 PDFENGINES_DISABLE_ROUTES=false
+PROMETHEUS_NAMESPACE=gotenberg
+PROMETHEUS_COLLECT_INTERVAL=1s
+PROMETHEUS_DISABLE_ROUTE_LOGGING=false
+PROMETHEUS_DISABLE_COLLECT=false
+WEBHOOK_ALLOW_LIST=
+WEBHOOK_DENY_LIST=
+WEBHOOK_ERROR_ALLOW_LIST=
+WEBHOOK_ERROR_DENY_LIST=
+WEBHOOK_MAX_RETRY=4
+WEBHOOK_RETRY_MIN_WAIT=1s
+WEBHOOK_RETRY_MAX_WAIT=30s
+WEBHOOK_CLIENT_TIMEOUT=30s
+WEBHOOK_DISABLE=false

 .PHONY: run
 run: ## Start a Gotenberg container
 	docker run --rm -it \
 	-p $(API_PORT):$(API_PORT) \
-	$(DOCKER_REGISTRY)/gotenberg:$(GOTENBERG_VERSION) \
+	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION) \
 	gotenberg \
 	--gotenberg-graceful-shutdown-duration=$(GOTENBERG_GRACEFUL_SHUTDOWN_DURATION) \
 	--api-port=$(API_PORT) \
 	--api-port-from-env=$(API_PORT_FROM_ENV) \
-	--api-read-timeout=$(API_READ_TIMEOUT) \
-	--api-process-timeout=$(API_PROCESS_TIMEOUT) \
-	--api-write-timeout=$(API_WRITE_TIMEOUT) \
+	--api-start-timeout=$(API_START_TIMEOUT) \
+	--api-timeout=$(API_TIMEOUT) \
 	--api-root-path=$(API_ROOT_PATH) \
 	--api-trace-header=$(API_TRACE_HEADER) \
 	--api-disable-health-check-logging=$(API_DISABLE_HEALTH_CHECK_LOGGING) \
-	--api-webhook-allow-list=$(API_WEBHOOK_ALLOW_LIST) \
-	--api-webhook-deny-list=$(API_WEBHOOK_DENY_LIST) \
-	--api-webhook-error-allow-list=$(API_WEBHOOK_ERROR_ALLOW_LIST) \
-	--api-webhook-error-deny-list=$(API_WEBHOOK_ERROR_DENY_LIST) \
-	--api-webhook-max-retry=$(API_WEBHOOK_MAX_RETRY) \
-	--api-webhook-retry-min-wait=$(API_WEBHOOK_RETRY_MIN_WAIT) \
-	--api-webhook-retry-max-wait=$(API_WEBHOOK_RETRY_MAX_WAIT) \
-	--api-disable-webhook=$(API_DISABLE_WEBHOOK) \
-	--chromium-user-agent=$(CHROMIUM_USER_AGENT) \
+	--chromium-restart-after=$(CHROMIUM_RESTART_AFTER) \
+	--chromium-auto-start=$(CHROMIUM_AUTO_START) \
+	--chromium-start-timeout=$(CHROMIUM_START_TIMEOUT) \
 	--chromium-incognito=$(CHROMIUM_INCOGNITO) \
+	--chromium-allow-insecure-localhost=$(CHROMIUM_ALLOW_INSECURE_LOCALHOST) \
 	--chromium-ignore-certificate-errors=$(CHROMIUM_IGNORE_CERTIFICATE_ERRORS) \
+	--chromium-disable-web-security=$(CHROMIUM_DISABLE_WEB_SECURITY) \
+	--chromium-allow-file-access-from-files=$(CHROMIUM_ALLOW_FILE_ACCESS_FROM_FILES) \
+	--chromium-host-resolver-rules=$(CHROMIUM_HOST_RESOLVER_RULES) \
+	--chromium-proxy-server=$(CHROMIUM_PROXY_SERVER) \
 	--chromium-allow-list=$(CHROMIUM_ALLOW_LIST) \
 	--chromium-deny-list=$(CHROMIUM_DENY_LIST) \
+	--chromium-clear-cache=$(CHROMIUM_CLEAR_CACHE) \
+	--chromium-clear-cookies=$(CHROMIUM_CLEAR_COOKIES) \
+	--chromium-disable-javascript=$(CHROMIUM_DISABLE_JAVASCRIPT) \
 	--chromium-disable-routes=$(CHROMIUM_DISABLE_ROUTES) \
-	--libreoffice-disable-routes=$(LIBREOFFICE_DISABLES_ROUTES) \
+	--libreoffice-restart-after=$(LIBREOFFICE_RESTART_AFTER) \
+	--libreoffice-auto-start=$(LIBREOFFICE_AUTO_START) \
+	--libreoffice-start-timeout=$(LIBREOFFICE_START_TIMEOUT) \
+	--libreoffice-disable-routes=$(LIBREOFFICE_DISABLE_ROUTES) \
 	--log-level=$(LOG_LEVEL) \
 	--log-format=$(LOG_FORMAT) \
+	--log-fields-prefix=$(LOG_FIELDS_PREFIX) \
 	--pdfengines-engines=$(PDFENGINES_ENGINES) \
-	--pdfengines-disable-routes=$(PDFENGINES_DISABLE_ROUTES)
+	--pdfengines-disable-routes=$(PDFENGINES_DISABLE_ROUTES) \
+	--prometheus-namespace=$(PROMETHEUS_NAMESPACE) \
+	--prometheus-collect-interval=$(PROMETHEUS_COLLECT_INTERVAL) \
+	--prometheus-disable-route-logging=$(PROMETHEUS_DISABLE_ROUTE_LOGGING) \
+	--prometheus-disable-collect=$(PROMETHEUS_DISABLE_COLLECT) \
+	--webhook-allow-list=$(WEBHOOK_ALLOW_LIST) \
+	--webhook-deny-list=$(WEBHOOK_DENY_LIST) \
+	--webhook-error-allow-list=$(WEBHOOK_ERROR_ALLOW_LIST) \
+	--webhook-error-deny-list=$(WEBHOOK_ERROR_DENY_LIST) \
+	--webhook-max-retry=$(WEBHOOK_MAX_RETRY) \
+	--webhook-retry-min-wait=$(WEBHOOK_RETRY_MIN_WAIT) \
+	--webhook-retry-max-wait=$(WEBHOOK_RETRY_MAX_WAIT) \
+	--webhook-client-timeout=$(WEBHOOK_CLIENT_TIMEOUT) \
+	--webhook-disable=$(WEBHOOK_DISABLE)

 .PHONY: build-tests
 build-tests: ## Build the tests' Docker image
 	docker build \
 	--build-arg GOLANG_VERSION=$(GOLANG_VERSION) \
-	--build-arg DOCKER_REGISTRY=$(DOCKER_REGISTRY) \
+	--build-arg DOCKER_REPOSITORY=$(DOCKER_REPOSITORY) \
 	--build-arg GOTENBERG_VERSION=$(GOTENBERG_VERSION) \
 	--build-arg GOLANGCI_LINT_VERSION=$(GOLANGCI_LINT_VERSION) \
-	-t $(DOCKER_REGISTRY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	-t $(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
 	-f test/Dockerfile .

 .PHONY: tests
 tests: ## Start the testing environment
 	docker run --rm -it \
 	-v $(PWD):/tests \
-	$(DOCKER_REGISTRY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
 	bash

 .PHONY: tests-once
 tests-once: ## Run the tests once (prefer the "tests" command while developing)
 	docker run --rm  \
 	-v $(PWD):/tests \
-	$(DOCKER_REGISTRY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
 	gotest

+# go install mvdan.cc/gofumpt@latest
+# go install github.com/daixiang0/gci@latest
 .PHONY: fmt
 fmt: ## Format the code and "optimize" the dependencies
-	go fmt ./...
+	gofumpt -l -w .
+	gci write -s standard -s default -s "prefix(github.com/gotenberg/gotenberg/v8)" --skip-generated --skip-vendor --custom-order .
 	go mod tidy

+# go install golang.org/x/tools/cmd/godoc@latest
 .PHONY: godoc
-godoc: ## Run a webserver with Gotenberg godoc (go get golang.org/x/tools/cmd/godoc)
-	$(info http://localhost:6060/pkg/github.com/gotenberg/gotenberg/v7)
+godoc: ## Run a webserver with Gotenberg godoc
+	$(info http://localhost:6060/pkg/github.com/gotenberg/gotenberg/v8)
 	godoc -http=:6060

 .PHONY: release
-release: ## Build the Gotenberg's Docker image for linux/amd64 and linux/arm64 platforms, then push it to a Docker Registry
+release: ## Build the Gotenberg's Docker image for many platforms, then push it to a Docker repository
 	./scripts/release.sh \
 	$(GOLANG_VERSION) \
 	$(GOTENBERG_VERSION) \
 	$(GOTENBERG_USER_GID) \
 	$(GOTENBERG_USER_UID) \
+	$(NOTO_COLOR_EMOJI_VERSION) \
 	$(PDFTK_VERSION) \
-	$(DOCKER_REGISTRY)
+	$(DOCKER_REPOSITORY)
--- a/README.md
+++ b/README.md
@@ -1,32 +1,32 @@
 <p align="center">
    <img src="https://user-images.githubusercontent.com/8983173/130322857-185831e2-f041-46eb-a17f-0a69d066c4e5.png" alt="Gotenberg Logo" width="150" height="150" />
-<h3 align="center">Gotenberg</h3>
-<p align="center">A Docker-powered stateless API for PDF files</p>
-<p align="center"><a href="https://gotenberg.dev/docs/about">Documentation</a><!-- &#183; <a href="#">OpenAPI</a></p>-->
+    <h3 align="center">Gotenberg</h3>
+    <p align="center">A Docker-powered stateless API for PDF files</p>
+    <p align="center"><a href="https://gotenberg.dev/docs/getting-started/introduction">Documentation</a> &#183; <a href="https://gotenberg.dev/docs/getting-started/installation#live-demo-">Live Demo</a> 🔥</p>
 </p>

 ---

-Gotenberg provides a developer-friendly API to interact with powerful tools like Chromium and LibreOffice to convert many
-documents to PDF, transform them, merge them, and more!
+Gotenberg provides a developer-friendly API to interact with powerful tools like Chromium and LibreOffice for converting 
+numerous document formats (HTML, Markdown, Word, Excel, etc.) into PDF files, and more!

 ## Quick Start

 Open a terminal and run the following command:

 ```
-docker run --rm -p 3000:3000 gotenberg/gotenberg:7
+docker run --rm -p 3000:3000 gotenberg/gotenberg:8
 ```

-Alternatively, using the historic Docker registry from our sponsor [TheCodingMachine](https://www.thecodingmachine.com):
+Alternatively, using the historic Docker repository from our sponsor [TheCodingMachine](https://www.thecodingmachine.com):

 ```
-docker run --rm -p 3000:3000 thecodingmachine/gotenberg:7
+docker run --rm -p 3000:3000 thecodingmachine/gotenberg:8
 ```

 The API is now available on your host at http://localhost:3000.

-Head to the [documentation](https://gotenberg.dev/docs/about) to learn how to interact with it 🚀
+Head to the [documentation](https://gotenberg.dev/docs/getting-started/introduction) to learn how to interact with it 🚀

 ## Sponsors

@@ -41,6 +41,5 @@ Head to the [documentation](https://gotenberg.dev/docs/about) to learn how to in
 [![Docker pulls](https://img.shields.io/docker/pulls/gotenberg/gotenberg)](https://hub.docker.com/r/gotenberg/gotenberg)
 [![Docker pulls](https://img.shields.io/docker/pulls/thecodingmachine/gotenberg)](https://hub.docker.com/r/thecodingmachine/gotenberg)
 [![Continuous Integration](https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml)
-[![Go Reference](https://pkg.go.dev/badge/github.com/gotenberg/gotenberg.svg)](https://pkg.go.dev/github.com/gotenberg/gotenberg/v7)
+[![Go Reference](https://pkg.go.dev/badge/github.com/gotenberg/gotenberg.svg)](https://pkg.go.dev/github.com/gotenberg/gotenberg/v8)
 [![Codecov](https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg)](https://codecov.io/gh/gotenberg/gotenberg)
-[![Go Report Card](https://goreportcard.com/badge/github.com/gotenberg/gotenberg)](https://goreportcard.com/report/gotenberg/gotenberg)
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -0,0 +1,41 @@
+# Security Policy
+
+## Supported Versions
+
+Please ensure to keep your environment up-to-date and use only the latest version of Gotenberg. 
+Security updates and patches will be applied only to the most recent version.
+
+## Reporting a Vulnerability
+
+Your help in identifying vulnerabilities in our project is much appreciated. 
+We take all reports regarding security seriously.
+
+If you discover a security vulnerability, please refrain from publishing it publicly. 
+Instead, kindly send us the details via email to *neuhart [dot] julien [at] gmail [dot] com*.
+
+In the subject of your email, please indicate that it's a security vulnerability report for Gotenberg. 
+In your message, please include:
+
+* A detailed description of the vulnerability.
+* The steps to reproduce the issue.
+* Any potential impact of the vulnerability on the users or system.
+
+Please remember that this process is done in a *'best-effort'* manner. 
+This means we strive to respond and act as quickly as possible, but the speed may vary depending on the severity of
+the issue and our resources.
+
+Thank you in advance for helping to keep our project safe!
+
+## Disclosure Policy
+
+Once we have received your vulnerability report, we will work to validate and reproduce the issue. 
+If we can confirm the vulnerability, we will proceed to:
+
+* Work on a fix and a release timeline.
+* Notify you when the fix has been implemented and released.
+* Credit you for discovering the vulnerability (unless you request anonymity).
+* Please note that we will do our best to keep you informed about the progress towards resolving the issue.
+
+## Comments on this Policy
+
+If you have suggestions on how this process could be improved, please submit a pull request.
--- a/build/Dockerfile
+++ b/build/Dockerfile
@@ -1,10 +1,14 @@
-# Note: ARG instructions do not create additional layers.
-# Instead, next layers will concatenate them.
+# ARG instructions do not create additional layers. Instead, next layers will
+# concatenate them. Also, we have to repeat ARG instructions in each build
+# stage that uses them.
 ARG GOLANG_VERSION
+
+# ----------------------------------------------
+# Gotenberg binary build stage
+# ----------------------------------------------
+FROM golang:$GOLANG_VERSION AS binary-stage
+
 ARG GOTENBERG_VERSION
-
-FROM golang:$GOLANG_VERSION AS builder
-
 ENV CGO_ENABLED 0

 # Define the working directory outside of $GOPATH (we're using go modules).
@@ -18,33 +22,28 @@ RUN go mod download &&\

 # Copy the source code.
 COPY cmd ./cmd
-COPY internal ./internal
 COPY pkg ./pkg

-# Build the binary.
-RUN go build -o gotenberg -ldflags "-X gotenberg.version=$GOTENBERG_VERSION" cmd/gotenberg/main.go
+RUN go build -o gotenberg -ldflags "-X 'github.com/gotenberg/gotenberg/v8/cmd.Version=$GOTENBERG_VERSION'" cmd/gotenberg/main.go

-FROM debian:buster-slim
+# ----------------------------------------------
+# Final stage
+# ----------------------------------------------
+FROM debian:12-slim

-LABEL author="Julien Neuhart" \
-      description="A Docker-powered stateless API for PDF files." \
-      github="https://github.com/gotenberg/gotenberg" \
-      version="$GOTENBER_VERSION" \
-      website="https://gotenberg.dev"
-
-# Improve fonts subpixel hinting and smoothing.
-# Credits:
-# https://github.com/arachnys/athenapdf/issues/69.
-# https://github.com/arachnys/athenapdf/commit/ba25a8d80a25d08d58865519c4cd8756dc9a336d.
-COPY build/fonts.conf /etc/fonts/conf.d/100-gotenberg.conf
-
-# Simple wrapper around Java and PDFtk.
-COPY build/pdftk.sh /usr/bin/pdftk
-
-# Setup the Docker image.
+ARG GOTENBERG_VERSION
 ARG GOTENBERG_USER_GID
 ARG GOTENBERG_USER_UID
+ARG NOTO_COLOR_EMOJI_VERSION
 ARG PDFTK_VERSION
+ARG TMP_CHOMIUM_VERSION_ARMHF="116.0.5845.180-1~deb12u1"
+
+LABEL org.opencontainers.image.title="Gotenberg" \
+      org.opencontainers.image.description="A Docker-powered stateless API for PDF files." \
+      org.opencontainers.image.version="$GOTENBERG_VERSION" \
+      org.opencontainers.image.authors="Julien Neuhart <neuhart.julien@gmail.com>" \
+      org.opencontainers.image.documentation="https://gotenberg.dev" \
+      org.opencontainers.image.source="https://github.com/gotenberg/gotenberg"

 RUN \
    # Create a non-root user.
@@ -52,19 +51,28 @@ RUN \
    groupadd --gid "$GOTENBERG_USER_GID" gotenberg &&\
    useradd --uid "$GOTENBERG_USER_UID" --gid gotenberg --shell /bin/bash --home /home/gotenberg --no-create-home gotenberg &&\
    mkdir /home/gotenberg &&\
-    chown gotenberg: /home/gotenberg &&\
-    # Install dependencies required for the next instructions or debugging.
-    # Note: procps for "top" command (useful when debugging processes).
+    chown gotenberg: /home/gotenberg
+
+RUN \
+    # Install system dependencies required for the next instructions or debugging.
    # Note: tini is a helper for reaping zombie processes.
    apt-get update -qq &&\
-    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends curl gnupg procps tini &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends curl gnupg tini python3 default-jre-headless &&\
+    # Cleanup.
+    # Note: the Debian image does automatically a clean after each install thanks to a hook.
+    # Therefore, there is no need for apt-get clean.
+    # See https://stackoverflow.com/a/24417119/3248473.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+RUN \
    # Install fonts.
    # Credits:
    # https://github.com/arachnys/athenapdf/blob/master/cli/Dockerfile.
    # https://help.accusoft.com/PrizmDoc/v12.1/HTML/Installing_Asian_Fonts_on_Ubuntu_and_Debian.html.
-    curl -o ./ttf-mscorefonts-installer_3.8_all.deb http://httpredir.debian.org/debian/pool/contrib/m/msttcorefonts/ttf-mscorefonts-installer_3.8_all.deb &&\
+    curl -o ./ttf-mscorefonts-installer_3.8.1_all.deb http://httpredir.debian.org/debian/pool/contrib/m/msttcorefonts/ttf-mscorefonts-installer_3.8.1_all.deb &&\
+    apt-get update -qq &&\
    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends \
-    ./ttf-mscorefonts-installer_3.8_all.deb \
+    ./ttf-mscorefonts-installer_3.8.1_all.deb \
    culmus \
    fonts-beng \
    fonts-hosny-amiri \
@@ -80,6 +88,7 @@ RUN \
    fonts-telu \
    fonts-thai-tlwg \
    ttf-wqy-zenhei \
+    fonts-arphic-ukai \
    fonts-arphic-uming \
    fonts-ipafont-mincho \
    fonts-ipafont-gothic \
@@ -92,48 +101,100 @@ RUN \
    fonts-liberation \
    fonts-liberation2 \
    fonts-linuxlibertine \
+    fonts-noto-cjk \
    fonts-noto-core \
    fonts-noto-mono \
    fonts-noto-ui-core \
    fonts-sil-gentium \
    fonts-sil-gentium-basic &&\
-    rm -f ./ttf-mscorefonts-installer_3.8_all.deb &&\
-    echo "deb https://httpredir.debian.org/debian/ buster-backports main contrib non-free" >> /etc/apt/sources.list &&\
-    apt-get update -qq &&\
-    # Install Chromium and LibreOffice.
-    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends chromium &&\
-    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends -t buster-backports libreoffice &&\
-    # Download unoconv (Python script).
-    curl -Ls https://raw.githubusercontent.com/dagwieers/unoconv/master/unoconv -o /usr/bin/unoconv &&\
-    chmod +x /usr/bin/unoconv &&\
-    # unoconv will look for the Python binary, which has to be at version 3.
-    ln -s /usr/bin/python3 /usr/bin/python &&\
-    # Download PDFtk.
-    # Credits: https://github.com/thecodingmachine/gotenberg/pull/273.
-    curl -o /usr/bin/pdftk-all.jar "https://gitlab.com/pdftk-java/pdftk/-/jobs/$PDFTK_VERSION/artifacts/raw/build/libs/pdftk-all.jar" &&\
-    chmod a+x /usr/bin/pdftk-all.jar &&\
-    # See https://github.com/nextcloud/docker/issues/380.
-    mkdir -p /usr/share/man/man1mkdir -p /usr/share/man/man1 &&\
-    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends default-jre-headless &&\
+    rm -f ./ttf-mscorefonts-installer_3.8.1_all.deb &&\
+    # Add Color and Black-and-White Noto emoji font.
+    # Credits:
+    # https://github.com/gotenberg/gotenberg/pull/325.
+    # https://github.com/googlefonts/noto-emoji.
+    curl -Ls "https://github.com/googlefonts/noto-emoji/raw/$NOTO_COLOR_EMOJI_VERSION/fonts/NotoColorEmoji.ttf" -o /usr/local/share/fonts/NotoColorEmoji.ttf &&\
    # Cleanup.
-    # Note: the Debian image does automatically a clean after each install thanks to a hook.
-    # Therefore, there is no need for apt-get clean.
-    # See https://stackoverflow.com/a/24417119/3248473.
-    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* &&\
-    # Print versions of main dependencies.
-    chromium --version &&\
-    libreoffice --version &&\
-    unoconv --version &&\
-    pdftk --version
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

-# Copy the Gotenberg binary from the builder stage.
-COPY --from=builder /home/gotenberg /usr/bin/
+RUN \
+    # Install either Google Chrome stable on amd64 architecture or
+    # Chromium on other architectures.
+    # See https://github.com/gotenberg/gotenberg/issues/328.
+    # FIXME:
+    # armhf is currently not working with the latest version of Chromium.
+    # See: https://github.com/gotenberg/gotenberg/issues/709.
+    /bin/bash -c \
+    'set -e &&\
+    if [[ "$(dpkg --print-architecture)" == "amd64" ]]; then \
+      curl https://dl.google.com/linux/linux_signing_key.pub | apt-key add - &&\
+      echo "deb http://dl.google.com/linux/chrome/deb/ stable main" | tee /etc/apt/sources.list.d/google-chrome.list &&\
+      apt-get update -qq &&\
+      DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends --allow-unauthenticated google-chrome-stable &&\
+      mv /usr/bin/google-chrome-stable /usr/bin/chromium; \
+    elif [[ "$(dpkg --print-architecture)" == "armhf" ]]; then \
+      apt-get update -qq &&\
+      DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends devscripts &&\
+      debsnap chromium-common "$TMP_CHOMIUM_VERSION_ARMHF" -v --force --binary --architecture armhf &&\
+      debsnap chromium "$TMP_CHOMIUM_VERSION_ARMHF" -v --force --binary --architecture armhf &&\
+      DEBIAN_FRONTEND=noninteractive apt-get install --fix-broken -y -qq --no-install-recommends "./binary-chromium-common/chromium-common_${TMP_CHOMIUM_VERSION_ARMHF}_armhf.deb" "./binary-chromium/chromium_${TMP_CHOMIUM_VERSION_ARMHF}_armhf.deb" &&\
+      DEBIAN_FRONTEND=noninteractive apt-get purge -y -qq devscripts &&\
+      rm -rf ./binary-chromium-common/* ./binary-chromium/*; \
+    else \
+      apt-get update -qq &&\
+      DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends chromium; \
+    fi' &&\
+    # Verify installation.
+    chromium --version &&\
+    # Cleanup.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+RUN \
+    # Install LibreOffice & unoconverter.
+    echo "deb http://deb.debian.org/debian bookworm-backports main" >> /etc/apt/sources.list &&\
+    apt-get update -qq &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends -t bookworm-backports libreoffice &&\
+    curl -Ls https://raw.githubusercontent.com/gotenberg/unoconverter/v0.0.1/unoconv -o /usr/bin/unoconverter &&\
+    chmod +x /usr/bin/unoconverter &&\
+    # unoconverter will look for the Python binary, which has to be at version 3.
+    ln -s /usr/bin/python3 /usr/bin/python &&\
+    # Verify installations.
+    libreoffice --version &&\
+    unoconverter --version &&\
+    # Cleanup.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+RUN \
+    # Install PDFtk & QPDF (PDF engines).
+    # See https://github.com/gotenberg/gotenberg/pull/273.
+    curl -o /usr/bin/pdftk-all.jar "https://gitlab.com/api/v4/projects/5024297/packages/generic/pdftk-java/$PDFTK_VERSION/pdftk-all.jar" &&\
+    chmod a+x /usr/bin/pdftk-all.jar &&\
+    echo '#!/bin/bash\n\nexec java -jar /usr/bin/pdftk-all.jar "$@"' > /usr/bin/pdftk && \
+    chmod +x /usr/bin/pdftk &&\
+    apt-get update -qq &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends qpdf &&\
+    # See https://github.com/nextcloud/docker/issues/380.
+    mkdir -p /usr/share/man/man1 &&\
+    # Verify installations.
+    pdftk --version &&\
+    qpdf --version &&\
+    # Cleanup.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Improve fonts subpixel hinting and smoothing.
+# Credits:
+# https://github.com/arachnys/athenapdf/issues/69.
+# https://github.com/arachnys/athenapdf/commit/ba25a8d80a25d08d58865519c4cd8756dc9a336d.
+COPY build/fonts.conf /etc/fonts/conf.d/100-gotenberg.conf
+
+# Copy the Gotenberg binary from the binary stage.
+COPY --from=binary-stage /home/gotenberg /usr/bin/

 # Environment variables required by modules or else.
-ENV GC_EXCLUDE_SUBSTR "hsperfdata_root,hsperfdata_gotenberg"
 ENV CHROMIUM_BIN_PATH /usr/bin/chromium
-ENV UNOCONV_BIN_PATH /usr/bin/unoconv
+ENV LIBREOFFICE_BIN_PATH /usr/lib/libreoffice/program/soffice.bin
+ENV UNOCONVERTER_BIN_PATH /usr/bin/unoconverter
 ENV PDFTK_BIN_PATH /usr/bin/pdftk
+ENV QPDF_BIN_PATH /usr/bin/qpdf

 USER gotenberg
 WORKDIR /home/gotenberg
@@ -142,4 +203,4 @@ WORKDIR /home/gotenberg
 EXPOSE 3000

 ENTRYPOINT [ "/usr/bin/tini", "--" ]
-CMD [ "gotenberg" ]
+CMD [ "gotenberg" ]
--- a/build/Dockerfile.cloudrun
+++ b/build/Dockerfile.cloudrun
@@ -1,9 +1,7 @@
-# Note: ARG instructions do not create additional layers.
-# Instead, next layers will concatenate them.
-ARG DOCKER_REGISTRY
+ARG DOCKER_REPOSITORY
 ARG GOTENBERG_VERSION

-FROM $DOCKER_REGISTRY/gotenberg:$GOTENBERG_VERSION
+FROM $DOCKER_REPOSITORY/gotenberg:$GOTENBERG_VERSION

 USER root

--- a/build/pdftk.sh
+++ b/build/pdftk.sh
@@ -1,3 +0,0 @@
-#!/bin/bash
-
-exec java -jar /usr/bin/pdftk-all.jar "$@"
--- a/internal/app/gotenberg/gotenberg.go
+++ b/internal/app/gotenberg/gotenberg.go
@@ -1,14 +1,17 @@
-package gotenberg
+package gotenbergcmd

 import (
 	"context"
 	"fmt"
 	"os"
 	"os/signal"
+	"syscall"
 	"time"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	flag "github.com/spf13/pflag"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

 // See https://patorjk.com/software/taag/#p=display&f=Small%20Slant&t=Gotenberg.
@@ -25,12 +28,15 @@ Version: %s
 -------------------------------------------------------
 `

-var version = "snapshot"
+// Version is the... version of the Gotenberg application. We set it at the
+// build stage of the Docker image.
+var Version = "snapshot"

+// Run starts the Gotenberg application. Call this in the main of your program.
 func Run() {
-	fmt.Printf(banner, version)
+	fmt.Printf(banner, Version)

-	// Creates the roo` FlagSet and adds the modules flags to it.
+	// Create the root FlagSet and adds the modules flags to it.
 	fs := flag.NewFlagSet("gotenberg", flag.ExitOnError)
 	fs.Duration("gotenberg-graceful-shutdown-duration", time.Duration(30)*time.Second, "Set the graceful shutdown duration")

@@ -43,14 +49,14 @@ func Run() {

 	fmt.Printf("[SYSTEM] modules: %s\n", modsInfo)

-	// Parses the flags...
+	// Parse the flags...
 	err := fs.Parse(os.Args[1:])
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}

-	// ...and creates a wrapper around those.
+	// ...and create a wrapper around those.
 	parsedFlags := gotenberg.ParsedFlags{FlagSet: fs}

 	// Get the graceful shutdown duration.
@@ -58,7 +64,7 @@ func Run() {

 	ctx := gotenberg.NewContext(parsedFlags, descriptors)

-	// Starts application modules.
+	// Start application modules.
 	apps, err := ctx.Modules(new(gotenberg.App))
 	if err != nil {
 		fmt.Printf("[FATAL] %s\n", err)
@@ -78,19 +84,34 @@ func Run() {
 			startupMessage := app.StartupMessage()
 			if startupMessage == "" {
 				fmt.Printf("[SYSTEM] %s: application started\n", id)
-
 				return
 			}

 			fmt.Printf("[SYSTEM] %s: %s\n", id, startupMessage)
 		}(a.(gotenberg.App))
+	}

+	// Get modules that want to print system messages.
+	sysLoggers, err := ctx.Modules(new(gotenberg.SystemLogger))
+	if err != nil {
+		fmt.Printf("[FATAL] %s\n", err)
+		os.Exit(1)
+	}
+
+	for _, l := range sysLoggers {
+		go func(logger gotenberg.SystemLogger) {
+			id := logger.(gotenberg.Module).Descriptor().ID
+
+			for _, message := range logger.SystemMessages() {
+				fmt.Printf("[SYSTEM] %s: %s\n", id, message)
+			}
+		}(l.(gotenberg.SystemLogger))
 	}

 	quit := make(chan os.Signal, 1)

-	// We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C).
-	signal.Notify(quit, os.Interrupt)
+	// We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C) or SIGTERM (Kubernetes).
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

 	// Block until we receive our signal.
 	<-quit
@@ -98,18 +119,39 @@ func Run() {
 	gracefulShutdownCtx, cancel := context.WithTimeout(context.Background(), gracefulShutdownDuration)
 	defer cancel()

+	forceQuit := make(chan os.Signal, 1)
+	signal.Notify(forceQuit, syscall.SIGINT)
+
+	go func() {
+		// In case of force quit, cancel the context.
+		<-forceQuit
+		cancel()
+	}()
+
 	fmt.Printf("[SYSTEM] graceful shutdown of %s\n", gracefulShutdownDuration)

+	eg, _ := errgroup.WithContext(gracefulShutdownCtx)
+
 	for _, a := range apps {
-		id := a.(gotenberg.Module).Descriptor().ID
-		app := a.(gotenberg.App)
+		eg.Go(func(app gotenberg.App) func() error {
+			return func() error {
+				id := app.(gotenberg.Module).Descriptor().ID

-		err = app.Stop(gracefulShutdownCtx)
-		if err != nil {
-			fmt.Printf("[ERROR] stopping %s: %s\n", id, err)
-		}
+				err = app.Stop(gracefulShutdownCtx)
+				if err != nil {
+					return fmt.Errorf("stopping %s: %w", id, err)
+				}

-		fmt.Printf("[SYSTEM] %s: application stopped\n", id)
+				fmt.Printf("[SYSTEM] %s: application stopped\n", id)
+				return nil
+			}
+		}(a.(gotenberg.App)))
+	}
+
+	err = eg.Wait()
+	if err != nil {
+		fmt.Printf("[FATAL] %v\n", err)
+		os.Exit(1)
 	}

 	os.Exit(0)
--- a/cmd/gotenberg/main.go
+++ b/cmd/gotenberg/main.go
@@ -1,16 +1,11 @@
 package main

 import (
-	gotenbergapp "github.com/gotenberg/gotenberg/v7/internal/app/gotenberg"
-
+	gotenbergcmd "github.com/gotenberg/gotenberg/v8/cmd"
 	// Gotenberg modules.
-	_ "github.com/gotenberg/gotenberg/v7/pkg/standard"
-	// PDF engines.
-	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/pdfengine"
-	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/pdfcpu"
-	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/pdftk"
+	_ "github.com/gotenberg/gotenberg/v8/pkg/standard"
 )

 func main() {
-	gotenbergapp.Run()
+	gotenbergcmd.Run()
 }
--- a/go.mod
+++ b/go.mod
@@ -1,38 +1,65 @@
-module github.com/gotenberg/gotenberg/v7
+module github.com/gotenberg/gotenberg/v8

-go 1.16
+go 1.21

 require (
-	github.com/alexliesenfeld/health v0.6.0
-	github.com/andybalholm/brotli v1.0.3 // indirect
-	github.com/chromedp/cdproto v0.0.0-20210808225517-c36c1bd4c35e
-	github.com/chromedp/chromedp v0.7.4
+	github.com/alexliesenfeld/health v0.8.0
+	github.com/andybalholm/brotli v1.1.0 // indirect
+	github.com/chromedp/cdproto v0.0.0-20240202021202-6d0b6a386732
+	github.com/chromedp/chromedp v0.9.5
 	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/uuid v1.3.0
+	github.com/google/uuid v1.6.0
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
-	github.com/hashicorp/go-retryablehttp v0.7.0
-	github.com/klauspost/compress v1.13.4 // indirect
-	github.com/klauspost/pgzip v1.2.5 // indirect
-	github.com/labstack/echo/v4 v4.5.0
-	github.com/labstack/gommon v0.3.0
-	github.com/mattn/go-isatty v0.0.13 // indirect
-	github.com/mholt/archiver/v3 v3.5.0
-	github.com/microcosm-cc/bluemonday v1.0.15
-	github.com/nwaples/rardecode v1.1.2 // indirect
-	github.com/pdfcpu/pdfcpu v0.3.12
-	github.com/pierrec/lz4/v4 v4.1.8 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.5
+	github.com/klauspost/compress v1.17.6 // indirect
+	github.com/klauspost/pgzip v1.2.6 // indirect
+	github.com/labstack/echo/v4 v4.11.4
+	github.com/labstack/gommon v0.4.2
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mholt/archiver/v3 v3.5.1
+	github.com/microcosm-cc/bluemonday v1.0.26
+	github.com/nwaples/rardecode v1.1.3 // indirect
+	github.com/pdfcpu/pdfcpu v0.6.0
+	github.com/pierrec/lz4/v4 v4.1.21 // indirect
+	github.com/prometheus/client_golang v1.18.0
 	github.com/russross/blackfriday/v2 v2.1.0
 	github.com/spf13/pflag v1.0.5
-	github.com/ulikunitz/xz v0.5.10 // indirect
-	go.uber.org/atomic v1.9.0 // indirect
-	go.uber.org/multierr v1.7.0
-	go.uber.org/zap v1.19.0
-	golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 // indirect
-	golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d // indirect
-	golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d // indirect
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	golang.org/x/sys v0.0.0-20210820121016-41cdb8703e55 // indirect
-	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b
-	golang.org/x/text v0.3.7
-	golang.org/x/tools v0.1.5 // indirect
+	github.com/ulikunitz/xz v0.5.11 // indirect
+	go.uber.org/multierr v1.11.0
+	go.uber.org/zap v1.26.0
+	golang.org/x/crypto v0.18.0 // indirect
+	golang.org/x/image v0.15.0 // indirect
+	golang.org/x/net v0.20.0
+	golang.org/x/sync v0.6.0
+	golang.org/x/sys v0.16.0 // indirect
+	golang.org/x/term v0.16.0
+	golang.org/x/text v0.14.0
+)
+
+require (
+	github.com/aymerick/douceur v0.2.0 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/chromedp/sysutil v1.0.0 // indirect
+	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
+	github.com/gobwas/httphead v0.1.0 // indirect
+	github.com/gobwas/pool v0.2.1 // indirect
+	github.com/gobwas/ws v1.3.2 // indirect
+	github.com/gorilla/css v1.0.1 // indirect
+	github.com/hhrutter/lzw v1.0.0 // indirect
+	github.com/hhrutter/tiff v1.0.1 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/prometheus/client_model v0.5.0 // indirect
+	github.com/prometheus/common v0.46.0 // indirect
+	github.com/prometheus/procfs v0.12.0 // indirect
+	github.com/rivo/uniseg v0.4.6 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.2 // indirect
+	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
+	google.golang.org/protobuf v1.32.0 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -1,198 +1,159 @@
-github.com/alexliesenfeld/health v0.6.0 h1:HRBTCgybNSe4lqGEk7nU82c3bjwh9W+3b46W6UvD4CQ=
-github.com/alexliesenfeld/health v0.6.0/go.mod h1:N4NDIeQtlWumG+6z1ne1v62eQxktz5ylEgGgH9emdMw=
-github.com/andybalholm/brotli v1.0.0/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
-github.com/andybalholm/brotli v1.0.3 h1:fpcw+r1N1h0Poc1F/pHbW40cUm/lMEQslZtCkBQ0UnM=
-github.com/andybalholm/brotli v1.0.3/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
-github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
+github.com/alexliesenfeld/health v0.8.0 h1:lCV0i+ZJPTbqP7LfKG7p3qZBl5VhelwUFCIVWl77fgk=
+github.com/alexliesenfeld/health v0.8.0/go.mod h1:TfNP0f+9WQVWMQRzvMUjlws4ceXKEL3WR+6Hp95HUFc=
+github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
+github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
+github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
-github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
-github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
-github.com/chromedp/cdproto v0.0.0-20210713064928-7d28b402946a/go.mod h1:At5TxYYdxkbQL0TSefRjhLE3Q0lgvqKKMSFUglJ7i1U=
-github.com/chromedp/cdproto v0.0.0-20210808225517-c36c1bd4c35e h1:uYQIvPKwL7YQh+tQC+EUXmvWosBeOYbJZKrh4NnS0UM=
-github.com/chromedp/cdproto v0.0.0-20210808225517-c36c1bd4c35e/go.mod h1:At5TxYYdxkbQL0TSefRjhLE3Q0lgvqKKMSFUglJ7i1U=
-github.com/chromedp/chromedp v0.7.4 h1:U+0d3WbB/Oj4mDuBOI0P7S3PJEued5UZIl5AJ3QulwU=
-github.com/chromedp/chromedp v0.7.4/go.mod h1:dBj+SXuQHznp6ZPwZeDDEBZKwclUwDLbZ0hjMialMYs=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chromedp/cdproto v0.0.0-20240202021202-6d0b6a386732 h1:XYUCaZrW8ckGWlCRJKCSoh/iFwlpX316a8yY9IFEzv8=
+github.com/chromedp/cdproto v0.0.0-20240202021202-6d0b6a386732/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
+github.com/chromedp/chromedp v0.9.5 h1:viASzruPJOiThk7c5bueOUY91jGLJVximoEMGoH93rg=
+github.com/chromedp/chromedp v0.9.5/go.mod h1:D4I2qONslauw/C7INoCir1BJkSwBYMyZgx8X276z3+Y=
 github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
 github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dsnet/compress v0.0.1 h1:PlZu0n3Tuv04TzpfPbrnI0HW/YwodEXDS+oPKahKF0Q=
-github.com/dsnet/compress v0.0.1/go.mod h1:Aw8dCMJ7RioblQeTqt88akK31OvO8Dhf5JflhBbQEHo=
+github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 h1:iFaUwBSo5Svw6L7HYpRu/0lE3e0BaElwnNO1qkNQxBY=
+github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5/go.mod h1:qssHWj60/X5sZFNxpG4HBPDHVqxNm4DfnCKgrbZOT+s=
 github.com/dsnet/golib v0.0.0-20171103203638-1ea166775780/go.mod h1:Lj+Z9rebOhdfkVLjJ8T6VcRQv3SXugXy999NBtR9aFY=
 github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
 github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.1.0 h1:7RFti/xnNkMJnrK7D1yQ/iCIB5OrrY/54/H930kIbHA=
-github.com/gobwas/ws v1.1.0/go.mod h1:nzvNcVha5eUziGrbxFCo6qFIojQHjJV5cLYIbezhfL0=
-github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/gobwas/ws v1.3.2 h1:zlnbNHxumkRvfPWgfXu8RBwyNR1x8wh9cf5PTOCqs9Q=
+github.com/gobwas/ws v1.3.2/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
+github.com/golang/snappy v0.0.2/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
-github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
-github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
+github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
 github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
 github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
 github.com/hashicorp/go-hclog v0.9.2 h1:CG6TE5H9/JXsFWJCfoIVpKFIkFe6ysEuHirp4DxCsHI=
 github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
-github.com/hashicorp/go-retryablehttp v0.7.0 h1:eu1EI/mbirUgP5C8hVsTNaGZreBDlYiwC1FZWkvQPQ4=
-github.com/hashicorp/go-retryablehttp v0.7.0/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY=
-github.com/hhrutter/lzw v0.0.0-20190827003112-58b82c5a41cc/go.mod h1:yJBvOcu1wLQ9q9XZmfiPfur+3dQJuIhYQsMGLYcItZk=
-github.com/hhrutter/lzw v0.0.0-20190829144645-6f07a24e8650 h1:1yY/RQWNSBjJe2GDCIYoLmpWVidrooriUr4QS/zaATQ=
-github.com/hhrutter/lzw v0.0.0-20190829144645-6f07a24e8650/go.mod h1:yJBvOcu1wLQ9q9XZmfiPfur+3dQJuIhYQsMGLYcItZk=
-github.com/hhrutter/tiff v0.0.0-20190829141212-736cae8d0bc7 h1:o1wMw7uTNyA58IlEdDpxIrtFHTgnvYzA8sCQz8luv94=
-github.com/hhrutter/tiff v0.0.0-20190829141212-736cae8d0bc7/go.mod h1:WkUxfS2JUu3qPo6tRld7ISb8HiC0gVSU91kooBMDVok=
+github.com/hashicorp/go-retryablehttp v0.7.5 h1:bJj+Pj19UZMIweq/iie+1u5YCdGrnxCT9yvm0e+Nd5M=
+github.com/hashicorp/go-retryablehttp v0.7.5/go.mod h1:Jy/gPYAdjqffZ/yFGCFV2doI5wjtH1ewM9u8iYVjtX8=
+github.com/hhrutter/lzw v1.0.0 h1:laL89Llp86W3rRs83LvKbwYRx6INE8gDn0XNb1oXtm0=
+github.com/hhrutter/lzw v1.0.0/go.mod h1:2HC6DJSn/n6iAZfgM3Pg+cP1KxeWc3ezG8bBqW5+WEo=
+github.com/hhrutter/tiff v1.0.1 h1:MIus8caHU5U6823gx7C6jrfoEvfSTGtEFRiM8/LOzC0=
+github.com/hhrutter/tiff v1.0.1/go.mod h1:zU/dNgDm0cMIa8y8YwcYBeuEEveI4B0owqHyiPpJPHc=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
-github.com/klauspost/compress v1.10.10/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.13.4 h1:0zhec2I8zGnjWcKyLl6i3gPqKANCCn5e9xmviEEeX6s=
-github.com/klauspost/compress v1.13.4/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
+github.com/klauspost/compress v1.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
+github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI=
+github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
 github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
-github.com/klauspost/pgzip v1.2.4/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
-github.com/klauspost/pgzip v1.2.5 h1:qnWYvvKqedOF2ulHpMG72XQol4ILEJ8k2wwRl/Km8oE=
 github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/labstack/echo/v4 v4.5.0 h1:JXk6H5PAw9I3GwizqUHhYyS4f45iyGebR/c1xNCeOCY=
-github.com/labstack/echo/v4 v4.5.0/go.mod h1:czIriw4a0C1dFun+ObrXp7ok03xON0N1awStJ6ArI7Y=
-github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0=
-github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
+github.com/klauspost/pgzip v1.2.6 h1:8RXeL5crjEUFnR2/Sn6GJNWtSQ3Dk8pq4CL3jvdDyjU=
+github.com/klauspost/pgzip v1.2.6/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/labstack/echo/v4 v4.11.4 h1:vDZmA+qNeh1pd/cCkEicDMrjtrnMGQ1QFI9gWN1zGq8=
+github.com/labstack/echo/v4 v4.11.4/go.mod h1:noh7EvLwqDsmh/X/HWKPUl1AjzJrhyptRyEbQJfxen8=
+github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
+github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
+github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kULo2bwGEkFvCePZ3qHDDTC3/J9Swo=
+github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
 github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
-github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
-github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-isatty v0.0.13 h1:qdl+GuBjcsKKDco5BsxPJlId98mSWNKqYA+Co0SC1yA=
-github.com/mattn/go-isatty v0.0.13/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mholt/archiver/v3 v3.5.0 h1:nE8gZIrw66cu4osS/U7UW7YDuGMHssxKutU8IfWxwWE=
-github.com/mholt/archiver/v3 v3.5.0/go.mod h1:qqTTPUK/HZPFgFQ/TJ3BzvTpF/dPtFVJXdQbCmeMxwc=
-github.com/microcosm-cc/bluemonday v1.0.15 h1:J4uN+qPng9rvkBZBoBb8YGR+ijuklIMpSOZZLjYpbeY=
-github.com/microcosm-cc/bluemonday v1.0.15/go.mod h1:ZLvAzeakRwrGnzQEvstVzVt3ZpqOF2+sdFr0Om+ce30=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mholt/archiver/v3 v3.5.1 h1:rDjOBX9JSF5BvoJGvjqK479aL70qh9DIpZCl+k7Clwo=
+github.com/mholt/archiver/v3 v3.5.1/go.mod h1:e3dqJ7H78uzsRSEACH1joayhuSyhnonssnDhppzS1L4=
+github.com/microcosm-cc/bluemonday v1.0.26 h1:xbqSvqzQMeEHCqMi64VAs4d8uy6Mequs3rQ0k/Khz58=
+github.com/microcosm-cc/bluemonday v1.0.26/go.mod h1:JyzOCs9gkyQyjs+6h10UEVSe02CGwkhd72Xdqh78TWs=
 github.com/nwaples/rardecode v1.1.0/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
-github.com/nwaples/rardecode v1.1.2 h1:Cj0yZY6T1Zx1R7AhTbyGSALm44/Mmq+BAPc4B/p/d3M=
-github.com/nwaples/rardecode v1.1.2/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
-github.com/orisano/pixelmatch v0.0.0-20210112091706-4fa4c7ba91d5 h1:1SoBaSPudixRecmlHXb/GxmaD3fLMtHIDN13QujwQuc=
-github.com/orisano/pixelmatch v0.0.0-20210112091706-4fa4c7ba91d5/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
-github.com/pdfcpu/pdfcpu v0.3.12 h1:B+MdKisilWNSk5OCO58Z9U6H93usH73xqk6hMOaZCls=
-github.com/pdfcpu/pdfcpu v0.3.12/go.mod h1:8XVBtVxuuIuSZL4Ez15Q4QoC+H8zeAaGnuiOEwAk8jA=
-github.com/pierrec/lz4/v4 v4.0.3/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
-github.com/pierrec/lz4/v4 v4.1.8 h1:ieHkV+i2BRzngO4Wd/3HGowuZStgq6QkPsD1eolNAO4=
-github.com/pierrec/lz4/v4 v4.1.8/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/nwaples/rardecode v1.1.3 h1:cWCaZwfM5H7nAD6PyEdcVnczzV8i/JtotnyW/dD9lEc=
+github.com/nwaples/rardecode v1.1.3/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
+github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde h1:x0TT0RDC7UhAVbbWWBzr41ElhJx5tXPWkIHA2HWPRuw=
+github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
+github.com/pdfcpu/pdfcpu v0.6.0 h1:z4kARP5bcWa39TTYMcN/kjBnm7MvhTWjXgeYmkdAGMI=
+github.com/pdfcpu/pdfcpu v0.6.0/go.mod h1:kmpD0rk8YnZj0l3qSeGBlAB+XszHUgNv//ORH/E7EYo=
+github.com/pierrec/lz4/v4 v4.1.2/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
+github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v1.18.0 h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk=
+github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA=
+github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw=
+github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI=
+github.com/prometheus/common v0.46.0 h1:doXzt5ybi1HBKpsZOL0sSkaNHJJqkyfEWZGGqqScV0Y=
+github.com/prometheus/common v0.46.0/go.mod h1:Tp0qkxpb9Jsg54QMe+EAmqXkSV7Evdy1BTn+g2pa/hQ=
+github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
+github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.6 h1:Sovz9sDSwbOz9tgUy8JpT+KgCkPYJEN/oYzlJiYTNLg=
+github.com/rivo/uniseg v0.4.6/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/ulikunitz/xz v0.5.6/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
-github.com/ulikunitz/xz v0.5.7/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-github.com/ulikunitz/xz v0.5.10 h1:t92gobL9l3HE202wg3rlk19F6X+JOxl9BBrCCMYEYd8=
-github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/ulikunitz/xz v0.5.8/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/ulikunitz/xz v0.5.9/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/ulikunitz/xz v0.5.11 h1:kpFauv27b6ynzBNT/Xy+1k+fK4WswhN/6PN5WhFAGw8=
+github.com/ulikunitz/xz v0.5.11/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
-github.com/valyala/fasttemplate v1.2.1 h1:TVEnxayobAdVkhQfrfes2IzOB6o+z4roRkPF52WA1u4=
-github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
 github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 h1:nIPpBwaJSVYIxUFsDv3M8ofmx9yWTog9BfvIu0q41lo=
 github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMxjDjgmT5uz5wzYJKVo23qUhYTos=
-github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
-go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/goleak v1.1.10 h1:z+mqJhf6ss6BSfSM671tgKyZBFPTTJM+HLxnhPC3wu0=
-go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
-go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
-go.uber.org/multierr v1.7.0 h1:zaiO/rmgFjbmCXdSYJWQcdvOCsthmdaHfr3Gm2Kx4Ec=
-go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak=
-go.uber.org/zap v1.19.0 h1:mZQZefskPPCMIBCSEH0v2/iUqqLrYtaeqwD6FUGUnFE=
-go.uber.org/zap v1.19.0/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
-golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ=
-golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/image v0.0.0-20190823064033-3a9bac650e44/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.0.0-20210220032944-ac19c3e999fb/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d h1:RNPAfi2nHY7C2srAV8A49jpsYr0ADedCk1wq6fTMTvs=
-golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d h1:LO7XpTYMwTqxjLcGWPijK3vRXg1aWdlNOVOHRq45d7c=
-golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210525143221-35b2ab0089ea/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210820121016-41cdb8703e55 h1:rw6UNGRMfarCepjI8qOepea/SXwIBVfTKjztZ5gBbq4=
-golang.org/x/sys v0.0.0-20210820121016-41cdb8703e55/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE=
-golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.5 h1:ouewzE6p+/VEB31YYnTbEJdi8pFqKp4P4n85vwo3DHA=
-golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk=
+go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo=
+go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so=
+golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/image v0.15.0 h1:kOELfmgrmJlw4Cdb7g/QGuB3CvDrXbqEIww/pNtNBm8=
+golang.org/x/image v0.15.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE=
+golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
+golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
+google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
-gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/pkg/gotenberg/cmd.go
+++ b/pkg/gotenberg/cmd.go
@@ -13,51 +13,51 @@ import (
 	"go.uber.org/zap"
 )

-// Cmd wraps an exec.Cmd.
+// Cmd wraps an [exec.Cmd].
 type Cmd struct {
 	ctx     context.Context
 	logger  *zap.Logger
 	process *exec.Cmd
 }

-// Command creates a Cmd without a context. It configures the internal
-// exec.Cmd of Cmd so that we may kill its unix process and all its children
-// without creating orphans.
+// Command creates a [Cmd] without a context. It configures the internal
+// [exec.Cmd] of [Cmd] so that we may kill its unix process and all its
+// children without creating orphans.
 //
 // See https://medium.com/@felixge/killing-a-child-process-and-all-of-its-children-in-go-54079af94773.
-func Command(logger *zap.Logger, binPath string, args ...string) Cmd {
+func Command(logger *zap.Logger, binPath string, args ...string) *Cmd {
 	cmd := exec.Command(binPath, args...)
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

-	return Cmd{
+	return &Cmd{
 		ctx:     nil,
-		logger:  logger.Named("cmd"),
+		logger:  logger.Named(strings.ReplaceAll(binPath, "/", "")),
 		process: cmd,
 	}
 }

-// CommandContext creates a Cmd with a context. It configures the internal
-// exec.Cmd of Cmd so that we may kill its unix process and all its children
-// without creating orphans.
+// CommandContext creates a [Cmd] with a context. It configures the internal
+// [exec.Cmd] of [Cmd] so that we may kill its unix process and all its
+// children without creating orphans.
 //
 // See https://medium.com/@felixge/killing-a-child-process-and-all-of-its-children-in-go-54079af94773.
-func CommandContext(ctx context.Context, logger *zap.Logger, binPath string, args ...string) (Cmd, error) {
+func CommandContext(ctx context.Context, logger *zap.Logger, binPath string, args ...string) (*Cmd, error) {
 	if ctx == nil {
-		return Cmd{}, errors.New("nil context")
+		return nil, errors.New("nil context")
 	}

 	cmd := exec.CommandContext(ctx, binPath, args...)
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

-	return Cmd{
+	return &Cmd{
 		ctx:     ctx,
-		logger:  logger.Named("cmd"),
+		logger:  logger.Named(strings.ReplaceAll(binPath, "/", "")),
 		process: cmd,
 	}, nil
 }

 // Start starts the command but does not wait for its completion.
-func (cmd Cmd) Start() error {
+func (cmd *Cmd) Start() error {
 	err := cmd.pipeOutput()
 	if err != nil {
 		return fmt.Errorf("pipe unix process output: %w", err)
@@ -73,22 +73,37 @@ func (cmd Cmd) Start() error {
 	return nil
 }

+// Wait waits for the command to complete. It should be called when using the
+// Start method, so that the command does not leak zombies.
+func (cmd *Cmd) Wait() error {
+	err := cmd.process.Wait()
+	if err != nil {
+		return fmt.Errorf("wait for unix process: %w", err)
+	}
+
+	return nil
+}
+
 // Exec executes the command and wait for its completion or until the context
 // is done. In any case, it kills the unix process and all its children.
-func (cmd Cmd) Exec() error {
+func (cmd *Cmd) Exec() (int, error) {
 	if cmd.ctx == nil {
-		return errors.New("nil context")
+		return 10, errors.New("nil context")
 	}

 	err := cmd.Start()
 	if err != nil {
-		return fmt.Errorf("start command: %w", err)
+		if cmd.process.ProcessState == nil {
+			return 131, fmt.Errorf("start command: %w", err)
+		}
+
+		return cmd.process.ProcessState.ExitCode(), fmt.Errorf("start command: %w", err)
 	}

 	errChan := make(chan error, 1)

 	go func() {
-		errChan <- cmd.process.Wait()
+		errChan <- cmd.Wait()
 	}()

 	select {
@@ -99,23 +114,27 @@ func (cmd Cmd) Exec() error {
 		}

 		if err == nil {
-			return nil
+			return 0, nil
 		}

-		return fmt.Errorf("unix process error: %w", err)
+		if cmd.process.ProcessState == nil {
+			return 131, fmt.Errorf("unix process error: %w", err)
+		}
+
+		return cmd.process.ProcessState.ExitCode(), fmt.Errorf("unix process error: %w", err)
 	case <-cmd.ctx.Done():
 		errProc := cmd.Kill()
 		if errProc != nil {
 			cmd.logger.Error(errProc.Error())
 		}

-		return fmt.Errorf("context done: %w", cmd.ctx.Err())
+		return 62, fmt.Errorf("context done: %w", cmd.ctx.Err())
 	}
 }

 // pipeOutput creates logs entries according to the process stdout and stderr.
 // It does nothing if the logging level is not debug.
-func (cmd Cmd) pipeOutput() error {
+func (cmd *Cmd) pipeOutput() error {
 	checkedEntry := cmd.logger.Check(zap.DebugLevel, "check for debug level before piping unix process output")
 	if checkedEntry == nil {
 		return nil
@@ -135,11 +154,15 @@ func (cmd Cmd) pipeOutput() error {
 	// (either stdout or stderr).
 	logCommandOutput := func(logger *zap.Logger, reader io.ReadCloser) {
 		r := bufio.NewReader(reader)
-		defer reader.Close()
+		defer func(reader io.ReadCloser) {
+			err := reader.Close()
+			if err != nil {
+				logger.Error(fmt.Sprintf("close reader: %s", err))
+			}
+		}(reader)

 		for {
 			line, _, err := r.ReadLine()
-
 			if err != nil {
 				if err != io.EOF && !strings.Contains(err.Error(), "file already closed") {
 					logger.Error(fmt.Sprintf("pipe unix process output error: %s", err))
@@ -163,7 +186,7 @@ func (cmd Cmd) pipeOutput() error {
 // Kill kills the unix process and all its children without creating orphans.
 //
 // See https://medium.com/@felixge/killing-a-child-process-and-all-of-its-children-in-go-54079af94773.
-func (cmd Cmd) Kill() error {
+func (cmd *Cmd) Kill() error {
 	if cmd.process == nil {
 		// We cannot use the logger here, because for whatever reason using it
 		// result to a panic.
--- a/pkg/gotenberg/cmd_test.go
+++ b/pkg/gotenberg/cmd_test.go
@@ -10,211 +10,308 @@ import (

 func TestCommand(t *testing.T) {
 	cmd := Command(zap.NewNop(), "foo")
-
 	if !cmd.process.SysProcAttr.Setpgid {
-		t.Error("expected Setpgid to be true")
+		t.Error("expected cmd.process.SysProcAttr.Setpgid to be true")
 	}
 }

 func TestCommandContext(t *testing.T) {
-	for i, tc := range []struct {
-		ctx       context.Context
-		expectErr bool
+	tests := []struct {
+		scenario                  string
+		ctx                       context.Context
+		expectCommandContextError bool
 	}{
 		{
-			ctx:       nil,
-			expectErr: true,
+			scenario:                  "nominal behavior",
+			ctx:                       context.Background(),
+			expectCommandContextError: false,
 		},
 		{
-			ctx: context.TODO(),
+			scenario:                  "nil context",
+			ctx:                       nil,
+			expectCommandContextError: true,
 		},
-	} {
-		cmd, err := CommandContext(tc.ctx, zap.NewNop(), "foo")
+	}

-		if err == nil && !cmd.process.SysProcAttr.Setpgid {
-			t.Fatalf("test %d: expected Setpgid to be true", i)
-		}
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			cmd, err := CommandContext(tc.ctx, zap.NewNop(), "foo")

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if err == nil && !cmd.process.SysProcAttr.Setpgid {
+				t.Fatal("expected cmd.process.SysProcAttr.Setpgid to be true")
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if !tc.expectCommandContextError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectCommandContextError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

 func TestCmd_Start(t *testing.T) {
-	for i, tc := range []struct {
-		cmd       Cmd
-		expectErr bool
+	tests := []struct {
+		scenario         string
+		cmd              *Cmd
+		expectStartError bool
 	}{
 		{
-			cmd:       Command(zap.NewNop(), "foo"),
-			expectErr: true,
+			scenario:         "nominal behavior",
+			cmd:              Command(zap.NewNop(), "echo", "Hello", "World"),
+			expectStartError: false,
 		},
 		{
-			cmd: Command(zap.NewNop(), "echo", "Hello", "World"),
+			scenario:         "start error",
+			cmd:              Command(zap.NewNop(), "foo"),
+			expectStartError: true,
 		},
-	} {
-		err := tc.cmd.Start()
+	}

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.cmd.Start()

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if !tc.expectStartError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectStartError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestCmd_Wait(t *testing.T) {
+	tests := []struct {
+		scenario        string
+		cmd             *Cmd
+		expectWaitError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			cmd: func() *Cmd {
+				cmd := Command(zap.NewNop(), "echo", "Hello", "World")
+				err := cmd.Start()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return cmd
+			}(),
+			expectWaitError: false,
+		},
+		{
+			scenario: "wait error",
+			cmd: func() *Cmd {
+				cmd := Command(zap.NewNop(), "echo", "Hello", "World")
+				err := cmd.Start()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				err = cmd.Kill()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return cmd
+			}(),
+			expectWaitError: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.cmd.Wait()
+
+			if !tc.expectWaitError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectWaitError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

 func TestCmd_Exec(t *testing.T) {
-	for i, tc := range []struct {
-		cmd       Cmd
-		timeout   time.Duration
-		expectErr bool
+	tests := []struct {
+		scenario        string
+		cmd             *Cmd
+		timeout         time.Duration
+		expectExecError bool
 	}{
 		{
-			cmd:       Command(zap.NewNop(), "foo"),
-			expectErr: true,
+			scenario: "nominal behavior",
+			cmd: func() *Cmd {
+				cmd, err := CommandContext(context.Background(), zap.NewNop(), "echo", "Hello", "World")
+				if err != nil {
+					t.Fatalf("expected no error from CommandContext(), but got: %v", err)
+				}
+				return cmd
+			}(),
+			expectExecError: false,
 		},
 		{
-			cmd:       Command(zap.NewNop(), "foo"),
-			timeout:   time.Duration(5) * time.Second,
-			expectErr: true,
+			scenario:        "nil context",
+			cmd:             Command(zap.NewNop(), "echo", "Hello", "World"),
+			expectExecError: true,
 		},
 		{
-			cmd:     Command(zap.NewNop(), "echo", "Hello", "World"),
-			timeout: time.Duration(5) * time.Second,
+			scenario: "start error",
+			cmd: func() *Cmd {
+				cmd, err := CommandContext(context.Background(), zap.NewNop(), "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return cmd
+			}(),
+			expectExecError: true,
 		},
 		{
-			cmd:       Command(zap.NewNop(), "sleep", "3"),
-			timeout:   time.Duration(2) * time.Second,
-			expectErr: true,
+			scenario:        "context done",
+			cmd:             Command(zap.NewNop(), "sleep", "2"),
+			timeout:         time.Duration(1) * time.Second,
+			expectExecError: true,
 		},
-	} {
-		if tc.timeout > 0 {
-			ctx, cancel := context.WithTimeout(context.TODO(), tc.timeout)
-			defer cancel()
+	}

-			tc.cmd.ctx = ctx
-		}
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.timeout > 0 {
+				ctx, cancel := context.WithTimeout(context.TODO(), tc.timeout)
+				defer cancel()

-		err := tc.cmd.Exec()
+				tc.cmd.ctx = ctx
+			}

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			_, err := tc.cmd.Exec()

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if !tc.expectExecError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectExecError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

 func TestCmd_pipeOutput(t *testing.T) {
-	for i, tc := range []struct {
-		cmd       Cmd
-		run       bool
-		expectErr bool
+	tests := []struct {
+		scenario              string
+		cmd                   *Cmd
+		run                   bool
+		expectPipeOutputError bool
 	}{
 		{
-			cmd: Command(zap.NewNop(), "echo", "Hello", "World"),
+			scenario:              "nominal behavior",
+			cmd:                   Command(zap.NewExample(), "echo", "Hello", "World"),
+			run:                   true,
+			expectPipeOutputError: false,
 		},
 		{
-			cmd: func() Cmd {
+			scenario:              "no debug, no pipe",
+			cmd:                   Command(zap.NewNop(), "echo", "Hello", "World"),
+			run:                   false,
+			expectPipeOutputError: false,
+		},
+		{
+			scenario: "stdout already piped",
+			cmd: func() *Cmd {
 				cmd := Command(zap.NewExample(), "echo", "Hello", "World")
 				_, err := cmd.process.StdoutPipe()
-
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
-
 				return cmd
 			}(),
-			expectErr: true,
+			run:                   false,
+			expectPipeOutputError: true,
 		},
 		{
-			cmd: func() Cmd {
+			scenario: "stderr already piped",
+			cmd: func() *Cmd {
 				cmd := Command(zap.NewExample(), "echo", "Hello", "World")
 				_, err := cmd.process.StderrPipe()
-
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
-
 				return cmd
 			}(),
-			expectErr: true,
+			run:                   false,
+			expectPipeOutputError: true,
 		},
-		{
-			cmd: Command(zap.NewExample(), "echo", "Hello", "World"),
-			run: true,
-		},
-	} {
-		err := tc.cmd.pipeOutput()
+	}

-		if tc.run {
-			errStart := tc.cmd.process.Start()
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.cmd.pipeOutput()

-			if errStart != nil {
-				t.Fatalf("test %d: expected no error but got: %v", i, err)
+			if tc.run {
+				errStart := tc.cmd.process.Start()
+				if errStart != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
 			}
-		}

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if !tc.expectPipeOutputError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectPipeOutputError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

 func TestCmd_Kill(t *testing.T) {
-	for i, tc := range []struct {
-		cmd       Cmd
-		expectErr bool
+	tests := []struct {
+		scenario string
+		cmd      *Cmd
 	}{
 		{
-			cmd: Cmd{logger: zap.NewNop()},
-		},
-		{
-			cmd: func() Cmd {
+			scenario: "nominal behavior",
+			cmd: func() *Cmd {
 				cmd := Command(zap.NewNop(), "sleep", "60")
 				err := cmd.process.Start()
-
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
-
 				return cmd
 			}(),
 		},
 		{
-			cmd: func() Cmd {
-				cmd := Command(zap.NewNop(), "echo", "Hello", "World")
-				err := cmd.process.Run()
-
+			scenario: "no process",
+			cmd:      &Cmd{logger: zap.NewNop()},
+		},
+		{
+			scenario: "process already killed",
+			cmd: func() *Cmd {
+				cmd := Command(zap.NewNop(), "sleep", "60")
+				err := cmd.process.Start()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				err = cmd.Kill()
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
-
 				return cmd
 			}(),
 		},
-	} {
-		err := tc.cmd.Kill()
+	}

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.cmd.Kill()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
 	}
 }
--- a/pkg/gotenberg/context.go
+++ b/pkg/gotenberg/context.go
@@ -5,7 +5,7 @@ import (
 	"reflect"
 )

-// Context is a struct which helps initializing modules. When provisioning, a
+// Context is a struct which helps to initialize modules. When provisioning, a
 // module may use the context to get other modules that it needs internally.
 type Context struct {
 	flags           ParsedFlags
@@ -13,8 +13,8 @@ type Context struct {
 	moduleInstances map[string]interface{}
 }

-// NewContext creates a Context.
-// In a module, prefer the Provisioner interface to get a Context.
+// NewContext creates a [Context].
+// In a module, prefer the [Provisioner] interface to get a [Context].
 func NewContext(
 	flags ParsedFlags,
 	descriptors []ModuleDescriptor,
@@ -32,7 +32,7 @@ func NewContext(
 //		flags := ctx.ParsedFlags()
 //		m.foo = flags.RequiredString("foo")
 //	}
-func (ctx Context) ParsedFlags() ParsedFlags {
+func (ctx *Context) ParsedFlags() ParsedFlags {
 	return ctx.flags
 }

@@ -47,7 +47,6 @@ func (ctx Context) ParsedFlags() ParsedFlags {
 // initializes it. Otherwise, returns the already initialized instance.
 func (ctx *Context) Module(kind interface{}) (interface{}, error) {
 	mods, err := ctx.Modules(kind)
-
 	if err != nil {
 		return nil, fmt.Errorf("get module: %w", err)
 	}
@@ -101,7 +100,7 @@ func (ctx *Context) Modules(kind interface{}) ([]interface{}, error) {
 }

 // loadModule calls the Provision and/or Validate methods of the requested
-// module if it satisfies the Provisioner and/or Validator interfaces.
+// module if it satisfies the [Provisioner] and/or [Validator] interfaces.
 func (ctx *Context) loadModule(id string, instance interface{}) error {
 	if prov, ok := instance.(Provisioner); ok {
 		// The instance can be provisioned.
--- a/pkg/gotenberg/context_test.go
+++ b/pkg/gotenberg/context_test.go
@@ -23,173 +23,212 @@ func TestContext_ParsedFlags(t *testing.T) {
 }

 func TestContext_Module(t *testing.T) {
-	for i, tc := range []struct {
-		mods      []ModuleDescriptor
-		kind      interface{}
-		expectErr bool
+	for _, tc := range []struct {
+		scenario    string
+		mods        []ModuleDescriptor
+		kind        interface{}
+		expectError bool
 	}{
 		{
+			scenario: "module with error on provision",
 			mods: func() []ModuleDescriptor {
-				mod := struct{ ProtoProvisioner }{}
-				mod.descriptor = func() ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
 					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
 				}
-				mod.provision = func(ctx *Context) error { return errors.New("foo") }
-
+				mod.ProvisionMock = func(ctx *Context) error { return errors.New("foo") }
 				return []ModuleDescriptor{mod.Descriptor()}
 			}(),
-			kind:      new(Provisioner),
-			expectErr: true,
+			kind:        new(Provisioner),
+			expectError: true,
 		},
 		{
+			scenario: "two modules instead of one",
 			mods: func() []ModuleDescriptor {
-				mod := struct{ ProtoProvisioner }{}
-				mod.descriptor = func() ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
 					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
 				}
-				mod.provision = func(ctx *Context) error { return nil }
-
+				mod.ProvisionMock = func(ctx *Context) error { return nil }
 				return []ModuleDescriptor{mod.Descriptor(), mod.Descriptor()}
 			}(),
-			kind:      new(Provisioner),
-			expectErr: true,
+			kind:        new(Provisioner),
+			expectError: true,
 		},
 		{
+			scenario: "success",
 			mods: func() []ModuleDescriptor {
-				mod := struct{ ProtoProvisioner }{}
-				mod.descriptor = func() ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
 					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
 				}
-				mod.provision = func(ctx *Context) error { return nil }
-
+				mod.ProvisionMock = func(ctx *Context) error { return nil }
 				return []ModuleDescriptor{mod.Descriptor()}
 			}(),
-			kind: new(Provisioner),
+			kind:        new(Provisioner),
+			expectError: false,
 		},
 	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			ctx := NewContext(ParsedFlags{}, tc.mods)
+			_, err := ctx.Module(tc.kind)

-		ctx := NewContext(ParsedFlags{}, tc.mods)
-		_, err := ctx.Module(tc.kind)
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

 func TestContext_Modules(t *testing.T) {
-	for i, tc := range []struct {
-		mods      []ModuleDescriptor
-		kind      interface{}
-		expectErr bool
+	for _, tc := range []struct {
+		scenario    string
+		mods        []ModuleDescriptor
+		kind        interface{}
+		expectError bool
 	}{
 		{
+			scenario: "module with error on provision",
 			mods: func() []ModuleDescriptor {
-				mod := struct{ ProtoProvisioner }{}
-				mod.descriptor = func() ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
 					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
 				}
-				mod.provision = func(ctx *Context) error { return errors.New("foo") }
-
+				mod.ProvisionMock = func(ctx *Context) error { return errors.New("foo") }
 				return []ModuleDescriptor{mod.Descriptor()}
 			}(),
-			kind:      new(Provisioner),
-			expectErr: true,
+			kind:        new(Provisioner),
+			expectError: true,
 		},
 		{
+			scenario: "success (module)",
 			mods: func() []ModuleDescriptor {
-				mod := struct{ ProtoProvisioner }{}
-				mod.descriptor = func() ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
 					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
 				}
-				mod.provision = func(ctx *Context) error { return nil }
-
+				mod.ProvisionMock = func(ctx *Context) error { return nil }
 				return []ModuleDescriptor{mod.Descriptor(), mod.Descriptor()}
 			}(),
-			kind: new(Provisioner),
+			kind:        new(Provisioner),
+			expectError: false,
 		},
 		{
+			scenario: "success (one module)",
 			mods: func() []ModuleDescriptor {
-				mod := struct{ ProtoProvisioner }{}
-				mod.descriptor = func() ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
 					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
 				}
-				mod.provision = func(ctx *Context) error { return nil }
+				mod.ProvisionMock = func(ctx *Context) error { return nil }

 				return []ModuleDescriptor{mod.Descriptor()}
 			}(),
-			kind: new(Provisioner),
+			kind:        new(Provisioner),
+			expectError: false,
 		},
 	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			ctx := NewContext(ParsedFlags{}, tc.mods)
+			_, err := ctx.Modules(tc.kind)

-		ctx := NewContext(ParsedFlags{}, tc.mods)
-		_, err := ctx.Modules(tc.kind)
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

 func TestContext_loadModule(t *testing.T) {
-	for i, tc := range []struct {
-		instance  interface{}
-		expectErr bool
+	for _, tc := range []struct {
+		scenario    string
+		instance    interface{}
+		expectError bool
 	}{
 		{
+			scenario: "module with error on provision",
 			instance: func() interface{} {
-				mod := struct{ ProtoProvisioner }{}
-				mod.descriptor = func() ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
 					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
 				}
-				mod.provision = func(ctx *Context) error { return errors.New("foo") }
-
+				mod.ProvisionMock = func(ctx *Context) error { return errors.New("foo") }
 				return mod
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
+			scenario: "module with error on validation",
 			instance: func() interface{} {
-				mod := struct{ ProtoValidator }{}
-				mod.descriptor = func() ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ValidatorMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
 					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
 				}
-				mod.validate = func() error { return errors.New("foo") }
-
+				mod.ValidateMock = func() error { return errors.New("foo") }
 				return mod
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
+			scenario: "success",
 			instance: func() interface{} {
-				mod := struct{ ProtoValidator }{}
-				mod.descriptor = func() ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ValidatorMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
 					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
 				}
-				mod.validate = func() error { return nil }
+				mod.ValidateMock = func() error { return nil }

 				return mod
 			}(),
+			expectError: false,
 		},
 	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			ctx := NewContext(ParsedFlags{}, nil)
+			err := ctx.loadModule("foo", tc.instance)

-		ctx := NewContext(ParsedFlags{}, nil)
-		err := ctx.loadModule("foo", tc.instance)
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }
--- a/pkg/gotenberg/flags.go
+++ b/pkg/gotenberg/flags.go
@@ -8,7 +8,7 @@ import (
 	flag "github.com/spf13/pflag"
 )

-// ParsedFlags wraps a flag.FlagSet so that retrieving the typed values is
+// ParsedFlags wraps a [flag.FlagSet] so that retrieving the typed values is
 // easier.
 type ParsedFlags struct {
 	*flag.FlagSet
@@ -25,6 +25,17 @@ func (f *ParsedFlags) MustString(name string) string {
 	return val
 }

+// MustDeprecatedString returns the string value of a deprecated flag if it was
+// explicitly set or the string value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedString(deprecated string, newName string) string {
+	if f.Changed(deprecated) {
+		return f.MustString(deprecated)
+	}
+
+	return f.MustString(newName)
+}
+
 // MustStringSlice returns the string slice value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustStringSlice(name string) []string {
@@ -36,6 +47,17 @@ func (f *ParsedFlags) MustStringSlice(name string) []string {
 	return val
 }

+// MustDeprecatedStringSlice returns the string slice value of a deprecated
+// flag if it was explicitly set or the string slice value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedStringSlice(deprecated string, newName string) []string {
+	if f.Changed(deprecated) {
+		return f.MustStringSlice(deprecated)
+	}
+
+	return f.MustStringSlice(newName)
+}
+
 // MustBool returns the boolean value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustBool(name string) bool {
@@ -47,6 +69,39 @@ func (f *ParsedFlags) MustBool(name string) bool {
 	return val
 }

+// MustDeprecatedBool returns the boolean value of a deprecated flag if it was
+// explicitly set or the int value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedBool(deprecated string, newName string) bool {
+	if f.Changed(deprecated) {
+		return f.MustBool(deprecated)
+	}
+
+	return f.MustBool(newName)
+}
+
+// MustInt64 returns the int64 value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustInt64(name string) int64 {
+	val, err := f.GetInt64(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDeprecatedInt64 returns the int64 value of a deprecated flag if it was
+// explicitly set or the int64 value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedInt64(deprecated string, newName string) int64 {
+	if f.Changed(deprecated) {
+		return f.MustInt64(deprecated)
+	}
+
+	return f.MustInt64(newName)
+}
+
 // MustInt returns the int value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustInt(name string) int {
@@ -58,6 +113,17 @@ func (f *ParsedFlags) MustInt(name string) int {
 	return val
 }

+// MustDeprecatedInt returns the int value of a deprecated flag if it was
+// explicitly set or the int value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedInt(deprecated string, newName string) int {
+	if f.Changed(deprecated) {
+		return f.MustInt(deprecated)
+	}
+
+	return f.MustInt(newName)
+}
+
 // MustFloat64 returns the float value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustFloat64(name string) float64 {
@@ -69,6 +135,17 @@ func (f *ParsedFlags) MustFloat64(name string) float64 {
 	return val
 }

+// MustDeprecatedFloat64 returns the float value of a deprecated flag if it was
+// explicitly set or the float value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedFloat64(deprecated string, newName string) float64 {
+	if f.Changed(deprecated) {
+		return f.MustFloat64(deprecated)
+	}
+
+	return f.MustFloat64(newName)
+}
+
 // MustDuration returns the time.Duration value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustDuration(name string) time.Duration {
@@ -80,6 +157,17 @@ func (f *ParsedFlags) MustDuration(name string) time.Duration {
 	return val
 }

+// MustDeprecatedDuration returns the time.Duration value of a deprecated flag
+// if it was explicitly set or the time.Duration value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedDuration(deprecated string, newName string) time.Duration {
+	if f.Changed(deprecated) {
+		return f.MustDuration(deprecated)
+	}
+
+	return f.MustDuration(newName)
+}
+
 // MustHumanReadableBytesString returns the human-readable bytes string of a
 // flag given by name.
 // It panics if an error occurs.
@@ -97,6 +185,18 @@ func (f *ParsedFlags) MustHumanReadableBytesString(name string) string {
 	return val
 }

+// MustDeprecatedHumanReadableBytesString returns the human-readable bytes
+// string of a deprecated flag if it was explicitly set or the human-readable
+// bytes string of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedHumanReadableBytesString(deprecated string, newName string) string {
+	if f.Changed(deprecated) {
+		return f.MustHumanReadableBytesString(deprecated)
+	}
+
+	return f.MustHumanReadableBytesString(newName)
+}
+
 // MustRegexp returns the regular expression of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustRegexp(name string) *regexp.Regexp {
@@ -107,3 +207,14 @@ func (f *ParsedFlags) MustRegexp(name string) *regexp.Regexp {

 	return regexp.MustCompile(val)
 }
+
+// MustDeprecatedRegexp returns the regular expression of a deprecated flag if
+// it was explicitly set or the regular expression of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedRegexp(deprecated string, newName string) *regexp.Regexp {
+	if f.Changed(deprecated) {
+		return f.MustRegexp(deprecated)
+	}
+
+	return f.MustRegexp(newName)
+}
--- a/pkg/gotenberg/flags_test.go
+++ b/pkg/gotenberg/flags_test.go
@@ -1,6 +1,8 @@
 package gotenberg

 import (
+	"reflect"
+	"regexp"
 	"testing"
 	"time"

@@ -18,23 +20,27 @@ func TestParsedFlags_MustString(t *testing.T) {

 	parsedFlags := ParsedFlags{FlagSet: fs}

-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		name        string
 		expectPanic bool
 	}{
 		{
-			name: "foo",
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
 		},
 		{
+			scenario:    "non-existing flag",
 			name:        "bar",
 			expectPanic: true,
 		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
 				defer func() {
 					if r := recover(); r == nil {
-						t.Errorf("test %d: expected panic but got none", i)
+						t.Fatal("expected panic but got none")
 					}
 				}()
 			}
@@ -42,13 +48,55 @@ func TestParsedFlags_MustString(t *testing.T) {
 			if !tc.expectPanic {
 				defer func() {
 					if r := recover(); r != nil {
-						t.Errorf("test %d: expected no panic but got: %v", i, r)
+						t.Fatalf("expected no panic but got: %v", r)
 					}
 				}()
 			}

 			parsedFlags.MustString(tc.name)
-		}()
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedString(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue string
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: "foo",
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: "bar",
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: "foo",
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.String("foo", "", "")
+			fs.String("bar", "", "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedString("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected '%s' but got '%s'", tc.expectValue, actual)
+			}
+		})
 	}
 }

@@ -63,23 +111,27 @@ func TestParsedFlags_MustStringSlice(t *testing.T) {

 	parsedFlags := ParsedFlags{FlagSet: fs}

-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		name        string
 		expectPanic bool
 	}{
 		{
-			name: "foo",
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
 		},
 		{
+			scenario:    "non-existing flag",
 			name:        "bar",
 			expectPanic: true,
 		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
 				defer func() {
 					if r := recover(); r == nil {
-						t.Errorf("test %d: expected panic but got none", i)
+						t.Fatal("expected panic but got none")
 					}
 				}()
 			}
@@ -87,13 +139,55 @@ func TestParsedFlags_MustStringSlice(t *testing.T) {
 			if !tc.expectPanic {
 				defer func() {
 					if r := recover(); r != nil {
-						t.Errorf("test %d: expected no panic but got: %v", i, r)
+						t.Fatalf("expected no panic but got: %v", r)
 					}
 				}()
 			}

 			parsedFlags.MustStringSlice(tc.name)
-		}()
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedStringSlice(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue []string
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: []string{"foo"},
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: []string{"bar"},
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: []string{"foo"},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.StringSlice("foo", make([]string, 0), "")
+			fs.StringSlice("bar", make([]string, 0), "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedStringSlice("foo", "bar")
+			if !reflect.DeepEqual(actual, tc.expectValue) {
+				t.Errorf("expected %+v but got %+v", tc.expectValue, actual)
+			}
+		})
 	}
 }

@@ -108,23 +202,27 @@ func TestParsedFlags_MustBool(t *testing.T) {

 	parsedFlags := ParsedFlags{FlagSet: fs}

-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		name        string
 		expectPanic bool
 	}{
 		{
-			name: "foo",
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
 		},
 		{
+			scenario:    "non-existing flag",
 			name:        "bar",
 			expectPanic: true,
 		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
 				defer func() {
 					if r := recover(); r == nil {
-						t.Errorf("test %d: expected panic but got none", i)
+						t.Fatal("expected panic but got none")
 					}
 				}()
 			}
@@ -132,13 +230,144 @@ func TestParsedFlags_MustBool(t *testing.T) {
 			if !tc.expectPanic {
 				defer func() {
 					if r := recover(); r != nil {
-						t.Errorf("test %d: expected no panic but got: %v", i, r)
+						t.Fatalf("expected no panic but got: %v", r)
 					}
 				}()
 			}

 			parsedFlags.MustBool(tc.name)
-		}()
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedBool(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue bool
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=true"},
+			expectValue: true,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=false"},
+			expectValue: false,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=true", "--bar=false"},
+			expectValue: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.Bool("foo", false, "")
+			fs.Bool("bar", true, "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedBool("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected %v but got %v", tc.expectValue, actual)
+			}
+		})
+	}
+}
+
+func TestParsedFlags_MustInt64(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Int64("foo", 0, "")
+
+	err := fs.Parse([]string{"--foo=1"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustInt64(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedInt64(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue int64
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1"},
+			expectValue: 1,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2"},
+			expectValue: 2,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1", "--bar=2"},
+			expectValue: 1,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Int64("foo", 0, "")
+		fs.Int64("bar", 0, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("expected no error but got: %v", err)
+		}
+
+		actual := parsedFlags.MustDeprecatedInt64("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("expected %d but got %d", tc.expectValue, actual)
+		}
 	}
 }

@@ -153,23 +382,27 @@ func TestParsedFlags_MustInt(t *testing.T) {

 	parsedFlags := ParsedFlags{FlagSet: fs}

-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		name        string
 		expectPanic bool
 	}{
 		{
-			name: "foo",
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
 		},
 		{
+			scenario:    "non-existing flag",
 			name:        "bar",
 			expectPanic: true,
 		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
 				defer func() {
 					if r := recover(); r == nil {
-						t.Errorf("test %d: expected panic but got none", i)
+						t.Fatal("expected panic but got none")
 					}
 				}()
 			}
@@ -177,13 +410,55 @@ func TestParsedFlags_MustInt(t *testing.T) {
 			if !tc.expectPanic {
 				defer func() {
 					if r := recover(); r != nil {
-						t.Errorf("test %d: expected no panic but got: %v", i, r)
+						t.Fatalf("expected no panic but got: %v", r)
 					}
 				}()
 			}

 			parsedFlags.MustInt(tc.name)
-		}()
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedInt(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue int
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1"},
+			expectValue: 1,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2"},
+			expectValue: 2,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1", "--bar=2"},
+			expectValue: 1,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.Int("foo", 0, "")
+			fs.Int("bar", 0, "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedInt("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected %d but got %d", tc.expectValue, actual)
+			}
+		})
 	}
 }

@@ -198,23 +473,27 @@ func TestParsedFlags_MustFloat64(t *testing.T) {

 	parsedFlags := ParsedFlags{FlagSet: fs}

-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		name        string
 		expectPanic bool
 	}{
 		{
-			name: "foo",
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
 		},
 		{
+			scenario:    "non-existing flag",
 			name:        "bar",
 			expectPanic: true,
 		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
 				defer func() {
 					if r := recover(); r == nil {
-						t.Errorf("test %d: expected panic but got none", i)
+						t.Fatal("expected panic but got none")
 					}
 				}()
 			}
@@ -222,13 +501,55 @@ func TestParsedFlags_MustFloat64(t *testing.T) {
 			if !tc.expectPanic {
 				defer func() {
 					if r := recover(); r != nil {
-						t.Errorf("test %d: expected no panic but got: %v", i, r)
+						t.Fatalf("expected no panic but got: %v", r)
 					}
 				}()
 			}

 			parsedFlags.MustFloat64(tc.name)
-		}()
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedFloat64(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue float64
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1.0"},
+			expectValue: 1.0,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2.0"},
+			expectValue: 2.0,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1.0", "--bar=2.0"},
+			expectValue: 1.0,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.Float64("foo", 0, "")
+			fs.Float64("bar", 0, "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedFloat64("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected %f but got %f", tc.expectValue, actual)
+			}
+		})
 	}
 }

@@ -243,23 +564,27 @@ func TestParsedFlags_MustDuration(t *testing.T) {

 	parsedFlags := ParsedFlags{FlagSet: fs}

-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		name        string
 		expectPanic bool
 	}{
 		{
-			name: "foo",
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
 		},
 		{
+			scenario:    "non-existing flag",
 			name:        "bar",
 			expectPanic: true,
 		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
 				defer func() {
 					if r := recover(); r == nil {
-						t.Errorf("test %d: expected panic but got none", i)
+						t.Fatal("expected panic but got none")
 					}
 				}()
 			}
@@ -267,13 +592,55 @@ func TestParsedFlags_MustDuration(t *testing.T) {
 			if !tc.expectPanic {
 				defer func() {
 					if r := recover(); r != nil {
-						t.Errorf("test %d: expected no panic but got: %v", i, r)
+						t.Fatalf("expected no panic but got: %v", r)
 					}
 				}()
 			}

 			parsedFlags.MustDuration(tc.name)
-		}()
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedDuration(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue time.Duration
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1s"},
+			expectValue: time.Duration(1) * time.Second,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2s"},
+			expectValue: time.Duration(2) * time.Second,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1s", "--bar=2s"},
+			expectValue: time.Duration(1) * time.Second,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.Duration("foo", 0, "")
+			fs.Duration("bar", 0, "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedDuration("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected '%s' but got '%s'", tc.expectValue, actual)
+			}
+		})
 	}
 }

@@ -289,27 +656,27 @@ func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {

 	parsedFlags := ParsedFlags{FlagSet: fs}

-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		name        string
 		expectPanic bool
 	}{
 		{
-			name: "foo",
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
 		},
 		{
+			scenario:    "non-existing flag",
 			name:        "bar",
 			expectPanic: true,
 		},
-		{
-			name:        "baz",
-			expectPanic: true,
-		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
 				defer func() {
 					if r := recover(); r == nil {
-						t.Errorf("test %d: expected panic but got none", i)
+						t.Fatal("expected panic but got none")
 					}
 				}()
 			}
@@ -317,13 +684,55 @@ func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
 			if !tc.expectPanic {
 				defer func() {
 					if r := recover(); r != nil {
-						t.Errorf("test %d: expected no panic but got: %v", i, r)
+						t.Fatalf("expected no panic but got: %v", r)
 					}
 				}()
 			}

 			parsedFlags.MustHumanReadableBytesString(tc.name)
-		}()
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedHumanReadableBytesString(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue string
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1MB"},
+			expectValue: "1MB",
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2MB"},
+			expectValue: "2MB",
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1MB", "--bar=2MB"},
+			expectValue: "1MB",
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.String("foo", "", "")
+			fs.String("bar", "", "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedHumanReadableBytesString("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected '%s' but got '%s'", tc.expectValue, actual)
+			}
+		})
 	}
 }

@@ -339,27 +748,27 @@ func TestParsedFlags_MustRegexp(t *testing.T) {

 	parsedFlags := ParsedFlags{FlagSet: fs}

-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		name        string
 		expectPanic bool
 	}{
 		{
-			name: "foo",
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
 		},
 		{
+			scenario:    "non-existing flag",
 			name:        "bar",
 			expectPanic: true,
 		},
-		{
-			name:        "baz",
-			expectPanic: true,
-		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
 				defer func() {
 					if r := recover(); r == nil {
-						t.Errorf("test %d: expected panic but got none", i)
+						t.Fatal("expected panic but got none")
 					}
 				}()
 			}
@@ -367,12 +776,54 @@ func TestParsedFlags_MustRegexp(t *testing.T) {
 			if !tc.expectPanic {
 				defer func() {
 					if r := recover(); r != nil {
-						t.Errorf("test %d: expected no panic but got: %v", i, r)
+						t.Fatalf("expected no panic but got: %v", r)
 					}
 				}()
 			}

 			parsedFlags.MustRegexp(tc.name)
-		}()
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedRegexp(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue *regexp.Regexp
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: regexp.MustCompile("foo"),
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: regexp.MustCompile("bar"),
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: regexp.MustCompile("foo"),
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.String("foo", "", "")
+			fs.String("bar", "", "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedRegexp("foo", "bar")
+			if actual.String() != tc.expectValue.String() {
+				t.Errorf("expected '%s' but got '%s'", tc.expectValue.String(), actual.String())
+			}
+		})
 	}
 }
--- a/pkg/gotenberg/fs.go
+++ b/pkg/gotenberg/fs.go
@@ -7,24 +7,44 @@ import (
 	"github.com/google/uuid"
 )

-// TmpPath returns the default directory to use for temporary files and
-// directories. Most if not all files and directories created by the
-// application and its dependencies must be based on this default directory.
-func TmpPath() string {
-	return os.TempDir()
+// FileSystem provides utilities for managing temporary directories. It creates
+// unique directory names based on UUIDs to ensure isolation of temporary files
+// for different modules.
+type FileSystem struct {
+	workingDir string
 }

-// NewDirPath returns a random absolute path based on the temporary path.
-func NewDirPath() string {
-	return fmt.Sprintf("%s/%s", TmpPath(), uuid.New())
+// NewFileSystem initializes a new [FileSystem] instance with a unique working
+// directory.
+func NewFileSystem() *FileSystem {
+	return &FileSystem{
+		workingDir: uuid.NewString(),
+	}
 }

-// MkdirAll creates a random directory based on the temporary path and
-// returns its absolute path.
-func MkdirAll() (string, error) {
-	path := NewDirPath()
+// WorkingDir returns the unique name of the working directory.
+func (fs *FileSystem) WorkingDir() string {
+	return fs.workingDir
+}

-	err := os.MkdirAll(path, 0755)
+// WorkingDirPath constructs and returns the full path to the working directory
+// inside the system's temporary directory.
+func (fs *FileSystem) WorkingDirPath() string {
+	return fmt.Sprintf("%s/%s", os.TempDir(), fs.workingDir)
+}
+
+// NewDirPath generates a new unique path for a directory inside the working
+// directory.
+func (fs *FileSystem) NewDirPath() string {
+	return fmt.Sprintf("%s/%s", fs.WorkingDirPath(), uuid.NewString())
+}
+
+// MkdirAll creates a new unique directory inside the working directory and
+// returns its path. If the directory creation fails, an error is returned.
+func (fs *FileSystem) MkdirAll() (string, error) {
+	path := fs.NewDirPath()
+
+	err := os.MkdirAll(path, 0o755)
 	if err != nil {
 		return "", fmt.Errorf("create directory %s: %w", path, err)
 	}
--- a/pkg/gotenberg/fs_test.go
+++ b/pkg/gotenberg/fs_test.go
@@ -1,59 +1,55 @@
 package gotenberg

 import (
+	"fmt"
 	"os"
 	"strings"
 	"testing"
 )

-func TestTmpPath(t *testing.T) {
-	osTempDir := os.TempDir()
-	tmpPath := TmpPath()
+func TestFileSystem_WorkingDir(t *testing.T) {
+	fs := NewFileSystem()
+	dirName := fs.WorkingDir()

-	if tmpPath != osTempDir {
-		t.Errorf("expected path '%s' but got '%s'", osTempDir, tmpPath)
+	if dirName == "" {
+		t.Error("expected directory name but got empty string")
 	}
 }

-func TestNewDirPath(t *testing.T) {
-	newDirPath := NewDirPath()
-	tmpPath := TmpPath()
+func TestFileSystem_WorkingDirPath(t *testing.T) {
+	fs := NewFileSystem()
+	expectedPath := fmt.Sprintf("%s/%s", os.TempDir(), fs.WorkingDir())

-	if !strings.HasPrefix(newDirPath, tmpPath) {
-		t.Fatalf("expected path '%s' to start with '%s'", newDirPath, tmpPath)
-	}
-
-	newDirPaths := make([]string, 1000)
-	for i := range newDirPaths {
-		newDirPaths[i] = NewDirPath()
-	}
-
-	for i, newDirPath := range newDirPaths {
-		for j, comparison := range newDirPaths {
-			if i == j {
-				continue
-			}
-
-			if newDirPath == comparison {
-				t.Fatalf("expected path '%s' (index %d) to be unique, but found an identical path on index %d", newDirPath, i, j)
-			}
-		}
+	if fs.WorkingDirPath() != expectedPath {
+		t.Errorf("expected path '%s' but got '%s'", expectedPath, fs.WorkingDirPath())
 	}
 }

-func TestMkdirAll(t *testing.T) {
-	path, err := MkdirAll()
+func TestFileSystem_NewDirPath(t *testing.T) {
+	fs := NewFileSystem()
+	newDir := fs.NewDirPath()
+	expectedPrefix := fs.WorkingDirPath()
+
+	if !strings.HasPrefix(newDir, expectedPrefix) {
+		t.Errorf("expected new directory to start with '%s' but got '%s'", expectedPrefix, newDir)
+	}
+}
+
+func TestFileSystem_MkdirAll(t *testing.T) {
+	fs := NewFileSystem()
+
+	newPath, err := fs.MkdirAll()
 	if err != nil {
 		t.Fatalf("expected no error but got: %v", err)
 	}

-	tmpPath := TmpPath()
-	if !strings.HasPrefix(path, tmpPath) {
-		t.Fatalf("expected path '%s' to start with '%s'", path, tmpPath)
+	_, err = os.Stat(newPath)
+	if os.IsNotExist(err) {
+		t.Errorf("expected directory '%s' to exist but it doesn't", newPath)
 	}

-	_, err = os.Stat(path)
-	if os.IsNotExist(err) {
-		t.Errorf("expected path '%s' to exist but got: %v", path, err)
+	err = os.RemoveAll(fs.WorkingDirPath())
+	if err != nil {
+		t.Fatalf("expected no error while cleaning up but got: %v", err)
 	}
 }
--- a/pkg/gotenberg/gc.go
+++ b/pkg/gotenberg/gc.go
@@ -0,0 +1,53 @@
+package gotenberg
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"go.uber.org/zap"
+)
+
+// GarbageCollect scans the root path and deletes files or directories with
+// names containing specific substrings.
+func GarbageCollect(logger *zap.Logger, rootPath string, includeSubstr []string) error {
+	logger = logger.Named("gc")
+
+	// To make sure that the next Walk method stays on
+	// the root level of the considered path, we have to
+	// return a filepath.SkipDir error if the current path
+	// is a directory.
+	skipDirOrNil := func(info os.FileInfo) error {
+		if info.IsDir() {
+			return filepath.SkipDir
+		}
+
+		return nil
+	}
+
+	return filepath.Walk(rootPath, func(path string, info os.FileInfo, pathErr error) error {
+		if pathErr != nil {
+			return pathErr
+		}
+
+		if path == rootPath {
+			return nil
+		}
+
+		for _, substr := range includeSubstr {
+			if strings.Contains(info.Name(), substr) || path == substr {
+				err := os.RemoveAll(path)
+				if err != nil {
+					return fmt.Errorf("garbage collect '%s': %w", path, err)
+				}
+
+				logger.Debug(fmt.Sprintf("'%s' removed", path))
+
+				return skipDirOrNil(info)
+			}
+		}
+
+		return skipDirOrNil(info)
+	})
+}
--- a/pkg/gotenberg/gc_test.go
+++ b/pkg/gotenberg/gc_test.go
@@ -0,0 +1,98 @@
+package gotenberg
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/google/uuid"
+	"go.uber.org/zap"
+)
+
+func TestGarbageCollect(t *testing.T) {
+	for _, tc := range []struct {
+		scenario        string
+		rootPath        string
+		includeSubstr   []string
+		expectError     bool
+		expectNotExists []string
+		expectExists    []string
+	}{
+		{
+			scenario:    "root path does not exist",
+			rootPath:    uuid.NewString(),
+			expectError: true,
+		},
+		{
+			scenario: "remove include substrings",
+			rootPath: func() string {
+				path := fmt.Sprintf("%s/a_directory", os.TempDir())
+
+				err := os.MkdirAll(path, 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/a_foo_file", path), []byte{1}, 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/a_bar_file", path), []byte{1}, 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/a_baz_file", path), []byte{1}, 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return path
+			}(),
+			includeSubstr:   []string{"foo", fmt.Sprintf("%s/a_directory/a_bar_file", os.TempDir())},
+			expectError:     false,
+			expectExists:    []string{"a_baz_file"},
+			expectNotExists: []string{"a_foo_file", "a_bar_file"},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			defer func() {
+				err := os.RemoveAll(tc.rootPath)
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
+				}
+			}()
+
+			err := GarbageCollect(zap.NewNop(), tc.rootPath, tc.includeSubstr)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.expectError && err != nil {
+				return
+			}
+
+			for _, name := range tc.expectNotExists {
+				path := fmt.Sprintf("%s/%s", tc.rootPath, name)
+				_, err = os.Stat(path)
+				if !os.IsNotExist(err) {
+					t.Errorf("expected '%s' not to exist but it does: %v", path, err)
+				}
+			}
+
+			for _, name := range tc.expectExists {
+				path := fmt.Sprintf("%s/%s", tc.rootPath, name)
+				_, err = os.Stat(path)
+				if os.IsNotExist(err) {
+					t.Errorf("expected '%s' to exist but it does not: %v", path, err)
+				}
+			}
+		})
+	}
+}
--- a/pkg/gotenberg/logging.go
+++ b/pkg/gotenberg/logging.go
@@ -2,8 +2,8 @@ package gotenberg

 import "go.uber.org/zap"

-// LoggerProvider is a module interface which exposes a method for creating a
-// zap.Logger for other modules.
+// LoggerProvider is an interface for a module that supplies a method for
+// creating a [zap.Logger] instance for use by other modules.
 //
 //	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
 //		provider, _ := ctx.Module(new(gotenberg.LoggerProvider))
--- a/pkg/gotenberg/metrics.go
+++ b/pkg/gotenberg/metrics.go
@@ -0,0 +1,26 @@
+package gotenberg
+
+// Metric represents a unitary metric.
+type Metric struct {
+	// Name is the unique identifier.
+	// Required.
+	Name string
+
+	// Description describes the metric.
+	// Optional.
+	Description string
+
+	// Read returns the current value.
+	// Required.
+	Read func() float64
+}
+
+// MetricsProvider is a module interface which provides a list of [Metric].
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(gotenberg.MetricsProvider))
+//		metrics, _  := provider.(gotenberg.MetricsProvider).Metrics()
+//	}
+type MetricsProvider interface {
+	Metrics() ([]Metric, error)
+}
--- a/pkg/gotenberg/mocks.go
+++ b/pkg/gotenberg/mocks.go
@@ -0,0 +1,140 @@
+package gotenberg
+
+import (
+	"context"
+
+	"go.uber.org/zap"
+)
+
+// ModuleMock is a mock for the [Module] interface.
+type ModuleMock struct {
+	DescriptorMock func() ModuleDescriptor
+}
+
+func (mod *ModuleMock) Descriptor() ModuleDescriptor {
+	return mod.DescriptorMock()
+}
+
+// ProvisionerMock is a mock for the [Provisioner] interface.
+type ProvisionerMock struct {
+	ProvisionMock func(*Context) error
+}
+
+func (mod *ProvisionerMock) Provision(ctx *Context) error {
+	return mod.ProvisionMock(ctx)
+}
+
+// ValidatorMock is a mock for the [Validator] interface.
+type ValidatorMock struct {
+	ValidateMock func() error
+}
+
+func (mod *ValidatorMock) Validate() error {
+	return mod.ValidateMock()
+}
+
+// PdfEngineMock is a mock for the [PdfEngine] interface.
+type PdfEngineMock struct {
+	MergeMock   func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error
+	ConvertMock func(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error
+}
+
+func (engine *PdfEngineMock) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+	return engine.MergeMock(ctx, logger, inputPaths, outputPath)
+}
+
+func (engine *PdfEngineMock) Convert(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error {
+	return engine.ConvertMock(ctx, logger, formats, inputPath, outputPath)
+}
+
+// PdfEngineProviderMock is a mock for the [PdfEngineProvider] interface.
+type PdfEngineProviderMock struct {
+	PdfEngineMock func() (PdfEngine, error)
+}
+
+func (provider *PdfEngineProviderMock) PdfEngine() (PdfEngine, error) {
+	return provider.PdfEngineMock()
+}
+
+// ProcessMock is a mock for the [Process] interface.
+type ProcessMock struct {
+	StartMock   func(logger *zap.Logger) error
+	StopMock    func(logger *zap.Logger) error
+	HealthyMock func(logger *zap.Logger) bool
+}
+
+func (p *ProcessMock) Start(logger *zap.Logger) error {
+	return p.StartMock(logger)
+}
+
+func (p *ProcessMock) Stop(logger *zap.Logger) error {
+	return p.StopMock(logger)
+}
+
+func (p *ProcessMock) Healthy(logger *zap.Logger) bool {
+	return p.HealthyMock(logger)
+}
+
+// ProcessSupervisorMock is a mock for the [ProcessSupervisor] interface.
+type ProcessSupervisorMock struct {
+	LaunchMock        func() error
+	ShutdownMock      func() error
+	HealthyMock       func() bool
+	RunMock           func(ctx context.Context, logger *zap.Logger, task func() error) error
+	ReqQueueSizeMock  func() int64
+	RestartsCountMock func() int64
+}
+
+func (s *ProcessSupervisorMock) Launch() error {
+	return s.LaunchMock()
+}
+
+func (s *ProcessSupervisorMock) Shutdown() error {
+	return s.ShutdownMock()
+}
+
+func (s *ProcessSupervisorMock) Healthy() bool {
+	return s.HealthyMock()
+}
+
+func (s *ProcessSupervisorMock) Run(ctx context.Context, logger *zap.Logger, task func() error) error {
+	return s.RunMock(ctx, logger, task)
+}
+
+func (s *ProcessSupervisorMock) ReqQueueSize() int64 {
+	return s.ReqQueueSizeMock()
+}
+
+func (s *ProcessSupervisorMock) RestartsCount() int64 {
+	return s.RestartsCountMock()
+}
+
+// LoggerProviderMock is a mock for the [LoggerProvider] interface.
+type LoggerProviderMock struct {
+	LoggerMock func(mod Module) (*zap.Logger, error)
+}
+
+func (provider *LoggerProviderMock) Logger(mod Module) (*zap.Logger, error) {
+	return provider.LoggerMock(mod)
+}
+
+// MetricsProviderMock is a mock for the [MetricsProvider] interface.
+type MetricsProviderMock struct {
+	MetricsMock func() ([]Metric, error)
+}
+
+func (provider *MetricsProviderMock) Metrics() ([]Metric, error) {
+	return provider.MetricsMock()
+}
+
+// Interface guards.
+var (
+	_ Module            = (*ModuleMock)(nil)
+	_ Validator         = (*ValidatorMock)(nil)
+	_ PdfEngine         = (*PdfEngineMock)(nil)
+	_ PdfEngineProvider = (*PdfEngineProviderMock)(nil)
+	_ Process           = (*ProcessMock)(nil)
+	_ ProcessSupervisor = (*ProcessSupervisorMock)(nil)
+	_ LoggerProvider    = (*LoggerProviderMock)(nil)
+	_ MetricsProvider   = (*MetricsProviderMock)(nil)
+)
--- a/pkg/gotenberg/mocks_test.go
+++ b/pkg/gotenberg/mocks_test.go
@@ -0,0 +1,190 @@
+package gotenberg
+
+import (
+	"context"
+	"testing"
+
+	"go.uber.org/zap"
+)
+
+func TestModuleMock(t *testing.T) {
+	mock := &ModuleMock{
+		DescriptorMock: func() ModuleDescriptor {
+			return ModuleDescriptor{ID: "foo", New: func() Module {
+				return nil
+			}}
+		},
+	}
+
+	if mock.Descriptor().ID != "foo" {
+		t.Errorf("expected ID '%s' from ModuleMock.Descriptor, but got '%s'", "foo", mock.Descriptor().ID)
+	}
+}
+
+func TestProvisionerMock(t *testing.T) {
+	mock := &ProvisionerMock{
+		ProvisionMock: func(*Context) error {
+			return nil
+		},
+	}
+
+	err := mock.Provision(&Context{})
+	if err != nil {
+		t.Errorf("expected no error from ProvisionerMock.Provision, but got: %v", err)
+	}
+}
+
+func TestValidatorMock(t *testing.T) {
+	mock := &ValidatorMock{
+		ValidateMock: func() error {
+			return nil
+		},
+	}
+
+	err := mock.Validate()
+	if err != nil {
+		t.Errorf("expected no error from ValidatorMock.Validate, but got: %v", err)
+	}
+}
+
+func TestPDFEngineMock(t *testing.T) {
+	mock := &PdfEngineMock{
+		MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+			return nil
+		},
+		ConvertMock: func(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error {
+			return nil
+		},
+	}
+
+	err := mock.Merge(context.Background(), zap.NewNop(), nil, "")
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineMock.Merge, but got: %v", err)
+	}
+
+	err = mock.Convert(context.Background(), zap.NewNop(), PdfFormats{}, "", "")
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineMock.Convert, but got: %v", err)
+	}
+}
+
+func TestPDFEngineProviderMock(t *testing.T) {
+	mock := &PdfEngineProviderMock{
+		PdfEngineMock: func() (PdfEngine, error) {
+			return new(PdfEngineMock), nil
+		},
+	}
+
+	_, err := mock.PdfEngine()
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineProviderMock.PdfEngine, but got: %v", err)
+	}
+}
+
+func TestProcessMock(t *testing.T) {
+	mock := &ProcessMock{
+		StartMock: func(logger *zap.Logger) error {
+			return nil
+		},
+		StopMock: func(logger *zap.Logger) error {
+			return nil
+		},
+		HealthyMock: func(logger *zap.Logger) bool {
+			return true
+		},
+	}
+
+	err := mock.Start(zap.NewNop())
+	if err != nil {
+		t.Errorf("expected no error from ProcessMock.Start, but got: %v", err)
+	}
+
+	err = mock.Stop(zap.NewNop())
+	if err != nil {
+		t.Errorf("expected no error from ProcessMock.Stop, but got: %v", err)
+	}
+
+	healthy := mock.Healthy(zap.NewNop())
+	if !healthy {
+		t.Error("expected true from ProcessMock.Healthy, but got false")
+	}
+}
+
+func TestProcessSupervisorMock(t *testing.T) {
+	mock := &ProcessSupervisorMock{
+		LaunchMock: func() error {
+			return nil
+		},
+		ShutdownMock: func() error {
+			return nil
+		},
+		HealthyMock: func() bool {
+			return true
+		},
+		RunMock: func(ctx context.Context, logger *zap.Logger, task func() error) error {
+			return nil
+		},
+		ReqQueueSizeMock: func() int64 {
+			return 0
+		},
+		RestartsCountMock: func() int64 {
+			return 0
+		},
+	}
+
+	err := mock.Launch()
+	if err != nil {
+		t.Errorf("expected no error from ProcessSupervisorMock.Launch, but got: %v", err)
+	}
+
+	err = mock.Shutdown()
+	if err != nil {
+		t.Errorf("expected no error from ProcessSupervisorMock.Shutdown, but got: %v", err)
+	}
+
+	healthy := mock.Healthy()
+	if !healthy {
+		t.Error("expected true from ProcessSupervisorMock.Healthy, but got false")
+	}
+
+	err = mock.Run(context.TODO(), zap.NewNop(), nil)
+	if err != nil {
+		t.Errorf("expected no error from ProcessSupervisorMock.Run, but got: %v", err)
+	}
+
+	size := mock.ReqQueueSize()
+	if size != 0 {
+		t.Errorf("expected 0 from ProcessSupervisorMock.ReqQueueSize, but got: %d", size)
+	}
+
+	restarts := mock.RestartsCount()
+	if restarts != 0 {
+		t.Errorf("expected 0 from ProcessSupervisorMock.RestartsCount, but got: %d", restarts)
+	}
+}
+
+func TestLoggerProviderMock(t *testing.T) {
+	mock := &LoggerProviderMock{
+		LoggerMock: func(mod Module) (*zap.Logger, error) {
+			return nil, nil
+		},
+	}
+
+	_, err := mock.Logger(new(ModuleMock))
+	if err != nil {
+		t.Errorf("expected no error from LoggerProviderMock.Logger, but got: %v", err)
+	}
+}
+
+func TestMetricsProviderMock(t *testing.T) {
+	mock := &MetricsProviderMock{
+		MetricsMock: func() ([]Metric, error) {
+			return nil, nil
+		},
+	}
+
+	_, err := mock.Metrics()
+	if err != nil {
+		t.Errorf("expected no error from MetricsProviderMock.Metrics, but got: %v", err)
+	}
+}
--- a/pkg/gotenberg/modules.go
+++ b/pkg/gotenberg/modules.go
@@ -69,6 +69,12 @@ type App interface {
 	Stop(ctx context.Context) error
 }

+// SystemLogger is a module interface for modules which want to display
+// messages on startup.
+type SystemLogger interface {
+	SystemMessages() []string
+}
+
 // MustRegisterModule registers a module.
 //
 // To register a module, create an init() method in the module main go file:
@@ -77,7 +83,7 @@ type App interface {
 //		gotenberg.MustRegisterModule(YourModule{})
 //	}
 //
-// Then, in the main command (github.com/gotenberg/gotenberg/v7/cmd/gotenberg),
+// Then, in the main command (github.com/gotenberg/gotenberg/v8/cmd/gotenberg),
 // import the module:
 //
 //	imports (
--- a/pkg/gotenberg/modules_test.go
+++ b/pkg/gotenberg/modules_test.go
@@ -5,32 +5,6 @@ import (
 	"testing"
 )

-type ProtoModule struct {
-	descriptor func() ModuleDescriptor
-}
-
-func (mod ProtoModule) Descriptor() ModuleDescriptor {
-	return mod.descriptor()
-}
-
-type ProtoProvisioner struct {
-	ProtoModule
-	provision func(ctx *Context) error
-}
-
-func (mod ProtoProvisioner) Provision(ctx *Context) error {
-	return mod.provision(ctx)
-}
-
-type ProtoValidator struct {
-	ProtoModule
-	validate func() error
-}
-
-func (mod ProtoValidator) Validate() error {
-	return mod.validate()
-}
-
 func TestMustRegisterModule(t *testing.T) {
 	descriptorsMu.RLock()
 	descriptors = map[string]ModuleDescriptor{
@@ -38,44 +12,51 @@ func TestMustRegisterModule(t *testing.T) {
 	}
 	descriptorsMu.RUnlock()

-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		ID          string
 		New         func() Module
 		expectPanic bool
 	}{
 		{
+			scenario:    "no ID",
 			ID:          "",
-			New:         func() Module { return new(ProtoModule) },
+			New:         func() Module { return new(ModuleMock) },
 			expectPanic: true,
 		},
 		{
+			scenario:    "nil New method",
 			ID:          "b",
 			New:         nil,
 			expectPanic: true,
 		},
 		{
+			scenario:    "nil module",
 			ID:          "b",
 			New:         func() Module { return nil },
 			expectPanic: true,
 		},
 		{
+			scenario:    "existing module",
 			ID:          "a",
-			New:         func() Module { return new(ProtoModule) },
+			New:         func() Module { return new(ModuleMock) },
 			expectPanic: true,
 		},
 		{
-			ID:  "b",
-			New: func() Module { return new(ProtoModule) },
+			scenario:    "success",
+			ID:          "b",
+			New:         func() Module { return new(ModuleMock) },
+			expectPanic: false,
 		},
 	} {
-		func() {
-			mod := struct{ ProtoModule }{}
-			mod.descriptor = func() ModuleDescriptor { return ModuleDescriptor{ID: tc.ID, New: tc.New} }
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := &struct{ ModuleMock }{}
+			mod.DescriptorMock = func() ModuleDescriptor { return ModuleDescriptor{ID: tc.ID, New: tc.New} }

 			if tc.expectPanic {
 				defer func() {
 					if r := recover(); r == nil {
-						t.Errorf("test %d: expected panic but got none", i)
+						t.Error("expected panic but got none")
 					}
 				}()
 			}
@@ -83,13 +64,13 @@ func TestMustRegisterModule(t *testing.T) {
 			if !tc.expectPanic {
 				defer func() {
 					if r := recover(); r != nil {
-						t.Errorf("test %d: expected no panic but got: %v", i, r)
+						t.Errorf("expected no panic but got: %v", r)
 					}
 				}()
 			}

 			MustRegisterModule(mod)
-		}()
+		})
 	}

 	descriptorsMu.RLock()
@@ -124,12 +105,3 @@ func TestGetModuleDescriptors(t *testing.T) {
 	descriptors = make(map[string]ModuleDescriptor)
 	descriptorsMu.RUnlock()
 }
-
-// Interface guards.
-var (
-	_ Module      = (*ProtoModule)(nil)
-	_ Provisioner = (*ProtoProvisioner)(nil)
-	_ Module      = (*ProtoProvisioner)(nil)
-	_ Validator   = (*ProtoValidator)(nil)
-	_ Module      = (*ProtoValidator)(nil)
-)
--- a/pkg/gotenberg/pdfengine.go
+++ b/pkg/gotenberg/pdfengine.go
@@ -8,45 +8,74 @@ import (
 )

 var (
-	// ErrPDFEngineMethodNotAvailable happens if a PDFEngine method is not
-	// available in the implementation.
-	ErrPDFEngineMethodNotAvailable = errors.New("method not available")
+	// ErrPdfEngineMethodNotSupported is returned when a specific method of the
+	// PdfEngine interface is not supported by its current implementation.
+	ErrPdfEngineMethodNotSupported = errors.New("method not supported")

-	// ErrPDFFormatNotAvailable happens if a PDFEngine Convert's method does
-	// not handle a specific format.
-	ErrPDFFormatNotAvailable = errors.New("PDF format not available")
+	// ErrPdfFormatNotSupported is returned when the Convert method of the
+	// PdfEngine interface does not support a requested PDF format conversion.
+	ErrPdfFormatNotSupported = errors.New("PDF format not supported")
 )

 const (
-	FormatPDFA1a string = "PDF/A-1a"
-	FormatPDFA1b string = "PDF/A-1b"
-	FormatPDFA2a string = "PDF/A-2a"
-	FormatPDFA2b string = "PDF/A-2b"
-	FormatPDFA2u string = "PDF/A-2u"
-	FormatPDFA3a string = "PDF/A-3a"
-	FormatPDFA3b string = "PDF/A-3b"
-	FormatPDFA3u string = "PDF/A-3u"
+	// PdfA1a represents the PDF/A-1a format.
+	PdfA1a string = "PDF/A-1a"
+
+	// PdfA1b represents the PDF/A-1b format.
+	PdfA1b string = "PDF/A-1b"
+
+	// PdfA2a represents the PDF/A-2a format.
+	PdfA2a string = "PDF/A-2a"
+
+	// PdfA2b represents the PDF/A-2b format.
+	PdfA2b string = "PDF/A-2b"
+
+	// PdfA2u represents the PDF/A-2u format.
+	PdfA2u string = "PDF/A-2u"
+
+	// PdfA3a represents the PDF/A-3a format.
+	PdfA3a string = "PDF/A-3a"
+
+	// PdfA3b represents the PDF/A-3b format.
+	PdfA3b string = "PDF/A-3b"
+
+	// PdfA3u represents the PDF/A-3u format.
+	PdfA3u string = "PDF/A-3u"
 )

-// PDFEngine is a module interface which exposes methods for manipulating one
-// or more PDFs. Implementations may abstract powerful tools like PDFtk, or
-// fulfill those methods contracts in Golang directly.
-type PDFEngine interface {
-	// Merge merges the given PDFs into a unique PDF. The pages' order reflects
-	// order of the given files.
+// PdfFormats specifies the target formats for a PDF conversion.
+type PdfFormats struct {
+	// PdfA denotes the PDF/A standard format (e.g., PDF/A-1a).
+	PdfA string
+
+	// PdfUa indicates whether the PDF should comply
+	// with the PDF/UA (Universal Accessibility) standard.
+	PdfUa bool
+}
+
+// PdfEngine provides an interface for operations on PDFs. Implementations
+// can utilize various tools like PDFtk, or implement functionality directly in
+// Go.
+type PdfEngine interface {
+	// Merge combines multiple PDFs into a single PDF. The resulting page order
+	// is determined by the order of files provided in inputPaths.
 	Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error

-	// Convert converts the given PDF to a specific PDF format.
-	Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error
+	// Convert transforms a given PDF to the specified formats defined in
+	// PdfFormats. If no format, it does nothing.
+	Convert(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error
 }

-// PDFEngineProvider is a module interface which exposes a method for creating a
-// PDFEngine for other modules.
+// PdfEngineProvider offers an interface to instantiate a [PdfEngine].
+// This is used to decouple the creation of a [PdfEngine] from its consumers.
+//
+// Example:
 //
 //	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
-//		provider, _  := ctx.Module(new(gotenberg.PDFEngineProvider))
-//		pdfengines, _ := provider.(gotenberg.PDFEngineProvider).PDFEngine()
+//		provider, _ := ctx.Module(new(gotenberg.PdfEngineProvider))
+//		engine, _ := provider.(gotenberg.PdfEngineProvider).PdfEngine()
 //	}
-type PDFEngineProvider interface {
-	PDFEngine() (PDFEngine, error)
+type PdfEngineProvider interface {
+	// PdfEngine returns an instance of the [PdfEngine] interface for PDF operations.
+	PdfEngine() (PdfEngine, error)
 }
--- a/pkg/gotenberg/supervisor.go
+++ b/pkg/gotenberg/supervisor.go
@@ -0,0 +1,262 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync/atomic"
+
+	"go.uber.org/zap"
+)
+
+// ErrProcessAlreadyRestarting happens if the [ProcessSupervisor] is trying
+// to restart an already restarting [Process].
+var ErrProcessAlreadyRestarting = errors.New("process already restarting")
+
+// Process is an interface that represents an abstract process
+// and provides methods for starting, stopping, and checking the health of the
+// process.
+//
+// Implementations of this interface should handle the actual logic for
+// starting, stopping, and ensuring the process's health.
+type Process interface {
+	// Start initiates the process and returns an error if the process cannot
+	// be started.
+	Start(logger *zap.Logger) error
+
+	// Stop terminates the process and returns an error if the process cannot
+	// be stopped.
+	Stop(logger *zap.Logger) error
+
+	// Healthy checks the health of the process. It returns true if the process
+	// is healthy; otherwise, it returns false.
+	Healthy(logger *zap.Logger) bool
+}
+
+// ProcessSupervisor provides methods to manage a [Process], including
+// starting, stopping, and ensuring its health.
+//
+// Additionally, it allows for the execution of tasks while managing the
+// process's state and provides functionality for limiting the number of
+// requests that can be handled by the process, as well as managing a request
+// queue.
+type ProcessSupervisor interface {
+	// Launch starts the managed [Process].
+	Launch() error
+
+	// Shutdown stops the managed [Process].
+	Shutdown() error
+
+	// Healthy checks and returns the health status of the managed [Process].
+	//
+	// If the process has not been started or is restarting, it is considered
+	// healthy and true is returned. Otherwise, it returns the health status of
+	// the actual process.
+	Healthy() bool
+
+	// Run executes a provided task while managing the state of the [Process].
+	//
+	// Run manages the request queue and may restart the process if it is not
+	// healthy or if the number of handled requests exceeds the maximum limit.
+	//
+	// It returns an error if the task cannot be run or if the process state
+	// cannot be managed properly.
+	Run(ctx context.Context, logger *zap.Logger, task func() error) error
+
+	// ReqQueueSize returns the current size of the request queue.
+	ReqQueueSize() int64
+
+	// RestartsCount returns the current number of restart.
+	RestartsCount() int64
+}
+
+type processSupervisor struct {
+	logger          *zap.Logger
+	process         Process
+	maxReqLimit     int64
+	mutexChan       chan struct{}
+	firstStart      atomic.Bool
+	reqCounter      atomic.Int64
+	reqQueueSize    atomic.Int64
+	restartsCounter atomic.Int64
+	isRestarting    atomic.Bool
+}
+
+// NewProcessSupervisor initializes a new [ProcessSupervisor].
+func NewProcessSupervisor(logger *zap.Logger, process Process, maxReqLimit int64) ProcessSupervisor {
+	b := &processSupervisor{
+		logger:      logger,
+		process:     process,
+		mutexChan:   make(chan struct{}, 1),
+		maxReqLimit: maxReqLimit,
+	}
+	b.reqCounter.Store(0)
+	b.reqQueueSize.Store(0)
+	b.restartsCounter.Store(0)
+	b.isRestarting.Store(false)
+
+	return b
+}
+
+func (s *processSupervisor) Launch() error {
+	s.logger.Debug("start process")
+	err := s.process.Start(s.logger)
+	if err != nil {
+		return fmt.Errorf("start process: %w", err)
+	}
+
+	s.firstStart.Store(true)
+	s.logger.Debug("process successfully started")
+
+	return nil
+}
+
+func (s *processSupervisor) Shutdown() error {
+	s.logger.Debug("shutdown process")
+	err := s.process.Stop(s.logger)
+	if err != nil {
+		return fmt.Errorf("shutdown process: %w", err)
+	}
+
+	s.logger.Debug("process successfully shutdown")
+
+	return nil
+}
+
+func (s *processSupervisor) restart() error {
+	if s.isRestarting.Load() {
+		s.logger.Debug("process already restarting, skip restart")
+
+		return ErrProcessAlreadyRestarting
+	}
+
+	s.logger.Debug("restart process")
+	s.isRestarting.Store(true)
+	defer s.isRestarting.Store(false)
+
+	err := s.Shutdown()
+	if err != nil {
+		// No big deal? Chances are it's already stopped.
+		s.logger.Debug(fmt.Sprintf("stop process before restart: %s", err))
+	}
+
+	err = s.Launch()
+	if err != nil {
+		return fmt.Errorf("restart process: %w", err)
+	}
+
+	s.reqCounter.Store(0)
+	s.restartsCounter.Add(1)
+	s.logger.Debug("process successfully restarted")
+
+	return nil
+}
+
+func (s *processSupervisor) Healthy() bool {
+	if !s.firstStart.Load() {
+		// A non-started process is always healthy.
+		return true
+	}
+
+	if s.isRestarting.Load() {
+		// A restarting process is always healthy.
+		return true
+	}
+
+	return s.process.Healthy(s.logger)
+}
+
+func (s *processSupervisor) Run(ctx context.Context, logger *zap.Logger, task func() error) error {
+	s.reqQueueSize.Add(1)
+
+	for {
+		err := func() error {
+			select {
+			case s.mutexChan <- struct{}{}:
+				logger.Debug("process lock acquired")
+				s.reqQueueSize.Add(-1)
+				s.reqCounter.Add(1)
+
+				defer func() {
+					logger.Debug("process lock released")
+					<-s.mutexChan
+				}()
+
+				if !s.firstStart.Load() {
+					err := s.runWithDeadline(ctx, func() error {
+						return s.Launch()
+					})
+					if err != nil {
+						return fmt.Errorf("process first start: %w", err)
+					}
+				}
+
+				if !s.Healthy() {
+					s.logger.Debug("process is unhealthy, cannot handle task, restarting...")
+					err := s.runWithDeadline(ctx, func() error {
+						return s.restart()
+					})
+					if err != nil {
+						return fmt.Errorf("process restart before task: %w", err)
+					}
+				}
+
+				if s.maxReqLimit > 0 && s.reqCounter.Load() >= s.maxReqLimit {
+					s.logger.Debug("max request limit reached, restarting...")
+					err := s.runWithDeadline(ctx, func() error {
+						return s.restart()
+					})
+					if err != nil {
+						return fmt.Errorf("process restart before task: %w", err)
+					}
+				}
+
+				// Note: no error wrapping because it leaks on Chromium console exceptions output.
+				return s.runWithDeadline(ctx, task)
+			case <-ctx.Done():
+				logger.Debug("failed to acquire process lock before deadline")
+				s.reqQueueSize.Add(-1)
+
+				return fmt.Errorf("acquire process lock: %w", ctx.Err())
+			}
+		}()
+
+		if errors.Is(err, ErrProcessAlreadyRestarting) {
+			logger.Debug("process is already restarting, trying to acquire process lock again...")
+			s.reqQueueSize.Add(1)
+			continue
+		}
+
+		// Note: no error wrapping because it leaks on Chromium console exceptions output.
+		return err
+	}
+}
+
+func (s *processSupervisor) runWithDeadline(ctx context.Context, task func() error) error {
+	runChan := make(chan error, 1)
+	go func() {
+		runChan <- task()
+	}()
+
+	for {
+		select {
+		case err := <-runChan:
+			return err
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+}
+
+func (s *processSupervisor) ReqQueueSize() int64 {
+	return s.reqQueueSize.Load()
+}
+
+func (s *processSupervisor) RestartsCount() int64 {
+	return s.restartsCounter.Load()
+}
+
+// Interface guards.
+var (
+	_ ProcessSupervisor = (*processSupervisor)(nil)
+)
--- a/pkg/gotenberg/supervisor_test.go
+++ b/pkg/gotenberg/supervisor_test.go
@@ -0,0 +1,602 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+func TestProcessSupervisor_Launch(t *testing.T) {
+	for _, tc := range []struct {
+		scenario      string
+		startError    error
+		expectError   bool
+		firstStartSet bool
+	}{
+		{
+			scenario:      "successful launch",
+			startError:    nil,
+			expectError:   false,
+			firstStartSet: true,
+		},
+		{
+			scenario:      "failed launch",
+			startError:    errors.New("start error"),
+			expectError:   true,
+			firstStartSet: false,
+		},
+		{
+			scenario:      "process already started",
+			startError:    nil,
+			expectError:   false,
+			firstStartSet: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				StartMock: func(logger *zap.Logger) error {
+					return tc.startError
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 5).(*processSupervisor)
+			if tc.firstStartSet {
+				ps.firstStart.Store(true)
+			}
+
+			err := ps.Launch()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.firstStartSet && !ps.firstStart.Load() {
+				t.Error("expected firstStart to be set but it was not")
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_Shutdown(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		stopError   error
+		expectError bool
+	}{
+		{
+			scenario:    "successful shutdown",
+			stopError:   nil,
+			expectError: false,
+		},
+		{
+			scenario:    "failed shutdown",
+			stopError:   errors.New("stop error"),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				StopMock: func(logger *zap.Logger) error {
+					return tc.stopError
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 5)
+			err := ps.Shutdown()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_restart(t *testing.T) {
+	for _, tc := range []struct {
+		scenario            string
+		initiallyRestarting bool
+		startError          error
+		stopError           error
+		expectError         bool
+		expectedError       error
+	}{
+		{
+			scenario:            "already restarting",
+			initiallyRestarting: true,
+			expectError:         true,
+			expectedError:       ErrProcessAlreadyRestarting,
+		},
+		{
+			scenario:    "successful restart",
+			startError:  nil,
+			stopError:   nil,
+			expectError: false,
+		},
+		{
+			scenario:    "failed to stop during restart",
+			startError:  nil,
+			stopError:   errors.New("stop error"),
+			expectError: false,
+		},
+		{
+			scenario:    "failed to start during restart",
+			startError:  errors.New("start error"),
+			stopError:   nil,
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				StartMock: func(logger *zap.Logger) error {
+					return tc.startError
+				},
+				StopMock: func(logger *zap.Logger) error {
+					return tc.stopError
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 5).(*processSupervisor)
+			if tc.initiallyRestarting {
+				ps.isRestarting.Store(true)
+			}
+
+			err := ps.restart()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_Healthy(t *testing.T) {
+	for _, tc := range []struct {
+		scenario            string
+		initiallyStarted    bool
+		initiallyRestarting bool
+		processHealthy      bool
+		expectHealthy       bool
+	}{
+		{
+			scenario:         "non-started process is always healthy",
+			initiallyStarted: false,
+			expectHealthy:    true,
+		},
+		{
+			scenario:            "restarting process is always healthy",
+			initiallyStarted:    true,
+			initiallyRestarting: true,
+			expectHealthy:       true,
+		},
+		{
+			scenario:         "process reports as healthy",
+			initiallyStarted: true,
+			processHealthy:   true,
+			expectHealthy:    true,
+		},
+		{
+			scenario:         "process reports as unhealthy",
+			initiallyStarted: true,
+			processHealthy:   false,
+			expectHealthy:    false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				HealthyMock: func(logger *zap.Logger) bool {
+					return tc.processHealthy
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 5).(*processSupervisor)
+			if tc.initiallyStarted {
+				ps.firstStart.Store(true)
+			}
+			if tc.initiallyRestarting {
+				ps.isRestarting.Store(true)
+			}
+
+			healthy := ps.Healthy()
+
+			if healthy != tc.expectHealthy {
+				t.Fatalf("expected healthy to be %v but got %v", tc.expectHealthy, healthy)
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_Run(t *testing.T) {
+	for _, tc := range []struct {
+		scenario             string
+		initiallyStarted     bool
+		isRestarting         bool
+		startError           error
+		processHealthy       bool
+		maxReqLimit          int64
+		tasksToRun           int
+		taskError            error
+		expectError          bool
+		skipCallsCheck       bool
+		expectedStartCalls   int64
+		expectedHealthyCalls int64
+		expectedStopCalls    int64
+	}{
+		{
+			scenario:             "successfully run task on non-started process",
+			initiallyStarted:     false,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          false,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    0,
+		},
+		{
+			scenario:             "cannot launch non-started process",
+			initiallyStarted:     false,
+			isRestarting:         false,
+			startError:           errors.New("launch error"),
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          true,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 0,
+			expectedStopCalls:    0,
+		},
+		{
+			scenario:             "run task with unhealthy process causing restart",
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       false,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          false,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    1,
+		},
+		{
+			scenario:             "cannot restart unhealthy process",
+			startError:           errors.New("start error"),
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       false,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          true,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    1,
+		},
+		{
+			scenario:         "ErrProcessAlreadyRestarting",
+			initiallyStarted: true,
+			isRestarting:     true,
+			processHealthy:   false,
+			maxReqLimit:      1,
+			tasksToRun:       1,
+			expectError:      true,
+			skipCallsCheck:   true,
+		},
+		{
+			scenario:             "run tasks reaching max request limit causing restart",
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           3,
+			expectError:          false,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 3,
+			expectedStopCalls:    1,
+		},
+		{
+			scenario:             "cannot restart after reaching max request limit",
+			startError:           errors.New("start error"),
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           2,
+			expectError:          true,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 2,
+			expectedStopCalls:    1,
+		},
+		{
+			scenario:             "task error",
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          0,
+			tasksToRun:           1,
+			taskError:            errors.New("task error"),
+			expectError:          true,
+			expectedStartCalls:   0,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    0,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			var startCalls, healthyCalls, stopCalls atomic.Int64
+			startCalls.Store(0)
+			healthyCalls.Store(0)
+			stopCalls.Store(0)
+
+			process := &ProcessMock{
+				StartMock: func(logger *zap.Logger) error {
+					startCalls.Add(1)
+					return tc.startError
+				},
+				StopMock: func(logger *zap.Logger) error {
+					stopCalls.Add(1)
+					return nil
+				},
+				HealthyMock: func(logger *zap.Logger) bool {
+					healthyCalls.Add(1)
+					return tc.processHealthy
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, tc.maxReqLimit).(*processSupervisor)
+			if tc.initiallyStarted {
+				ps.firstStart.Store(true)
+			}
+			if tc.isRestarting {
+				ps.isRestarting.Store(true)
+			}
+
+			task := func() error {
+				return tc.taskError
+			}
+
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+			defer cancel()
+
+			var wg sync.WaitGroup
+			errorChan := make(chan error, tc.tasksToRun)
+
+			for i := 0; i < tc.tasksToRun; i++ {
+				wg.Add(1)
+				go func() {
+					defer wg.Done()
+					err := ps.Run(ctx, logger, task)
+					if err != nil {
+						errorChan <- err
+					}
+				}()
+			}
+
+			wg.Wait()
+			close(errorChan)
+
+			for err := range errorChan {
+				if tc.expectError && err == nil {
+					t.Fatal("expected an error but got none")
+				}
+
+				if !tc.expectError && err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			}
+
+			if tc.skipCallsCheck {
+				return
+			}
+
+			if startCalls.Load() != tc.expectedStartCalls {
+				t.Errorf("expected %d process.Start calls, got %d", tc.expectedStartCalls, startCalls.Load())
+			}
+
+			if healthyCalls.Load() != tc.expectedHealthyCalls {
+				t.Errorf("expected %d process.Healthy calls, got %d", tc.expectedHealthyCalls, healthyCalls.Load())
+			}
+
+			if stopCalls.Load() != tc.expectedStopCalls {
+				t.Errorf("expected %d process.Stop calls, got %d", tc.expectedStopCalls, stopCalls.Load())
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_runWithDeadline(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctxDone     bool
+		expectError bool
+	}{
+		{
+			scenario:    "task finished",
+			ctxDone:     false,
+			expectError: false,
+		},
+		{
+			scenario:    "context expired",
+			ctxDone:     true,
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			ps := NewProcessSupervisor(zap.NewNop(), new(ProcessMock), 0).(*processSupervisor)
+
+			ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+			defer cancel()
+
+			if tc.ctxDone {
+				cancel()
+			}
+
+			err := ps.runWithDeadline(ctx, func() error {
+				return nil
+			})
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected an error but got none")
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_ReqQueueSize(t *testing.T) {
+	logger := zap.NewNop()
+	process := &ProcessMock{
+		StartMock: func(logger *zap.Logger) error {
+			return nil
+		},
+		HealthyMock: func(logger *zap.Logger) bool {
+			return true
+		},
+	}
+	ps := NewProcessSupervisor(logger, process, 0).(*processSupervisor)
+
+	// Simulating a lock.
+	ps.mutexChan <- struct{}{}
+
+	if ps.ReqQueueSize() != 0 {
+		t.Fatalf("expected queue size to be 0 but got %d", ps.ReqQueueSize())
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	var wg sync.WaitGroup
+	errorChan := make(chan error, 10)
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			err := ps.Run(ctx, logger, func() error {
+				return nil
+			})
+			if err != nil {
+				errorChan <- err
+			}
+		}()
+	}
+
+	// We have to wait a little bit so that the request queue size may change.
+	time.Sleep(10 * time.Millisecond)
+
+	if ps.ReqQueueSize() != 10 {
+		t.Fatalf("expected queue size to be 10 but got %d", ps.ReqQueueSize())
+	}
+
+	wg.Wait()
+	close(errorChan)
+
+	for err := range errorChan {
+		if err == nil {
+			t.Error("expected a lock error but got none")
+		}
+	}
+
+	if ps.ReqQueueSize() != 0 {
+		t.Errorf("expected queue size to be 0 but got %d", ps.ReqQueueSize())
+	}
+}
+
+func TestProcessSupervisor_RestartsCount(t *testing.T) {
+	for _, tc := range []struct {
+		scenario              string
+		initialRestartsCount  int64
+		restartAttempts       int
+		startError            error
+		stopError             error
+		expectedRestartsCount int64
+	}{
+		{
+			scenario:              "no restarts, counter remains 0",
+			initialRestartsCount:  0,
+			restartAttempts:       0,
+			expectedRestartsCount: 0,
+		},
+		{
+			scenario:              "successful restart increases counter",
+			initialRestartsCount:  0,
+			restartAttempts:       1,
+			startError:            nil,
+			stopError:             nil,
+			expectedRestartsCount: 1,
+		},
+		{
+			scenario:              "failed to stop during restart, no impact",
+			initialRestartsCount:  0,
+			restartAttempts:       1,
+			startError:            nil,
+			stopError:             errors.New("stop error"),
+			expectedRestartsCount: 1,
+		},
+		{
+			scenario:              "multiple successful restarts",
+			initialRestartsCount:  0,
+			restartAttempts:       3,
+			startError:            nil,
+			stopError:             nil,
+			expectedRestartsCount: 3,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				StartMock: func(logger *zap.Logger) error {
+					return tc.startError
+				},
+				StopMock: func(logger *zap.Logger) error {
+					return tc.stopError
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 0).(*processSupervisor)
+			ps.restartsCounter.Store(tc.initialRestartsCount)
+
+			for i := 0; i < tc.restartAttempts; i++ {
+				_ = ps.restart()
+			}
+
+			actualRestartsCount := ps.RestartsCount()
+			if actualRestartsCount != tc.expectedRestartsCount {
+				t.Fatalf("expected restarts count to be %d, but got  %d", tc.expectedRestartsCount, actualRestartsCount)
+			}
+		})
+	}
+}
--- a/pkg/modules/api/api.go
+++ b/pkg/modules/api/api.go
@@ -6,76 +6,90 @@ import (
 	"fmt"
 	"net/http"
 	"os"
-	"regexp"
 	"sort"
 	"strconv"
 	"strings"
 	"time"

 	"github.com/alexliesenfeld/health"
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/gc"
 	"github.com/labstack/echo/v4"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/multierr"
 	"go.uber.org/zap"
+	"golang.org/x/net/http2"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

 func init() {
-	gotenberg.MustRegisterModule(API{})
+	gotenberg.MustRegisterModule(new(Api))
 }

-// API is a module which provides an HTTP server. Other modules may add
-// "multipart/form-data" routes, middlewares or health checks.
-type API struct {
+// Api is a module which provides an HTTP server. Other modules may add routes,
+// middlewares or health checks.
+type Api struct {
 	port                      int
-	readTimeout               time.Duration
-	processTimeout            time.Duration
-	writeTimeout              time.Duration
+	startTimeout              time.Duration
+	timeout                   time.Duration
 	rootPath                  string
 	traceHeader               string
 	disableHealthCheckLogging bool
-	webhookAllowList          *regexp.Regexp
-	webhookDenyList           *regexp.Regexp
-	webhookErrorAllowList     *regexp.Regexp
-	webhookErrorDenyList      *regexp.Regexp
-	webhookMaxRetry           int
-	webhookRetryMinWait       time.Duration
-	webhookRetryMaxWait       time.Duration
-	disableWebhook            bool

-	multipartFormDataRoutes []MultipartFormDataRoute
-	externalMiddlewares     []Middleware
-	healthChecks            []health.CheckerOption
-	logger                  *zap.Logger
-	srv                     *echo.Echo
+	routes              []Route
+	externalMiddlewares []Middleware
+	healthChecks        []health.CheckerOption
+	readyFn             []func() error
+	fs                  *gotenberg.FileSystem
+	logger              *zap.Logger
+	srv                 *echo.Echo
 }

-// MultipartFormDataRouter is a module interface which adds
-// "multipart/form-data" routes to the API.
-type MultipartFormDataRouter interface {
-	Routes() ([]MultipartFormDataRoute, error)
+// Router is a module interface which adds routes to the [Api].
+type Router interface {
+	Routes() ([]Route, error)
 }

-// MultipartFormDataRoute represents a "multipart/form-data" route. All routes
-// uses the HTTP POST method.
-type MultipartFormDataRoute struct {
+// Route represents a route from a [Router].
+type Route struct {
+	// Method is the HTTP method of the route (i.e., GET, POST, etc.).
+	// Required.
+	Method string
+
 	// Path is the sub path of the route. Must start with a slash.
 	// Required.
 	Path string

+	// IsMultipart tells if the route is "multipart/form-data".
+	// Optional.
+	IsMultipart bool
+
+	// DisableLogging disables the logging for this route.
+	// Optional.
+	DisableLogging bool
+
 	// Handler is the function which handles the request.
 	// Required.
-	Handler func(ctx *Context) error
+	Handler echo.HandlerFunc
 }

-// MiddlewareProvider is a module interface which adds middlewares to the API.
+// MiddlewareProvider is a module interface which adds middlewares to the [Api].
 type MiddlewareProvider interface {
 	Middlewares() ([]Middleware, error)
 }

+// MiddlewareStack is a type which helps to determine in which stack the
+// middlewares provided by the [MiddlewareProvider] modules should be located.
+type MiddlewareStack uint32
+
+const (
+	DefaultStack MiddlewareStack = iota
+	PreRouterStack
+	MultipartStack
+)
+
 // MiddlewarePriority is a type which helps to determine the execution order of
-// middlewares provided by the MiddlewareProvider modules.
+// middlewares provided by the [MiddlewareProvider] modules in a stack.
 type MiddlewarePriority uint32

 const (
@@ -86,40 +100,40 @@ const (
 	VeryHighPriority
 )

-// Middleware is a middleware which can be added to the API's middlewares
+// Middleware is a middleware which can be added to the [Api]'s middlewares
 // chain.
 //
-//  middleware := &Middleware{
-//    Handler: func() echo.MiddlewareFunc {
-//      return func(next echo.HandlerFunc) echo.HandlerFunc {
-//        return func(c echo.Context) error {
-//          rootPath := c.Get("rootPath").(string)
-//          healthURI := fmt.Sprintf("%shealth", rootPath)
+//	middleware := Middleware{
+//	  Handler: func() echo.MiddlewareFunc {
+//	    return func(next echo.HandlerFunc) echo.HandlerFunc {
+//	      return func(c echo.Context) error {
+//	        rootPath := c.Get("rootPath").(string)
+//	        healthURI := fmt.Sprintf("%shealth", rootPath)
 //
-//          // Skip the middleware if health check URI.
-//          if c.Request().RequestURI == healthURI {
-//            // Call the next middleware in the chain.
-//            return next(c)
-//          }
+//	        // Skip the middleware if health check URI.
+//	        if c.Request().RequestURI == healthURI {
+//	          // Call the next middleware in the chain.
+//	          return next(c)
+//	        }
 //
-//          // Your middleware process.
-//          // ...
+//	        // Your middleware process.
+//	        // ...
 //
-//          // Call the next middleware in the chain.
-//          return next(c)
-//        }
-//      }
-//    }(),
-//  }
+//	        // Call the next middleware in the chain.
+//	        return next(c)
+//	      }
+//	    }
+//	  }(),
+//	}
 type Middleware struct {
-	// RunBeforeRouter tells if the middleware should run before the router
-	// process an HTTP request.
+	// Stack tells in which stack the middleware should be located.
+	// Default to [DefaultStack].
 	// Optional.
-	RunBeforeRouter bool
+	Stack MiddlewareStack

 	// Priority tells if the middleware should be positioned high or not in
-	// the middlewares chain.
-	// Default to VeryLowPriority.
+	// its stack.
+	// Default to [VeryLowPriority].
 	// Optional.
 	Priority MiddlewarePriority

@@ -134,55 +148,38 @@ type Middleware struct {
 // See https://github.com/alexliesenfeld/health for more details.
 type HealthChecker interface {
 	Checks() ([]health.CheckerOption, error)
+	Ready() error
 }

-// Descriptor returns an API's module descriptor.
-func (API) Descriptor() gotenberg.ModuleDescriptor {
+// Descriptor returns an [Api]'s module descriptor.
+func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID: "api",
 		FlagSet: func() *flag.FlagSet {
 			fs := flag.NewFlagSet("api", flag.ExitOnError)
 			fs.Int("api-port", 3000, "Set the port on which the API should listen")
 			fs.String("api-port-from-env", "", "Set the environment variable with the port on which the API should listen - override the default port")
-			fs.Duration("api-read-timeout", time.Duration(30)*time.Second, "Set the maximum duration allowed to read a complete request, including the body")
-			fs.Duration("api-process-timeout", time.Duration(30)*time.Second, "Set the maximum duration allowed to process a request")
-			fs.Duration("api-write-timeout", time.Duration(30)*time.Second, "Set the maximum duration before timing out writes of the response")
+			fs.Duration("api-start-timeout", time.Duration(30)*time.Second, "Set the time limit for the API to start")
+			fs.Duration("api-timeout", time.Duration(30)*time.Second, "Set the time limit for requests")
 			fs.String("api-root-path", "/", "Set the root path of the API - for service discovery via URL paths")
 			fs.String("api-trace-header", "Gotenberg-Trace", "Set the header name to use for identifying requests")
 			fs.Bool("api-disable-health-check-logging", false, "Disable health check logging")
-			fs.String("api-webhook-allow-list", "", "Set the allowed URLs for the webhook feature using a regular expression")
-			fs.String("api-webhook-deny-list", "", "Set the denied URLs for the webhook feature using a regular expression")
-			fs.String("api-webhook-error-allow-list", "", "Set the allowed URLs in case of an error for the webhook feature using a regular expression")
-			fs.String("api-webhook-error-deny-list", "", "Set the denied URLs in case of an error for the webhook feature using a regular expression")
-			fs.Int("api-webhook-max-retry", 4, "Set the maximum number of retries for the webhook feature")
-			fs.Duration("api-webhook-retry-min-wait", time.Duration(1)*time.Second, "Set the minimum duration to wait before trying to call the webhook again")
-			fs.Duration("api-webhook-retry-max-wait", time.Duration(30)*time.Second, "Set the maximum duration to wait before trying to call the webhook again")
-			fs.Bool("api-disable-webhook", false, "Disable the webhook feature")

 			return fs
 		}(),
-		New: func() gotenberg.Module { return new(API) },
+		New: func() gotenberg.Module { return new(Api) },
 	}
 }

 // Provision sets the module properties.
-func (a *API) Provision(ctx *gotenberg.Context) error {
+func (a *Api) Provision(ctx *gotenberg.Context) error {
 	flags := ctx.ParsedFlags()
 	a.port = flags.MustInt("api-port")
-	a.readTimeout = flags.MustDuration("api-read-timeout")
-	a.processTimeout = flags.MustDuration("api-process-timeout")
-	a.writeTimeout = flags.MustDuration("api-write-timeout")
+	a.startTimeout = flags.MustDuration("api-start-timeout")
+	a.timeout = flags.MustDuration("api-timeout")
 	a.rootPath = flags.MustString("api-root-path")
 	a.traceHeader = flags.MustString("api-trace-header")
 	a.disableHealthCheckLogging = flags.MustBool("api-disable-health-check-logging")
-	a.webhookAllowList = flags.MustRegexp("api-webhook-allow-list")
-	a.webhookDenyList = flags.MustRegexp("api-webhook-deny-list")
-	a.webhookErrorAllowList = flags.MustRegexp("api-webhook-error-allow-list")
-	a.webhookErrorDenyList = flags.MustRegexp("api-webhook-error-deny-list")
-	a.webhookMaxRetry = flags.MustInt("api-webhook-max-retry")
-	a.webhookRetryMinWait = flags.MustDuration("api-webhook-retry-min-wait")
-	a.webhookRetryMaxWait = flags.MustDuration("api-webhook-retry-max-wait")
-	a.disableWebhook = flags.MustBool("api-disable-webhook")

 	// Port from env?
 	portEnvVar := flags.MustString("api-port-from-env")
@@ -206,14 +203,14 @@ func (a *API) Provision(ctx *gotenberg.Context) error {
 	}

 	// Get routes from modules.
-	mods, err := ctx.Modules(new(MultipartFormDataRouter))
+	mods, err := ctx.Modules(new(Router))
 	if err != nil {
-		return fmt.Errorf("get multipart/form-data routers: %w", err)
+		return fmt.Errorf("get routers: %w", err)
 	}

-	routers := make([]MultipartFormDataRouter, len(mods))
+	routers := make([]Router, len(mods))
 	for i, router := range mods {
-		routers[i] = router.(MultipartFormDataRouter)
+		routers[i] = router.(Router)
 	}

 	for _, router := range routers {
@@ -222,7 +219,7 @@ func (a *API) Provision(ctx *gotenberg.Context) error {
 			return fmt.Errorf("get routes: %w", err)
 		}

-		a.multipartFormDataRoutes = append(a.multipartFormDataRoutes, routes...)
+		a.routes = append(a.routes, routes...)
 	}

 	// Get middlewares from modules.
@@ -268,8 +265,10 @@ func (a *API) Provision(ctx *gotenberg.Context) error {
 		}

 		a.healthChecks = append(a.healthChecks, checks...)
+		a.readyFn = append(a.readyFn, healthChecker.Ready)
 	}

+	// Logger.
 	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
 	if err != nil {
 		return fmt.Errorf("get logger provider: %w", err)
@@ -282,11 +281,14 @@ func (a *API) Provision(ctx *gotenberg.Context) error {

 	a.logger = logger

+	// File system.
+	a.fs = gotenberg.NewFileSystem()
+
 	return nil
 }

 // Validate validates the module properties.
-func (a API) Validate() error {
+func (a *Api) Validate() error {
 	var err error

 	if a.port < 1 || a.port > 65535 {
@@ -317,26 +319,35 @@ func (a API) Validate() error {
 		return err
 	}

-	routesMap := make(map[string]MultipartFormDataRoute, len(a.multipartFormDataRoutes))
+	routesMap := make(map[string]string, len(a.routes)+1)
+	routesMap["/health"] = "/health"

-	for _, route := range a.multipartFormDataRoutes {
+	for _, route := range a.routes {
 		if route.Path == "" {
 			return errors.New("route with empty path cannot be registered")
 		}

 		if !strings.HasPrefix(route.Path, "/") {
-			return fmt.Errorf("route %s does not start with /", route.Path)
+			return fmt.Errorf("route '%s' does not start with /", route.Path)
+		}
+
+		if route.IsMultipart && !strings.HasPrefix(route.Path, "/forms") {
+			return fmt.Errorf("multipart/form-data route '%s' does not start with /forms", route.Path)
+		}
+
+		if route.Method == "" {
+			return fmt.Errorf("route '%s' has an empty method", route.Path)
 		}

 		if route.Handler == nil {
-			return fmt.Errorf("route %s has a nil handler", route.Path)
+			return fmt.Errorf("route '%s' has a nil handler", route.Path)
 		}

 		if _, ok := routesMap[route.Path]; ok {
-			return fmt.Errorf("route %s is already registered", route.Path)
+			return fmt.Errorf("route '%s' is already registered", route.Path)
 		}

-		routesMap[route.Path] = route
+		routesMap[route.Path] = route.Path
 	}

 	for _, middleware := range a.externalMiddlewares {
@@ -349,106 +360,106 @@ func (a API) Validate() error {
 }

 // Start starts the HTTP server.
-func (a *API) Start() error {
+func (a *Api) Start() error {
 	a.srv = echo.New()
 	a.srv.HideBanner = true
 	a.srv.HidePort = true
-	a.srv.Server.ReadTimeout = a.readTimeout
-	a.srv.Server.WriteTimeout = a.writeTimeout
-	a.srv.HTTPErrorHandler = httpErrorHandler(a.traceHeader)
+	a.srv.Server.ReadTimeout = a.timeout
+	a.srv.Server.IdleTimeout = a.timeout
+	// See https://github.com/gotenberg/gotenberg/issues/396.
+	a.srv.Server.WriteTimeout = a.timeout + a.timeout
+	a.srv.HTTPErrorHandler = httpErrorHandler()

+	// Let's prepare the modules' routes.
+	var disableLoggingForPaths []string
+	for i, route := range a.routes {
+		a.routes[i].Path = strings.TrimPrefix(route.Path, "/")
+
+		if route.DisableLogging {
+			disableLoggingForPaths = append(disableLoggingForPaths, strings.TrimPrefix(route.Path, "/"))
+		}
+	}
+
+	// Check if the user wish to add logging entries related to the health
+	// check route.
+	if a.disableHealthCheckLogging {
+		disableLoggingForPaths = append(disableLoggingForPaths, "health")
+	}
+
+	// Add the API middlewares.
 	a.srv.Pre(
 		latencyMiddleware(),
 		rootPathMiddleware(a.rootPath),
 		traceMiddleware(a.traceHeader),
-		loggerMiddleware(a.logger, a.disableHealthCheckLogging),
+		loggerMiddleware(a.logger, disableLoggingForPaths),
 	)

+	// Add the modules' middlewares in their respective stacks.
+	var externalMultipartMiddlewares []Middleware
 	for _, externalMiddleware := range a.externalMiddlewares {
-		if externalMiddleware.RunBeforeRouter {
+		switch externalMiddleware.Stack {
+		case PreRouterStack:
 			a.srv.Pre(externalMiddleware.Handler)
-
-			continue
+		case MultipartStack:
+			externalMultipartMiddlewares = append(externalMultipartMiddlewares, externalMiddleware)
+		default:
+			a.srv.Use(externalMiddleware.Handler)
 		}
-
-		a.srv.Use(externalMiddleware.Handler)
 	}

-	hardTimeout := a.processTimeout + (time.Duration(5) * time.Second)
+	hardTimeout := a.timeout + (time.Duration(5) * time.Second)

-	a.srv.GET(
-		fmt.Sprintf("%shealth", a.rootPath),
-		func() echo.HandlerFunc {
-			checks := append(a.healthChecks, health.WithTimeout(a.processTimeout))
-			checker := health.NewChecker(checks...)
+	// Add the modules' routes and their specific middlewares.
+	for _, route := range a.routes {
+		var middlewares []echo.MiddlewareFunc

-			return func(echoCtx echo.Context) error {
-				health.NewHandler(checker).ServeHTTP(echoCtx.Response().Writer, echoCtx.Request())
+		if route.IsMultipart {
+			middlewares = append(middlewares, contextMiddleware(a.fs, a.timeout))

-				return nil
+			for _, externalMultipartMiddleware := range externalMultipartMiddlewares {
+				middlewares = append(middlewares, externalMultipartMiddleware.Handler)
 			}
-		}(),
-		timeoutMiddleware(hardTimeout),
-	)
+		}

-	formsGroup := a.srv.Group(
-		fmt.Sprintf("%sforms", a.rootPath),
-		contextMiddleware(
-			contextMiddlewareConfig{
-				traceHeader: a.traceHeader,
-				timeout: struct {
-					process time.Duration
-					write   time.Duration
-				}{
-					process: a.processTimeout,
-					write:   a.writeTimeout,
-				},
-				webhook: struct {
-					allowList      *regexp.Regexp
-					denyList       *regexp.Regexp
-					errorAllowList *regexp.Regexp
-					errorDenyList  *regexp.Regexp
-					maxRetry       int
-					retryMinWait   time.Duration
-					retryMaxWait   time.Duration
-					disable        bool
-				}{
-					allowList:      a.webhookAllowList,
-					denyList:       a.webhookDenyList,
-					errorAllowList: a.webhookErrorAllowList,
-					errorDenyList:  a.webhookErrorDenyList,
-					maxRetry:       a.webhookMaxRetry,
-					retryMinWait:   a.webhookRetryMinWait,
-					retryMaxWait:   a.webhookRetryMaxWait,
-					disable:        a.disableWebhook,
-				},
-			},
-		),
-		timeoutMiddleware(hardTimeout),
-	)
+		middlewares = append(middlewares, hardTimeoutMiddleware(hardTimeout))

-	// Add routes from other modules.
-	for _, route := range a.multipartFormDataRoutes {
-		formsGroup.POST(
-			route.Path,
-			func(route MultipartFormDataRoute) echo.HandlerFunc {
-				return func(c echo.Context) error {
-					ctx := c.Get("context").(*Context)
-
-					err := route.Handler(ctx)
-					if err != nil {
-						return fmt.Errorf("handle request: %w", err)
-					}
-
-					return nil
-				}
-			}(route),
+		a.srv.Add(
+			route.Method,
+			fmt.Sprintf("%s%s", a.rootPath, route.Path),
+			route.Handler,
+			middlewares...,
 		)
 	}

-	// As the listen method is blocking, run it in a goroutine.
+	// Let's not forget the health check route.
+	a.srv.GET(
+		fmt.Sprintf("%s%s", a.rootPath, "health"),
+		func() echo.HandlerFunc {
+			checks := append(a.healthChecks, health.WithTimeout(a.timeout))
+			checker := health.NewChecker(checks...)
+			return echo.WrapHandler(health.NewHandler(checker))
+		}(),
+		hardTimeoutMiddleware(hardTimeout),
+	)
+
+	// Wait for all modules to be ready.
+	ctx, cancel := context.WithTimeout(context.Background(), a.startTimeout)
+	defer cancel()
+
+	eg, _ := errgroup.WithContext(ctx)
+	for _, f := range a.readyFn {
+		eg.Go(f)
+	}
+
+	err := eg.Wait()
+	if err != nil {
+		return fmt.Errorf("waiting for modules readiness: %w", err)
+	}
+
+	// As the following code is blocking, run it in a goroutine.
 	go func() {
-		err := a.srv.Start(fmt.Sprintf(":%d", a.port))
+		server := &http2.Server{}
+		err := a.srv.StartH2CServer(fmt.Sprintf(":%d", a.port), server)
 		if !errors.Is(err, http.ErrServerClosed) {
 			a.logger.Fatal(err.Error())
 		}
@@ -458,37 +469,19 @@ func (a *API) Start() error {
 }

 // StartupMessage returns a custom startup message.
-func (a API) StartupMessage() string {
+func (a *Api) StartupMessage() string {
 	return fmt.Sprintf("server listening on port %d", a.port)
 }

 // Stop stops the HTTP server.
-func (a API) Stop(ctx context.Context) error {
+func (a *Api) Stop(ctx context.Context) error {
 	return a.srv.Shutdown(ctx)
 }

-// GraceDuration updates the expiration time of files and directories parsed by
-// the gc.GarbageCollector.
-func (a API) GraceDuration() time.Duration {
-	duration := a.readTimeout + a.processTimeout + a.writeTimeout
-
-	if a.disableWebhook {
-		return duration
-	}
-
-	for i := 0; i < a.webhookMaxRetry; i++ {
-		// Yep... Golang does not allow int * time.Duration.
-		duration += a.webhookRetryMaxWait
-	}
-
-	return duration
-}
-
 // Interface guards.
 var (
-	_ gotenberg.Module                         = (*API)(nil)
-	_ gotenberg.Provisioner                    = (*API)(nil)
-	_ gotenberg.Validator                      = (*API)(nil)
-	_ gotenberg.App                            = (*API)(nil)
-	_ gc.GarbageCollectorGraceDurationModifier = (*API)(nil)
+	_ gotenberg.Module      = (*Api)(nil)
+	_ gotenberg.Provisioner = (*Api)(nil)
+	_ gotenberg.Validator   = (*Api)(nil)
+	_ gotenberg.App         = (*Api)(nil)
 )
--- a/pkg/modules/api/api_test.go
+++ b/pkg/modules/api/api_test.go
--- a/pkg/modules/api/context.go
+++ b/pkg/modules/api/context.go
@@ -12,16 +12,14 @@ import (
 	"path/filepath"
 	"strings"
 	"time"
-	"unicode"

 	"github.com/google/uuid"
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/labstack/echo/v4"
 	"github.com/mholt/archiver/v3"
 	"go.uber.org/zap"
-	"golang.org/x/text/runes"
-	"golang.org/x/text/transform"
 	"golang.org/x/text/unicode/norm"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

 var (
@@ -48,8 +46,8 @@ type Context struct {
 	context.Context
 }

-// newContext returns a Context by parsing a "multipart/form-data" request.
-func newContext(echoCtx echo.Context, logger *zap.Logger, timeout time.Duration) (*Context, context.CancelFunc, error) {
+// newContext returns a [Context] by parsing a "multipart/form-data" request.
+func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSystem, timeout time.Duration) (*Context, context.CancelFunc, error) {
 	processCtx, processCancel := context.WithTimeout(context.Background(), timeout)

 	ctx := &Context{
@@ -81,7 +79,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, timeout time.Duration)
 				return
 			}

-			ctx.logger.Debug(fmt.Sprintf("'%s' removed", ctx.dirPath))
+			ctx.logger.Debug(fmt.Sprintf("'%s' context's working directory removed", ctx.dirPath))
 			ctx.cancelled = true
 		}
 	}()
@@ -92,28 +90,28 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, timeout time.Duration)
 		if errors.Is(err, http.ErrNotMultipart) {
 			return nil, cancel, WrapError(
 				fmt.Errorf("get multipart form: %w", err),
-				NewSentinelHTTPError(http.StatusUnsupportedMediaType, "Invalid 'Content-Type' header value: want 'multipart/form-data'"),
+				NewSentinelHttpError(http.StatusUnsupportedMediaType, "Invalid 'Content-Type' header value: want 'multipart/form-data'"),
 			)
 		}

 		if errors.Is(err, http.ErrMissingBoundary) {
 			return nil, cancel, WrapError(
 				fmt.Errorf("get multipart form: %w", err),
-				NewSentinelHTTPError(http.StatusUnsupportedMediaType, "Invalid 'Content-Type' header value: no boundary"),
+				NewSentinelHttpError(http.StatusUnsupportedMediaType, "Invalid 'Content-Type' header value: no boundary"),
 			)
 		}

 		if strings.Contains(err.Error(), io.EOF.Error()) {
 			return nil, cancel, WrapError(
 				fmt.Errorf("get multipart form: %w", err),
-				NewSentinelHTTPError(http.StatusBadRequest, "Malformed body: it does not match the 'Content-Type' header boundaries"),
+				NewSentinelHttpError(http.StatusBadRequest, "Malformed body: it does not match the 'Content-Type' header boundaries"),
 			)
 		}

 		return nil, cancel, fmt.Errorf("get multipart form: %w", err)
 	}

-	dirPath, err := gotenberg.MkdirAll()
+	dirPath, err := fs.MkdirAll()
 	if err != nil {
 		return nil, cancel, fmt.Errorf("create working directory: %w", err)
 	}
@@ -123,16 +121,6 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, timeout time.Duration)
 	ctx.files = make(map[string]string)

 	copyToDisk := func(fh *multipart.FileHeader) error {
-		// Avoid directory traversal and normalize filename.
-		// See https://github.com/gotenberg/gotenberg/issues/104.
-		// See https://github.com/gotenberg/gotenberg/issues/228.
-		t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
-
-		filename, _, err := transform.String(t, strings.ToLower(filepath.Base(fh.Filename)))
-		if err != nil {
-			return fmt.Errorf("transform filename: %w", err)
-		}
-
 		in, err := fh.Open()
 		if err != nil {
 			return fmt.Errorf("open multipart file: %w", err)
@@ -145,6 +133,10 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, timeout time.Duration)
 			}
 		}()

+		// Avoid directory traversal and make sure filename characters are
+		// normalized.
+		// See: https://github.com/gotenberg/gotenberg/issues/662.
+		filename := norm.NFC.String(filepath.Base(fh.Filename))
 		path := fmt.Sprintf("%s/%s", ctx.dirPath, filename)

 		out, err := os.Create(path)
@@ -179,19 +171,19 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, timeout time.Duration)
 		}
 	}

-	ctx.Log().Debug(fmt.Sprintf("form data values: %+v", ctx.values))
-	ctx.Log().Debug(fmt.Sprintf("form data files: %+v", ctx.files))
+	ctx.Log().Debug(fmt.Sprintf("form fields: %+v", ctx.values))
+	ctx.Log().Debug(fmt.Sprintf("form files: %+v", ctx.files))

 	return ctx, cancel, err
 }

-// Request returns the http.Request.
-func (ctx Context) Request() *http.Request {
+// Request returns the [http.Request].
+func (ctx *Context) Request() *http.Request {
 	return ctx.echoCtx.Request()
 }

-// FormData return a FormData.
-func (ctx Context) FormData() *FormData {
+// FormData return a [FormData].
+func (ctx *Context) FormData() *FormData {
 	return &FormData{
 		values: ctx.values,
 		files:  ctx.files,
@@ -201,7 +193,7 @@ func (ctx Context) FormData() *FormData {

 // GeneratePath generates a path within the context's working directory. It
 // does not create a file.
-func (ctx Context) GeneratePath(extension string) string {
+func (ctx *Context) GeneratePath(extension string) string {
 	return fmt.Sprintf("%s/%s%s", ctx.dirPath, uuid.New(), extension)
 }

@@ -223,14 +215,14 @@ func (ctx *Context) AddOutputPaths(paths ...string) error {
 	return nil
 }

-// Log returns the context zap.Logger.
-func (ctx Context) Log() *zap.Logger {
+// Log returns the context [zap.Logger].
+func (ctx *Context) Log() *zap.Logger {
 	return ctx.logger
 }

-// buildOutputFile builds the output file according to the output paths
+// BuildOutputFile builds the output file according to the output paths
 // registered in the context. If many output paths, an archive is created.
-func (ctx Context) buildOutputFile() (string, error) {
+func (ctx *Context) BuildOutputFile() (string, error) {
 	if ctx.cancelled {
 		return "", ErrContextAlreadyClosed
 	}
@@ -266,54 +258,14 @@ func (ctx Context) buildOutputFile() (string, error) {
 	return archivePath, nil
 }

-// MockContext is a helper for tests.
-//
-//  ctx := &api.MockContext{Context: &api.Context{}}
-type MockContext struct {
-	*Context
-}
+// OutputFilename returns the filename based on the given output path or the
+// "Gotenberg-Output-Filename" header's value.
+func (ctx *Context) OutputFilename(outputPath string) string {
+	filename := ctx.echoCtx.Request().Header.Get("Gotenberg-Output-Filename")

-// SetDirPath sets the context's working directory path.
-//
-//  ctx := &api.MockContext{Context: &api.Context{}}
-//  ctx.SetDirPath("/foo")
-func (ctx *MockContext) SetDirPath(path string) {
-	ctx.dirPath = path
-}
+	if filename == "" {
+		return filepath.Base(outputPath)
+	}

-// SetValues sets the values.
-//
-//  ctx := &api.MockContext{Context: &api.Context{}}
-//  ctx.SetValues(map[string][]string{
-//    "url": {
-//      "foo",
-//    },
-//  })
-func (ctx *MockContext) SetValues(values map[string][]string) {
-	ctx.values = values
-}
-
-// SetFiles sets the files.
-//
-//  ctx := &api.MockContext{Context: &api.Context{}}
-//  ctx.SetFiles(map[string]string{
-//    "foo": "/foo",
-//  })
-func (ctx *MockContext) SetFiles(files map[string]string) {
-	ctx.files = files
-}
-
-// SetCancelled sets if the context is cancelled or not.
-//
-//  ctx := &api.MockContext{Context: &api.Context{}}
-//  ctx.SetCancelled(true)
-func (ctx *MockContext) SetCancelled(cancelled bool) {
-	ctx.cancelled = cancelled
-}
-
-// OutputPaths returns the registered output paths.
-//  ctx := &api.MockContext{Context: &api.Context{}}
-//  outputPaths := ctx.OutputPaths()
-func (ctx MockContext) OutputPaths() []string {
-	return ctx.outputPaths
+	return fmt.Sprintf("%s%s", filename, filepath.Ext(outputPath))
 }
--- a/pkg/modules/api/context_test.go
+++ b/pkg/modules/api/context_test.go
@@ -12,144 +12,141 @@ import (
 	"testing"
 	"time"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

 func TestNewContext(t *testing.T) {
-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario         string
 		request          *http.Request
-		expectErr        bool
-		expectHTTPErr    bool
-		expectHTTPStatus int
+		expectError      bool
+		expectHttpError  bool
+		expectHttpStatus int
 	}{
 		{
+			scenario:         "http.ErrNotMultipart",
 			request:          httptest.NewRequest(http.MethodPost, "/", nil),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusUnsupportedMediaType,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusUnsupportedMediaType,
 		},
 		{
+			scenario: "http.ErrMissingBoundary",
 			request: func() *http.Request {
 				req := httptest.NewRequest(http.MethodPost, "/", nil)
 				req.Header.Set(echo.HeaderContentType, echo.MIMEMultipartForm)
-
 				return req
 			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusUnsupportedMediaType,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusUnsupportedMediaType,
 		},
 		{
+			scenario: "malformed body",
 			request: func() *http.Request {
 				body := &bytes.Buffer{}
-
 				writer := multipart.NewWriter(body)
-
 				defer func() {
 					err := writer.Close()
 					if err != nil {
 						t.Fatalf("expected no error but got: %v", err)
 					}
 				}()
-
 				err := writer.WriteField("foo", "foo")
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
-
 				req := httptest.NewRequest(http.MethodPost, "/", nil)
 				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
-
 				return req
 			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
 		},
 		{
+			scenario: "success",
 			request: func() *http.Request {
 				body := &bytes.Buffer{}
-
 				writer := multipart.NewWriter(body)
-
 				defer func() {
 					err := writer.Close()
 					if err != nil {
 						t.Fatalf("expected no error but got: %v", err)
 					}
 				}()
-
 				err := writer.WriteField("foo", "foo")
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
-
 				part, err := writer.CreateFormFile("foo.txt", "foo.txt")
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
-
 				_, err = part.Write([]byte("foo"))
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
-
 				req := httptest.NewRequest(http.MethodPost, "/", body)
 				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
-
 				return req
 			}(),
+			expectError:     false,
+			expectHttpError: false,
 		},
 	} {
-		handler := func(c echo.Context) error {
-			_, cancel, err := newContext(c, zap.NewNop(), time.Duration(10)*time.Second)
-			defer cancel()
-			// Context already cancelled.
-			defer cancel()
+		t.Run(tc.scenario, func(t *testing.T) {
+			handler := func(c echo.Context) error {
+				_, cancel, err := newContext(c, zap.NewNop(), gotenberg.NewFileSystem(), time.Duration(10)*time.Second)
+				defer cancel()
+				// Context already cancelled.
+				defer cancel()

-			if err != nil {
-				return err
+				if err != nil {
+					return err
+				}
+
+				return nil
 			}

-			return nil
-		}
+			recorder := httptest.NewRecorder()

-		recorder := httptest.NewRecorder()
+			srv := echo.New()
+			srv.HideBanner = true
+			srv.HidePort = true

-		srv := echo.New()
-		srv.HideBanner = true
-		srv.HidePort = true
+			c := srv.NewContext(tc.request, recorder)
+			err := handler(c)

-		c := srv.NewContext(tc.request, recorder)
-		err := handler(c)
-
-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
-
-		var httpErr HTTPError
-		isHTTPErr := errors.As(err, &httpErr)
-
-		if tc.expectHTTPErr && !isHTTPErr {
-			t.Errorf("test %d: expected HTTP error but got: %v", i, err)
-		}
-
-		if !tc.expectHTTPErr && isHTTPErr {
-			t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
-		}
-
-		if err != nil && tc.expectHTTPErr && isHTTPErr {
-			status, _ := httpErr.HTTPError()
-			if status != tc.expectHTTPStatus {
-				t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
 			}
-		}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			var httpErr HttpError
+			isHttpError := errors.As(err, &httpErr)
+
+			if tc.expectHttpError && !isHttpError {
+				t.Errorf("expected an HTTP error but got: %v", err)
+			}
+
+			if !tc.expectHttpError && isHttpError {
+				t.Errorf("expected no HTTP error but got one: %v", httpErr)
+			}
+
+			if err != nil && tc.expectHttpError && isHttpError {
+				status, _ := httpErr.HttpError()
+				if status != tc.expectHttpStatus {
+					t.Errorf("expected %d as HTTP status code but got %d", tc.expectHttpStatus, status)
+				}
+			}
+		})
 	}
 }

@@ -158,7 +155,7 @@ func TestContext_Request(t *testing.T) {
 	recorder := httptest.NewRecorder()
 	c := echo.New().NewContext(request, recorder)

-	ctx := Context{
+	ctx := &Context{
 		echoCtx: c,
 	}

@@ -168,7 +165,7 @@ func TestContext_Request(t *testing.T) {
 }

 func TestContext_FormData(t *testing.T) {
-	ctx := Context{
+	ctx := &Context{
 		values: map[string][]string{
 			"foo": {"foo"},
 		},
@@ -189,7 +186,7 @@ func TestContext_FormData(t *testing.T) {
 }

 func TestContext_GeneratePath(t *testing.T) {
-	ctx := Context{
+	ctx := &Context{
 		dirPath: "/foo",
 	}

@@ -201,40 +198,49 @@ func TestContext_GeneratePath(t *testing.T) {
 }

 func TestContext_AddOutputPaths(t *testing.T) {
-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario    string
 		ctx         *Context
 		path        string
 		expectCount int
-		expectErr   bool
+		expectError bool
 	}{
 		{
-			ctx:       &Context{cancelled: true},
-			expectErr: true,
+			scenario:    "ErrContextAlreadyClosed",
+			ctx:         &Context{cancelled: true},
+			expectCount: 0,
+			expectError: true,
 		},
 		{
-			ctx:       &Context{dirPath: "/foo"},
-			path:      "/bar/foo.txt",
-			expectErr: true,
+			scenario:    "ErrOutOfBoundsOutputPath",
+			ctx:         &Context{dirPath: "/foo"},
+			path:        "/bar/foo.txt",
+			expectCount: 0,
+			expectError: true,
 		},
 		{
+			scenario:    "success",
 			ctx:         &Context{dirPath: "/foo"},
 			path:        "/foo/foo.txt",
 			expectCount: 1,
+			expectError: false,
 		},
 	} {
-		err := tc.ctx.AddOutputPaths(tc.path)
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.ctx.AddOutputPaths(tc.path)

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if len(tc.ctx.outputPaths) != tc.expectCount {
-			t.Errorf("test %d: expected %d output paths but got %d", i, tc.expectCount, len(tc.ctx.outputPaths))
-		}
+			if len(tc.ctx.outputPaths) != tc.expectCount {
+				t.Errorf("expected %d output paths but got %d", tc.expectCount, len(tc.ctx.outputPaths))
+			}
+		})
 	}
 }

@@ -248,126 +254,106 @@ func TestContext_Log(t *testing.T) {
 	}
 }

-func TestContext_buildOutputFile(t *testing.T) {
-	for i, tc := range []struct {
-		ctx       *Context
-		expectErr bool
+func TestContext_BuildOutputFile(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *Context
+		expectError bool
 	}{
 		{
-			ctx:       &Context{cancelled: true},
-			expectErr: true,
+			scenario:    "ErrContextAlreadyClosed",
+			ctx:         &Context{cancelled: true},
+			expectError: true,
 		},
 		{
-			ctx:       &Context{},
-			expectErr: true,
+			scenario:    "no output path",
+			ctx:         &Context{},
+			expectError: true,
 		},
 		{
-			ctx: &Context{outputPaths: []string{"foo.txt"}},
+			scenario:    "success: one output path",
+			ctx:         &Context{outputPaths: []string{"foo.txt"}},
+			expectError: false,
 		},
 		{
-			ctx:       &Context{outputPaths: []string{"foo.txt", "foo.pdf"}},
-			expectErr: true,
+			scenario:    "cannot archive: invalid output paths",
+			ctx:         &Context{outputPaths: []string{"foo.txt", "foo.pdf"}},
+			expectError: true,
 		},
 		{
+			scenario: "success: many output paths",
 			ctx: &Context{
 				outputPaths: []string{
 					"/tests/test/testdata/api/sample1.txt",
 					"/tests/test/testdata/api/sample1.txt",
 				},
 			},
+			expectError: false,
 		},
 	} {
-		dirPath, err := gotenberg.MkdirAll()
-		if err != nil {
-			t.Fatalf("%d: expected no erro but got: %v", i, err)
-		}
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := gotenberg.NewFileSystem()
+			dirPath, err := fs.MkdirAll()
+			if err != nil {
+				t.Fatalf("expected no erro but got: %v", err)
+			}

-		tc.ctx.dirPath = dirPath
-		tc.ctx.logger = zap.NewNop()
+			defer func() {
+				err := os.RemoveAll(fs.WorkingDirPath())
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
+				}
+			}()

-		_, err = tc.ctx.buildOutputFile()
+			tc.ctx.dirPath = dirPath
+			tc.ctx.logger = zap.NewNop()

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			_, err = tc.ctx.BuildOutputFile()

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}

-		err = os.RemoveAll(dirPath)
-		if err != nil {
-			t.Fatalf("%d: expected no erro but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
 	}
 }

-func TestMockContext_SetDirPath(t *testing.T) {
-	mock := &MockContext{&Context{}}
-	mock.SetDirPath("/foo")
-
-	actual := mock.dirPath
-	expect := "/foo"
-
-	if actual != expect {
-		t.Errorf("expected '%s' but got '%s'", expect, actual)
-	}
-}
-
-func TestMockContext_SetValues(t *testing.T) {
-	mock := &MockContext{&Context{}}
-	mock.SetValues(map[string][]string{
-		"foo": {"foo"},
-	})
-
-	actual := mock.values
-	expect := map[string][]string{
-		"foo": {"foo"},
-	}
-
-	if !reflect.DeepEqual(actual, expect) {
-		t.Errorf("expected %+v but got: %+v", expect, actual)
-	}
-}
-
-func TestMockContext_SetFiles(t *testing.T) {
-	mock := &MockContext{&Context{}}
-	mock.SetFiles(map[string]string{
-		"foo": "/foo",
-	})
-
-	actual := mock.files
-	expect := map[string]string{
-		"foo": "/foo",
-	}
-
-	if !reflect.DeepEqual(actual, expect) {
-		t.Errorf("expected %+v but got: %+v", expect, actual)
-	}
-}
-
-func TestMockContext_SetCancelled(t *testing.T) {
-	mock := &MockContext{&Context{}}
-	mock.SetCancelled(true)
-
-	actual := mock.cancelled
-
-	if !actual {
-		t.Errorf("expected %t but got %t", true, actual)
-	}
-}
-
-func TestMockContext_OutputPaths(t *testing.T) {
-	mock := MockContext{
-		&Context{
-			outputPaths: []string{"/foo"},
+func TestContext_OutputFilename(t *testing.T) {
+	for _, tc := range []struct {
+		scenario             string
+		ctx                  *Context
+		outputPath           string
+		expectOutputFilename string
+	}{
+		{
+			scenario: "with Gotenberg-Output-Filename header",
+			ctx: func() *Context {
+				c := echo.New().NewContext(httptest.NewRequest(http.MethodGet, "/foo", nil), nil)
+				c.Request().Header.Set("Gotenberg-Output-Filename", "foo")
+				return &Context{echoCtx: c}
+			}(),
+			outputPath:           "/foo/bar.txt",
+			expectOutputFilename: "foo.txt",
 		},
-	}
+		{
+			scenario: "without custom filename",
+			ctx: func() *Context {
+				c := echo.New().NewContext(httptest.NewRequest(http.MethodGet, "/foo", nil), nil)
+				return &Context{echoCtx: c}
+			}(),
+			outputPath:           "/foo/foo.txt",
+			expectOutputFilename: "foo.txt",
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			actual := tc.ctx.OutputFilename(tc.outputPath)

-	actual := mock.OutputPaths()
-	expect := []string{"/foo"}
-
-	if !reflect.DeepEqual(actual, expect) {
-		t.Errorf("expected %+v but got: %+v", expect, actual)
+			if actual != tc.expectOutputFilename {
+				t.Errorf("expected '%s' but got '%s'", tc.expectOutputFilename, actual)
+			}
+		})
 	}
 }
--- a/pkg/modules/api/errors.go
+++ b/pkg/modules/api/errors.go
@@ -2,66 +2,66 @@ package api

 // Credits: https://www.joeshaw.org/error-handling-in-go-http-applications.

-// HTTPError is an interface allowing to retrieve the HTTP details of an error.
-type HTTPError interface {
-	HTTPError() (int, string)
+// HttpError is an interface allowing to retrieve the HTTP details of an error.
+type HttpError interface {
+	HttpError() (int, string)
 }

-// SentinelHTTPError is the HTTP sidekick of an error.
-type SentinelHTTPError struct {
+// SentinelHttpError is the HTTP sidekick of an error.
+type SentinelHttpError struct {
 	status  int
 	message string
 }

-// NewSentinelHTTPError creates a SentinelHTTPError. The message will be sent
-// as the response's body if returned from an handler, so make sure to not leak
+// NewSentinelHttpError creates a [SentinelHttpError]. The message will be sent
+// as the response's body if returned from a handler, so make sure to not leak
 // sensible information.
-func NewSentinelHTTPError(status int, message string) SentinelHTTPError {
-	return SentinelHTTPError{
+func NewSentinelHttpError(status int, message string) SentinelHttpError {
+	return SentinelHttpError{
 		status:  status,
 		message: message,
 	}
 }

 // Error returns the message.
-func (err SentinelHTTPError) Error() string {
+func (err SentinelHttpError) Error() string {
 	return err.message
 }

-// HTTPError returns the status and message.
-func (err SentinelHTTPError) HTTPError() (int, string) {
+// HttpError returns the status and message.
+func (err SentinelHttpError) HttpError() (int, string) {
 	return err.status, err.message
 }

 // sentinelWrappedError contains both the error which will logged and the
-// sidekick SentinelHTTPError.
+// sidekick [SentinelHttpError].
 type sentinelWrappedError struct {
 	error
-	sentinel SentinelHTTPError
+	sentinel SentinelHttpError
 }

 func (w sentinelWrappedError) Is(err error) bool {
 	return w.sentinel == err
 }

-func (w sentinelWrappedError) HTTPError() (int, string) {
-	return w.sentinel.HTTPError()
+func (w sentinelWrappedError) HttpError() (int, string) {
+	return w.sentinel.HttpError()
 }

-// WrapError wraps the given error with a SentinelHTTPError. The wrapped error
-// will be displayed in a log, while the SentinelHTTPError will be sent in the
-// response.
+// WrapError wraps the given error with a [SentinelHttpError]. The wrapped
+// error will be displayed in a log, while the [SentinelHttpError] will be sent
+// in the response.
 //
-//  return api.WrapError(
-//    // This first error will be logged.
-//    fmt.Errorf("my action: %w", err),
-//    // The HTTP error will be sent as a response.
-//    api.NewSentinelHTTPError(
-//      http.StatusForbidden,
-//      "Hey, you did something wrong!"
-//    ),
-//  )
-func WrapError(err error, sentinel SentinelHTTPError) error {
+//	return api.WrapError(
+//	  // This first error will be logged.
+//	  fmt.Errorf("my action: %w", err),
+//	  // The HTTP error will be sent as a response.
+//	  api.NewSentinelHttpError(
+//	    http.StatusForbidden,
+//	    "Hey, you did something wrong!"
+//	  ),
+//	)
+func WrapError(err error, sentinel SentinelHttpError) error {
 	return sentinelWrappedError{
 		error:    err,
 		sentinel: sentinel,
@@ -70,8 +70,8 @@ func WrapError(err error, sentinel SentinelHTTPError) error {

 // Interface guards.
 var (
-	_ error     = (*SentinelHTTPError)(nil)
-	_ HTTPError = (*SentinelHTTPError)(nil)
+	_ error     = (*SentinelHttpError)(nil)
+	_ HttpError = (*SentinelHttpError)(nil)
 	_ error     = (*sentinelWrappedError)(nil)
-	_ HTTPError = (*sentinelWrappedError)(nil)
+	_ HttpError = (*sentinelWrappedError)(nil)
 )
--- a/pkg/modules/api/errors_test.go
+++ b/pkg/modules/api/errors_test.go
@@ -7,9 +7,9 @@ import (
 	"testing"
 )

-func TestNewSentinelHTTPError(t *testing.T) {
-	actual := NewSentinelHTTPError(http.StatusInternalServerError, "foo")
-	expect := SentinelHTTPError{
+func TestNewSentinelHttpError(t *testing.T) {
+	actual := NewSentinelHttpError(http.StatusInternalServerError, "foo")
+	expect := SentinelHttpError{
 		status:  http.StatusInternalServerError,
 		message: "foo",
 	}
@@ -19,8 +19,8 @@ func TestNewSentinelHTTPError(t *testing.T) {
 	}
 }

-func TestSentinelHTTPError_Error(t *testing.T) {
-	err := SentinelHTTPError{
+func TestSentinelHttpError_Error(t *testing.T) {
+	err := SentinelHttpError{
 		message: "foo",
 	}

@@ -32,11 +32,11 @@ func TestSentinelHTTPError_Error(t *testing.T) {
 	}
 }

-func TestSentinelHTTPError_HTTPError(t *testing.T) {
-	actualStatus, actualMessage := SentinelHTTPError{
+func TestSentinelHttpError_HttpError(t *testing.T) {
+	actualStatus, actualMessage := SentinelHttpError{
 		status:  http.StatusInternalServerError,
 		message: "foo",
-	}.HTTPError()
+	}.HttpError()

 	expectStatus := http.StatusInternalServerError
 	expectMessage := "foo"
@@ -51,7 +51,7 @@ func TestSentinelHTTPError_HTTPError(t *testing.T) {
 }

 func TestSentinelWrappedError_Is(t *testing.T) {
-	errSentinel := SentinelHTTPError{}
+	errSentinel := SentinelHttpError{}

 	err := sentinelWrappedError{
 		error:    errors.New("foo"),
@@ -63,19 +63,19 @@ func TestSentinelWrappedError_Is(t *testing.T) {
 	}
 }

-func TestSentinelWrappedError_HTTPError(t *testing.T) {
-	expectStatus, expectMessage := SentinelHTTPError{
+func TestSentinelWrappedError_HttpError(t *testing.T) {
+	expectStatus, expectMessage := SentinelHttpError{
 		status:  http.StatusInternalServerError,
 		message: "foo",
-	}.HTTPError()
+	}.HttpError()

 	actualStatus, actualMessage := sentinelWrappedError{
 		error: errors.New("foo"),
-		sentinel: SentinelHTTPError{
+		sentinel: SentinelHttpError{
 			status:  http.StatusInternalServerError,
 			message: "foo",
 		},
-	}.HTTPError()
+	}.HttpError()

 	if actualStatus != expectStatus {
 		t.Errorf("expected %d but got %d", expectStatus, actualStatus)
@@ -91,13 +91,13 @@ func TestWrapError(t *testing.T) {

 	expect := sentinelWrappedError{
 		error: errFoo,
-		sentinel: SentinelHTTPError{
+		sentinel: SentinelHttpError{
 			status:  http.StatusInternalServerError,
 			message: "foo",
 		},
 	}

-	actual := WrapError(errFoo, SentinelHTTPError{
+	actual := WrapError(errFoo, SentinelHttpError{
 		status:  http.StatusInternalServerError,
 		message: "foo",
 	})
--- a/pkg/modules/api/formdata.go
+++ b/pkg/modules/api/formdata.go
@@ -2,8 +2,8 @@ package api

 import (
 	"fmt"
-	"io/ioutil"
 	"net/http"
+	"os"
 	"path/filepath"
 	"sort"
 	"strconv"
@@ -16,151 +16,151 @@ import (
 // FormData is a helper for validating and hydrating values from a
 // "multipart/form-data" request.
 //
-//  form := ctx.FormData()
+//	form := ctx.FormData()
 type FormData struct {
 	values map[string][]string
 	files  map[string]string
 	errors error
 }

-// Validate returns nil or an error related to the FormData values, with a
-// SentinelHTTPError (status code 400, errors' details as message) wrapped
+// Validate returns nil or an error related to the [FormData] values, with a
+// [SentinelHttpError] (status code 400, errors' details as message) wrapped
 // inside.
 //
-//  var foo string
+//	var foo string
 //
-//  err := ctx.FormData().
-//     MandatoryString("foo", &foo, "bar").
-//     Validate()
-func (form FormData) Validate() error {
+//	err := ctx.FormData().
+//	   MandatoryString("foo", &foo, "bar").
+//	   Validate()
+func (form *FormData) Validate() error {
 	if form.errors == nil {
 		return nil
 	}

 	return WrapError(
 		form.errors,
-		NewSentinelHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid form data: %s", form.errors)),
+		NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid form data: %s", form.errors)),
 	)
 }

-// String binds a form data value to a string variable.
+// String binds a form field to a string variable.
 //
-//  var foo string
+//	var foo string
 //
-//  ctx.FormData().String("foo", &foo, "bar")
+//	ctx.FormData().String("foo", &foo, "bar")
 func (form *FormData) String(key string, target *string, defaultValue string) *FormData {
 	return form.mustValue(key, target, defaultValue)
 }

-// MandatoryString binds a form data value to a string variable. It populates
+// MandatoryString binds a form field to a string variable. It populates
 // an error if the value is empty or the "key" does not exist.
 //
-//  var foo string
+//	var foo string
 //
-//  ctx.FormData().MandatoryString("foo", &foo)
+//	ctx.FormData().MandatoryString("foo", &foo)
 func (form *FormData) MandatoryString(key string, target *string) *FormData {
-	return form.mustMandatoryValue(key, target)
+	return form.mustMandatoryField(key, target)
 }

-// Bool binds a form data value to a bool variable. It populates an error if
+// Bool binds a form field to a bool variable. It populates an error if
 // the value is not bool.
 //
-//  var foo bool
+//	var foo bool
 //
-//  ctx.FormData().Bool("foo", &foo, true)
+//	ctx.FormData().Bool("foo", &foo, true)
 func (form *FormData) Bool(key string, target *bool, defaultValue bool) *FormData {
 	return form.mustValue(key, target, defaultValue)
 }

-// MandatoryBool binds a form data value to a bool variable. It populates an
+// MandatoryBool binds a form field to a bool variable. It populates an
 // error if the value is not bool, is empty, or the "key" does not exist.
 //
-//  var foo bool
+//	var foo bool
 //
-//  ctx.FormData().MandatoryBool("foo", &foo)
+//	ctx.FormData().MandatoryBool("foo", &foo)
 func (form *FormData) MandatoryBool(key string, target *bool) *FormData {
-	return form.mustMandatoryValue(key, target)
+	return form.mustMandatoryField(key, target)
 }

-// Int binds a form data value to an int variable. It populates an error if the
+// Int binds a form field to an int variable. It populates an error if the
 // value is not int.
 //
-//  var foo int
+//	var foo int
 //
-//  ctx.FormData().Int("foo", &foo, 2)
+//	ctx.FormData().Int("foo", &foo, 2)
 func (form *FormData) Int(key string, target *int, defaultValue int) *FormData {
 	return form.mustValue(key, target, defaultValue)
 }

-// MandatoryInt binds a form data value to an int variable. It populates an
+// MandatoryInt binds a form field to an int variable. It populates an
 // error if the value is not int, is empty, or the "key" does not exist.
 //
-//  var foo int
+//	var foo int
 //
-//  ctx.FormData().MandatoryInt("foo", &foo)
+//	ctx.FormData().MandatoryInt("foo", &foo)
 func (form *FormData) MandatoryInt(key string, target *int) *FormData {
-	return form.mustMandatoryValue(key, target)
+	return form.mustMandatoryField(key, target)
 }

-// Float64 binds a form data value to a float64 variable. It populates an error
+// Float64 binds a form field to a float64 variable. It populates an error
 // if the value is not float64.
 //
-//  var foo float64
+//	var foo float64
 //
-//  ctx.FormData().Float64("foo", &foo, 2.0)
+//	ctx.FormData().Float64("foo", &foo, 2.0)
 func (form *FormData) Float64(key string, target *float64, defaultValue float64) *FormData {
 	return form.mustValue(key, target, defaultValue)
 }

-// MandatoryFloat64 binds a form data value to a float64 variable. It populates
+// MandatoryFloat64 binds a form field to a float64 variable. It populates
 // an error if the is not float64, is empty, or the "key" does not exist.
 //
-//  var foo float64
+//	var foo float64
 //
-//  ctx.FormData().MandatoryFloat64("foo", &foo)
+//	ctx.FormData().MandatoryFloat64("foo", &foo)
 func (form *FormData) MandatoryFloat64(key string, target *float64) *FormData {
-	return form.mustMandatoryValue(key, target)
+	return form.mustMandatoryField(key, target)
 }

-// Duration binds a form data value to a time.Duration variable. It populates
-// an error if the form data value is not time.Duration.
+// Duration binds a form field to a time.Duration variable. It populates
+// an error if the form field is not time.Duration.
 //
-//  var foo time.Duration
+//	var foo time.Duration
 //
-//  ctx.FormData().Duration("foo", &foo, time.Duration(2) * time.Second)
+//	ctx.FormData().Duration("foo", &foo, time.Duration(2) * time.Second)
 func (form *FormData) Duration(key string, target *time.Duration, defaultValue time.Duration) *FormData {
 	return form.mustValue(key, target, defaultValue)
 }

-// MandatoryDuration binds a form data value to a time.Duration variable. It
+// MandatoryDuration binds a form field to a time.Duration variable. It
 // populates an error if the value is not time.Duration, is empty, or the "key"
 // does not exist.
 //
-//  var foo time.Duration
+//	var foo time.Duration
 //
-//  ctx.FormData().MandatoryDuration("foo", &foo)
+//	ctx.FormData().MandatoryDuration("foo", &foo)
 func (form *FormData) MandatoryDuration(key string, target *time.Duration) *FormData {
-	return form.mustMandatoryValue(key, target)
+	return form.mustMandatoryField(key, target)
 }

-// Custom helps to define a custom binding function for a form data value.
+// Custom helps to define a custom binding function for a form field.
 //
-//  var foo map[string]string
+//	var foo map[string]string
 //
-//  ctx.FormData().Custom("foo", func(value string) error {
-//    if value == "" {
-//      foo = "bar"
+//	ctx.FormData().Custom("foo", func(value string) error {
+//	  if value == "" {
+//	    foo = "bar"
 //
-//      return nil
-//    }
+//	    return nil
+//	  }
 //
-//    err := json.Unmarshal([]byte(value), &foo)
-//    if err != nil {
-//      return fmt.Errorf("unmarshal foo: %w", err)
-//    }
+//	  err := json.Unmarshal([]byte(value), &foo)
+//	  if err != nil {
+//	    return fmt.Errorf("unmarshal foo: %w", err)
+//	  }
 //
-//    return nil
-//  })
+//	  return nil
+//	})
 func (form *FormData) Custom(key string, assign func(value string) error) *FormData {
 	var value string
 	form.mustValue(key, &value, "")
@@ -168,30 +168,29 @@ func (form *FormData) Custom(key string, assign func(value string) error) *FormD
 	err := assign(value)
 	if err != nil {
 		form.append(
-			fmt.Errorf("form value '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+			fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
 		)
 	}

 	return form
 }

-// MandatoryCustom helps to define a custom binding function for a form data
-// value. It populates an error if the value is empty or the "key" does not
-// exist.
+// MandatoryCustom helps to define a custom binding function for a form field.
+// It populates an error if the value is empty or the "key" does not exist.
 //
-//  var foo map[string]string
+//	var foo map[string]string
 //
-//  ctx.FormData().MandatoryCustom("foo", func(value string) error {
-//    err := json.Unmarshal([]byte(value), &foo)
-//    if err != nil {
-//      return fmt.Errorf("unmarshal foo: %w", err)
-//    }
+//	ctx.FormData().MandatoryCustom("foo", func(value string) error {
+//	  err := json.Unmarshal([]byte(value), &foo)
+//	  if err != nil {
+//	    return fmt.Errorf("unmarshal foo: %w", err)
+//	  }
 //
-//    return nil
-//  })
+//	  return nil
+//	})
 func (form *FormData) MandatoryCustom(key string, assign func(value string) error) *FormData {
 	var value string
-	form.mustMandatoryValue(key, &value)
+	form.mustMandatoryField(key, &value)

 	if value == "" {
 		return form
@@ -200,7 +199,7 @@ func (form *FormData) MandatoryCustom(key string, assign func(value string) erro
 	err := assign(value)
 	if err != nil {
 		form.append(
-			fmt.Errorf("form value '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+			fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
 		)
 	}

@@ -209,9 +208,9 @@ func (form *FormData) MandatoryCustom(key string, assign func(value string) erro

 // Path binds the absolute path of a form data file to a string variable.
 //
-//  var path string
+//	var path string
 //
-//  ctx.FormData().Path("foo.txt", &path)
+//	ctx.FormData().Path("foo.txt", &path)
 func (form *FormData) Path(filename string, target *string) *FormData {
 	return form.path(filename, target)
 }
@@ -219,18 +218,18 @@ func (form *FormData) Path(filename string, target *string) *FormData {
 // MandatoryPath binds the absolute path ofa  form data file to a string
 // variable. It populates an error if the file does not exist.
 //
-//  var path string
+//	var path string
 //
-//  ctx.FormData().MandatoryPath("foo.txt", &path)
+//	ctx.FormData().MandatoryPath("foo.txt", &path)
 func (form *FormData) MandatoryPath(filename string, target *string) *FormData {
 	return form.mandatoryPath(filename, target)
 }

 // Content binds the content of a form data file to a string variable.
 //
-//  var content string
+//	var content string
 //
-//  ctx.FormData().Content("foo.txt", &content, "bar")
+//	ctx.FormData().Content("foo.txt", &content, "bar")
 func (form *FormData) Content(filename string, target *string, defaultValue string) *FormData {
 	var path string
 	form.path(filename, &path)
@@ -247,9 +246,9 @@ func (form *FormData) Content(filename string, target *string, defaultValue stri
 // MandatoryContent binds the content of a form data file to a string variable.
 // It populates an error if the file does not exist.
 //
-//  var content string
+//	var content string
 //
-//  ctx.FormData().MandatoryContent("foo.txt", &content)
+//	ctx.FormData().MandatoryContent("foo.txt", &content)
 func (form *FormData) MandatoryContent(filename string, target *string) *FormData {
 	var path string
 	form.mandatoryPath(filename, &path)
@@ -264,9 +263,9 @@ func (form *FormData) MandatoryContent(filename string, target *string) *FormDat
 // Paths binds the absolute paths of form data files, according to a list of
 // file extensions, to a string slice variable.
 //
-//  var paths []string
+//	var paths []string
 //
-//  ctx.FormData().Paths([]string{".txt"}, &paths)
+//	ctx.FormData().Paths([]string{".txt"}, &paths)
 func (form *FormData) Paths(extensions []string, target *[]string) *FormData {
 	return form.paths(extensions, target)
 }
@@ -275,9 +274,9 @@ func (form *FormData) Paths(extensions []string, target *[]string) *FormData {
 // list of file extensions, to a string slice variable. It populates an error
 // if there is no file for given file extensions.
 //
-//  var paths []string
+//	var paths []string
 //
-//  ctx.FormData().MandatoryPaths([]string{".txt"}, &paths)
+//	ctx.FormData().MandatoryPaths([]string{".txt"}, &paths)
 func (form *FormData) MandatoryPaths(extensions []string, target *[]string) *FormData {
 	form.paths(extensions, target)

@@ -315,7 +314,7 @@ func (form *FormData) append(err error) {
 	form.errors = multierr.Append(form.errors, err)
 }

-// mustValue binds the target interface with a form data value. If the value is
+// mustValue binds the target interface with a form field. If the value is
 // empty or the "key" does not exist, it binds the default value. Currently,
 // only the string, bool, int, float64 and time.Duration types are bindable.
 func (form *FormData) mustValue(key string, target interface{}, defaultValue interface{}) *FormData {
@@ -343,16 +342,16 @@ func (form *FormData) mustValue(key string, target interface{}, defaultValue int
 	return form.mustAssign(key, val[0], target)
 }

-// mustMandatoryValue binds the target interface with a form data value. It
+// mustMandatoryField binds the target interface with a form field. It
 // populates an error if the value is empty or the "key" does not exist.
 // Currently, only the string, bool, int, float64 and time.Duration types are
 // bindable.
-func (form *FormData) mustMandatoryValue(key string, target interface{}) *FormData {
+func (form *FormData) mustMandatoryField(key string, target interface{}) *FormData {
 	val, ok := form.values[key]

 	if !ok || val[0] == "" {
 		form.append(
-			fmt.Errorf("form value '%s' is required", key),
+			fmt.Errorf("form field '%s' is required", key),
 		)

 		return form
@@ -386,7 +385,7 @@ func (form *FormData) mustAssign(key, value string, target interface{}) *FormDat

 	if err != nil {
 		form.append(
-			fmt.Errorf("form value '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+			fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
 		)
 	}

@@ -396,7 +395,9 @@ func (form *FormData) mustAssign(key, value string, target interface{}) *FormDat
 // path binds the absolute path of a form data file to a string variable.
 func (form *FormData) path(filename string, target *string) *FormData {
 	for name, path := range form.files {
-		if name == filename {
+		// See https://github.com/gotenberg/gotenberg/issues/228.
+		nameLowerExt := strings.TrimSuffix(name, filepath.Ext(name)) + strings.ToLower(filepath.Ext(name))
+		if name == filename || nameLowerExt == filename {
 			*target = path
 			return form
 		}
@@ -424,7 +425,7 @@ func (form *FormData) mandatoryPath(filename string, target *string) *FormData {
 // readFile binds the content of a file to a string variable. It populates an
 // error if it fails to read the file content.
 func (form *FormData) readFile(path, filename string, target *string) *FormData {
-	b, err := ioutil.ReadFile(path)
+	b, err := os.ReadFile(path)
 	if err != nil {
 		form.append(
 			fmt.Errorf("form file '%s' is invalid (%w)", filename, err),
--- a/pkg/modules/api/formdata_test.go
+++ b/pkg/modules/api/formdata_test.go
--- a/pkg/modules/api/middlewares.go
+++ b/pkg/modules/api/middlewares.go
@@ -1,103 +1,66 @@
 package api

 import (
-	"bufio"
-	"bytes"
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
 	"strings"
 	"time"

 	"github.com/google/uuid"
-	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

+// ErrAsyncProcess happens when a handler or middleware handles a request in an
+// asynchronous fashion.
+var ErrAsyncProcess = errors.New("async process")
+
+// ParseError parses an error and returns the corresponding HTTP status and
+// HTTP message.
+func ParseError(err error) (int, string) {
+	var echoErr *echo.HTTPError
+	ok := errors.As(err, &echoErr)
+	if ok {
+		return echoErr.Code, http.StatusText(echoErr.Code)
+	}
+
+	if errors.Is(err, context.DeadlineExceeded) {
+		return http.StatusServiceUnavailable, http.StatusText(http.StatusServiceUnavailable)
+	}
+
+	var httpErr HttpError
+	if errors.As(err, &httpErr) {
+		return httpErr.HttpError()
+	}
+
+	// Default 500 status code.
+	return http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)
+}
+
 // httpErrorHandler is the centralized HTTP error handler. It parses the error,
-// returns either a response as "text/plain; charset=UTF-8" or, if a webhook
-// client exists in the echo.Context, sends a request to the webhook error URL
-// with a JSON body containing the trace, the status and the error message.
-func httpErrorHandler(traceHeader string) echo.HTTPErrorHandler {
+// returns a response as "text/plain; charset=UTF-8".
+func httpErrorHandler() echo.HTTPErrorHandler {
 	return func(err error, c echo.Context) {
-		parseError := func(err error) (int, string) {
-			echoErr, ok := err.(*echo.HTTPError)
-			if ok {
-				return echoErr.Code, http.StatusText(echoErr.Code)
-			}
-
-			if errors.Is(err, context.DeadlineExceeded) {
-				return http.StatusServiceUnavailable, http.StatusText(http.StatusServiceUnavailable)
-			}
-
-			var httpErr HTTPError
-			if errors.As(err, &httpErr) {
-				return httpErr.HTTPError()
-			}
-
-			// Default 500 status code.
-			return http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)
-		}
-
-		status, message := parseError(err)
-
 		logger := c.Get("logger").(*zap.Logger)
-		clientOrNil := c.Get("webhookClient")
+		status, message := ParseError(err)

-		// No webhook client, meaning we can send the error as a response.
-		if clientOrNil == nil {
-			c.Response().Header().Add(echo.HeaderContentType, echo.MIMETextPlainCharsetUTF8)
+		c.Response().Header().Add(echo.HeaderContentType, echo.MIMETextPlainCharsetUTF8)

-			err = c.String(status, message)
-
-			if err != nil {
-				logger.Error(fmt.Sprintf("send error response: %s", err.Error()))
-			}
-
-			return
-		}
-
-		// We have to send the error to the webhook.
-		client := clientOrNil.(*webhookClient)
-
-		body := struct {
-			Status  int    `json:"status"`
-			Message string `json:"message"`
-		}{
-			Status:  status,
-			Message: message,
-		}
-
-		b, err := json.Marshal(body)
+		err = c.String(status, message)
 		if err != nil {
-			logger.Error(fmt.Sprintf("marshal JSON: %s", err.Error()))
-
-			return
-		}
-
-		headers := map[string]string{
-			echo.HeaderContentType: echo.MIMEApplicationJSONCharsetUTF8,
-			traceHeader:            c.Get("trace").(string),
-		}
-
-		err = client.send(bytes.NewReader(b), headers, true)
-		if err != nil {
-			logger.Error(fmt.Sprintf("send error response to webhook: %s", err.Error()))
+			logger.Error(fmt.Sprintf("send error response: %s", err.Error()))
 		}
 	}
 }

-// latencyMiddleware sets the start time in the echo.Context under "startTime".
-// Its value will be used later to calculate a request latency.
+// latencyMiddleware sets the start time in the [echo.Context] under
+// "startTime". Its value will be used later to calculate a request latency.
 //
-//  startTime := c.Get("startTime").(time.Time)
+//	startTime := c.Get("startTime").(time.Time)
 func latencyMiddleware() echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
@@ -111,18 +74,18 @@ func latencyMiddleware() echo.MiddlewareFunc {
 	}
 }

-// rootPathMiddleware sets the root path in the echo.Context under "rootPath".
-// Its value may be used to skip a middleware execution based on a request
-// URI.
+// rootPathMiddleware sets the root path in the [echo.Context] under
+// "rootPath". Its value may be used to skip a middleware execution based on a
+// request URI.
 //
-//  rootPath := c.Get("rootPath").(string)
-//  healthURI := fmt.Sprintf("%shealth", rootPath)
+//	rootPath := c.Get("rootPath").(string)
+//	healthURI := fmt.Sprintf("%s/health", rootPath)
 //
-//  // Skip the middleware if health check URI.
-//  if c.Request().RequestURI == healthURI {
-//    // Call the next middleware in the chain.
-//    return next(c)
-//  }
+//	// Skip the middleware if health check URI.
+//	if c.Request().RequestURI == healthURI {
+//	  // Call the next middleware in the chain.
+//	  return next(c)
+//	}
 func rootPathMiddleware(rootPath string) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
@@ -134,11 +97,12 @@ func rootPathMiddleware(rootPath string) echo.MiddlewareFunc {
 	}
 }

-// traceMiddleware sets the request identifier in the echo.Context under
+// traceMiddleware sets the request identifier in the [echo.Context] under
 // "trace". Its value is either retrieved from the trace header or generated if
 // the header is not present / its value is empty.
 //
-//  trace := c.Get("trace").(string)
+//	trace := c.Get("trace").(string)
+//	traceHeader := c.Get("traceHeader").(string).
 func traceMiddleware(header string) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
@@ -150,6 +114,7 @@ func traceMiddleware(header string) echo.MiddlewareFunc {
 			}

 			c.Set("trace", trace)
+			c.Set("traceHeader", header)
 			c.Response().Header().Add(header, trace)

 			// Call the next middleware in the chain.
@@ -158,20 +123,26 @@ func traceMiddleware(header string) echo.MiddlewareFunc {
 	}
 }

-// loggerMiddleware sets the logger in the echo.Context under "logger" and logs
-// a request result (but does not log a webhook call result, which is the job
-// of the webhookClient).
+// loggerMiddleware sets the logger in the [echo.Context] under "logger" and
+// logs a synchronous request result.
 //
-//  logger := c.Get("logger").(*zap.Logger)
-func loggerMiddleware(logger *zap.Logger, skipHealthRouteLogging bool) echo.MiddlewareFunc {
+//	logger := c.Get("logger").(*zap.Logger)
+func loggerMiddleware(logger *zap.Logger, disableLoggingForPaths []string) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			startTime := c.Get("startTime").(time.Time)
 			trace := c.Get("trace").(string)
+			rootPath := c.Get("rootPath").(string)

 			// Create the request logger and add it to our locals.
 			reqLogger := logger.With(zap.String("trace", trace))
-			c.Set("logger", reqLogger)
+			c.Set("logger", reqLogger.Named(func() string {
+				return strings.ReplaceAll(
+					strings.ReplaceAll(c.Request().URL.Path, rootPath, ""),
+					"/",
+					"",
+				)
+			}()))

 			// Call the next middleware in the chain.
 			err := next(c)
@@ -179,11 +150,10 @@ func loggerMiddleware(logger *zap.Logger, skipHealthRouteLogging bool) echo.Midd
 				c.Error(err)
 			}

-			if skipHealthRouteLogging {
-				rootPath := c.Get("rootPath").(string)
-				healthURI := fmt.Sprintf("%shealth", rootPath)
+			for _, path := range disableLoggingForPaths {
+				URI := fmt.Sprintf("%s%s", rootPath, path)

-				if c.Request().RequestURI == healthURI {
+				if c.Request().RequestURI == URI {
 					return nil
 				}
 			}
@@ -225,317 +195,65 @@ func loggerMiddleware(logger *zap.Logger, skipHealthRouteLogging bool) echo.Midd
 	}
 }

-type contextMiddlewareConfig struct {
-	traceHeader string
-	timeout     struct {
-		process time.Duration
-		write   time.Duration
-	}
-	webhook struct {
-		allowList      *regexp.Regexp
-		denyList       *regexp.Regexp
-		errorAllowList *regexp.Regexp
-		errorDenyList  *regexp.Regexp
-		maxRetry       int
-		retryMinWait   time.Duration
-		retryMaxWait   time.Duration
-		disable        bool
-	}
-}
-
-// contextMiddleware handles the result of a "multipart/form-data" request. If
-// a webhook URL is present in the headers, exit early and process the result
-// in a goroutine.
-func contextMiddleware(cfg contextMiddlewareConfig) echo.MiddlewareFunc {
+// contextMiddleware, a middleware for "multipart/form-data" requests, sets the
+// [Context] and related context.CancelFunc in the [echo.Context] under
+// "context" and "cancel". If the process is synchronous, it also handles the
+// result of a "multipart/form-data" request.
+//
+//	ctx := c.Get("context").(*api.Context)
+//	cancel := c.Get("cancel").(context.CancelFunc)
+func contextMiddleware(fs *gotenberg.FileSystem, timeout time.Duration) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
-			webhookURL := c.Request().Header.Get("Gotenberg-Webhook-Url")
-			logger := c.Get("logger").(*zap.Logger).With(zap.Bool("webhook", webhookURL != ""))
+			logger := c.Get("logger").(*zap.Logger)

 			// We create a context with a timeout so that underlying processes are
 			// able to stop early and handle correctly a timeout scenario.
-			ctx, cancel, err := newContext(c, logger, cfg.timeout.process)
+			ctx, cancel, err := newContext(c, logger, fs, timeout)
 			if err != nil {
 				cancel()

 				return fmt.Errorf("create request context: %w", err)
 			}
 			c.Set("context", ctx)
+			c.Set("cancel", cancel)

-			// Helper function for retrieving/creating the output filename.
-			outputFilename := func(outputPath string) string {
-				filename := c.Request().Header.Get("Gotenberg-Output-Filename")
+			// Call the next middleware in the chain.
+			err = next(c)

-				if filename == "" {
-					return filepath.Base(outputPath)
-				}
-
-				return fmt.Sprintf("%s%s", filename, filepath.Ext(outputPath))
+			if errors.Is(err, ErrAsyncProcess) {
+				// A middleware/handler tells us that it's handling the process
+				// in an asynchronous fashion. Therefore, we must not cancel
+				// the context nor send an output file.
+				return c.NoContent(http.StatusNoContent)
 			}

-			if webhookURL == "" {
-				defer cancel()
+			defer cancel()

-				// No webhook URL, call the next middleware in the chain.
-				err := next(c)
-
-				if err != nil {
-					return err
-				}
-
-				// No error, let's build the output file.
-				outputPath, err := ctx.buildOutputFile()
-				if err != nil {
-					return fmt.Errorf("build output file: %w", err)
-				}
-
-				// Send the output file.
-				err = c.Attachment(outputPath, outputFilename(outputPath))
-				if err != nil {
-					return fmt.Errorf("send response: %w", err)
-				}
-
-				return nil
-			}
-
-			// Ok, we got a webhook URL.
-
-			if cfg.webhook.disable {
-				// The client requested the webhook feature, but it has been
-				// disabled. Let's tell the client about that.
-				cancel()
-
-				return WrapError(
-					errors.New("webhook feature requested but it is disabled"),
-					NewSentinelHTTPError(http.StatusForbidden, "Invalid 'Gotenberg-Webhook-Url' header: feature is disabled"),
-				)
-			}
-
-			// Do we have a webhook error URL in case of... error?
-			webhookErrorURL := c.Request().Header.Get("Gotenberg-Webhook-Error-Url")
-
-			if webhookErrorURL == "" {
-				cancel()
-
-				return WrapError(
-					errors.New("empty webhook error URL"),
-					NewSentinelHTTPError(http.StatusBadRequest, "Invalid 'Gotenberg-Webhook-Error-Url' header: empty value or header not provided"),
-				)
-			}
-
-			// Let's check if the webhook URLs are acceptable according to our
-			// allowed/denied lists.
-			filter := func(URL, header string, allowList, denyList *regexp.Regexp) error {
-				if !allowList.MatchString(URL) {
-					return WrapError(
-						fmt.Errorf("'%s' does not match the expression from the allowed list", URL),
-						NewSentinelHTTPError(
-							http.StatusForbidden,
-							fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URLs", header, URL),
-						),
-					)
-				}
-
-				if denyList.String() != "" && denyList.MatchString(URL) {
-					return WrapError(
-						fmt.Errorf("'%s' matches the expression from the denied list", URL),
-						NewSentinelHTTPError(
-							http.StatusForbidden,
-							fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URLs", header, URL),
-						),
-					)
-				}
-
-				return nil
-			}
-
-			err = filter(webhookURL, "Gotenberg-Webhook-Url", cfg.webhook.allowList, cfg.webhook.denyList)
 			if err != nil {
-				cancel()
-
-				return fmt.Errorf("filter webhook URL: %w", err)
+				return err
 			}

-			err = filter(webhookErrorURL, "Gotenberg-Webhook-Error-Url", cfg.webhook.errorAllowList, cfg.webhook.errorDenyList)
+			// No error, let's build the output file.
+			outputPath, err := ctx.BuildOutputFile()
 			if err != nil {
-				cancel()
-
-				return fmt.Errorf("filter webhook error URL: %w", err)
+				return fmt.Errorf("build output file: %w", err)
 			}

-			// Let's check the HTTP methods for calling the webhook URLs.
-			methodFromHeader := func(header string) (string, error) {
-				method := c.Request().Header.Get(header)
-
-				if method == "" {
-					return http.MethodPost, nil
-				}
-
-				method = strings.ToUpper(method)
-
-				switch method {
-				case http.MethodPost:
-					return method, nil
-				case http.MethodPatch:
-					return method, nil
-				case http.MethodPut:
-					return method, nil
-				}
-
-				return "", WrapError(
-					fmt.Errorf("webhook method '%s' is not '%s', '%s' or '%s'", method, http.MethodPost, http.MethodPatch, http.MethodPut),
-					NewSentinelHTTPError(
-						http.StatusBadRequest,
-						fmt.Sprintf("Invalid '%s' header value: expected '%s', '%s' or '%s', but got '%s'", header, http.MethodPost, http.MethodPatch, http.MethodPut, method),
-					),
-				)
-			}
-
-			webhookMethod, err := methodFromHeader("Gotenberg-Webhook-Method")
+			// Send the output file.
+			err = c.Attachment(outputPath, ctx.OutputFilename(outputPath))
 			if err != nil {
-				cancel()
-
-				return fmt.Errorf("get method to use for webhook: %w", err)
+				return fmt.Errorf("send response: %w", err)
 			}

-			webhookErrorMethod, err := methodFromHeader("Gotenberg-Webhook-Error-Method")
-			if err != nil {
-				cancel()
-
-				return fmt.Errorf("get method to use for webhook error: %w", err)
-			}
-
-			// What about extra HTTP headers?
-			var extraHTTPHeaders map[string]string
-
-			extraHTTPHeadersJSON := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers")
-			if extraHTTPHeadersJSON != "" {
-				err = json.Unmarshal([]byte(extraHTTPHeadersJSON), &extraHTTPHeaders)
-				if err != nil {
-					cancel()
-
-					return WrapError(
-						fmt.Errorf("unmarshal webhook extra HTTP headers: %w", err),
-						NewSentinelHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Gotenberg-Webhook-Extra-Http-Headers' header value: %s", err.Error())),
-					)
-				}
-			}
-
-			client := &webhookClient{
-				url:              webhookURL,
-				method:           webhookMethod,
-				errorURL:         webhookErrorURL,
-				errorMethod:      webhookErrorMethod,
-				extraHTTPHeaders: extraHTTPHeaders,
-				startTime:        c.Get("startTime").(time.Time),
-
-				client: &retryablehttp.Client{
-					HTTPClient: &http.Client{
-						Timeout: cfg.timeout.write,
-					},
-					RetryMax:     cfg.webhook.maxRetry,
-					RetryWaitMin: cfg.webhook.retryMinWait,
-					RetryWaitMax: cfg.webhook.retryMaxWait,
-					Logger: leveledLogger{
-						logger: logger,
-					},
-					CheckRetry: retryablehttp.DefaultRetryPolicy,
-					Backoff:    retryablehttp.DefaultBackoff,
-				},
-				logger: logger,
-			}
-
-			c.Set("webhookClient", client)
-
-			// As a webhook URL has been given, we handle the request in a
-			// goroutine and return immediately.
-			go func() {
-				defer cancel()
-
-				// Call the next middleware in the chain.
-				err := next(c)
-
-				if err != nil {
-					// The process failed for whatever reason. Let's send the
-					// details to the webhook.
-					ctx.Log().Error(err.Error())
-					c.Error(err)
-
-					return
-				}
-
-				// No error, let's get build the output file.
-				outputPath, err := ctx.buildOutputFile()
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("build output file: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				outputFile, err := os.Open(outputPath)
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("open output file: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				defer func() {
-					err := outputFile.Close()
-					if err != nil {
-						ctx.Log().Error(fmt.Sprintf("close output file: %s", err))
-					}
-				}()
-
-				fileHeader := make([]byte, 512)
-				_, err = outputFile.Read(fileHeader)
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("read header of output file: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				fileStat, err := outputFile.Stat()
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("get stat from output file: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				_, err = outputFile.Seek(0, 0)
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("reset output file reader: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				headers := map[string]string{
-					echo.HeaderContentDisposition: fmt.Sprintf("attachement; filename=%q", outputFilename(outputPath)),
-					echo.HeaderContentType:        http.DetectContentType(fileHeader),
-					echo.HeaderContentLength:      strconv.FormatInt(fileStat.Size(), 10),
-					cfg.traceHeader:               c.Get("trace").(string),
-				}
-
-				// Send the output file to the webhook.
-				err = client.send(bufio.NewReader(outputFile), headers, false)
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("send output file to webhook: %s", err))
-					c.Error(err)
-				}
-			}()
-
-			return c.NoContent(http.StatusNoContent)
+			return nil
 		}
 	}
 }

-// timeoutMiddleware manages hard timeout scenarios, i.e., when a route handler
-// fails to timeout as expected.
-func timeoutMiddleware(hardTimeout time.Duration) echo.MiddlewareFunc {
+// hardTimeoutMiddleware manages hard timeout scenarios, i.e., when a route
+// handler fails to timeout as expected.
+func hardTimeoutMiddleware(hardTimeout time.Duration) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			logger := c.Get("logger").(*zap.Logger)
--- a/pkg/modules/api/middlewares_test.go
+++ b/pkg/modules/api/middlewares_test.go
@@ -3,28 +3,23 @@ package api
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"errors"
-	"fmt"
-	"io/ioutil"
-	"math/rand"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
-	"regexp"
 	"strings"
 	"testing"
 	"time"

-	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

-func TestHttpErrorHandler(t *testing.T) {
+func TestParseError(t *testing.T) {
 	for i, tc := range []struct {
 		err           error
-		webhookClient *webhookClient
 		expectStatus  int
 		expectMessage string
 	}{
@@ -41,35 +36,47 @@ func TestHttpErrorHandler(t *testing.T) {
 		{
 			err: WrapError(
 				errors.New("foo"),
-				NewSentinelHTTPError(http.StatusBadRequest, "foo"),
+				NewSentinelHttpError(http.StatusBadRequest, "foo"),
 			),
 			expectStatus:  http.StatusBadRequest,
 			expectMessage: "foo",
 		},
+	} {
+		actualStatus, actualMessage := ParseError(tc.err)
+
+		if actualStatus != tc.expectStatus {
+			t.Errorf("test %d: expected HTTP status code %d but got %d", i, tc.expectStatus, actualStatus)
+		}
+
+		if actualMessage != tc.expectMessage {
+			t.Errorf("test %d: expected message '%s' but got '%s'", i, tc.expectMessage, actualMessage)
+		}
+	}
+}
+
+func TestHttpErrorHandler(t *testing.T) {
+	for i, tc := range []struct {
+		err           error
+		expectStatus  int
+		expectMessage string
+	}{
 		{
-			err: echo.ErrInternalServerError,
-			webhookClient: &webhookClient{
-				errorURL:    "http://localhost:%d/",
-				errorMethod: http.MethodPost,
-				client:      retryablehttp.NewClient(),
-				logger:      zap.NewNop(),
-			},
+			err:           echo.ErrInternalServerError,
 			expectStatus:  http.StatusInternalServerError,
 			expectMessage: http.StatusText(http.StatusInternalServerError),
 		},
 		{
-			err: echo.ErrInternalServerError,
-			webhookClient: &webhookClient{
-				errorURL:    "non-existent",
-				errorMethod: http.MethodPost,
-				client: func() *retryablehttp.Client {
-					client := retryablehttp.NewClient()
-					client.RetryMax = 0
-
-					return client
-				}(),
-				logger: zap.NewNop(),
-			},
+			err:           context.DeadlineExceeded,
+			expectStatus:  http.StatusServiceUnavailable,
+			expectMessage: http.StatusText(http.StatusServiceUnavailable),
+		},
+		{
+			err: WrapError(
+				errors.New("foo"),
+				NewSentinelHttpError(http.StatusBadRequest, "foo"),
+			),
+			expectStatus:  http.StatusBadRequest,
+			expectMessage: "foo",
 		},
 	} {
 		recorder := httptest.NewRecorder()
@@ -81,105 +88,24 @@ func TestHttpErrorHandler(t *testing.T) {

 		c := srv.NewContext(request, recorder)
 		c.Set("logger", zap.NewNop())
-		c.Set("trace", "foo")

-		if tc.webhookClient != nil {
-			c.Set("webhookClient", tc.webhookClient)
+		handler := httpErrorHandler()
+		handler(tc.err, c)
+
+		contentType := recorder.Header().Get(echo.HeaderContentType)
+		if contentType != echo.MIMETextPlainCharsetUTF8 {
+			t.Errorf("test %d: expected %s '%s' but got '%s'", i, echo.HeaderContentType, echo.MIMETextPlainCharsetUTF8, contentType)
 		}

-		if tc.webhookClient == nil {
-			handler := httpErrorHandler("Gotenberg-Trace")
-			handler(tc.err, c)
+		// Note: we cannot test the trace header in the response here, as it is set in the trace middleware.

-			contentType := recorder.Header().Get(echo.HeaderContentType)
-			if contentType != echo.MIMETextPlainCharsetUTF8 {
-				t.Errorf("test %d: expected %s '%s' but got '%s'", i, echo.HeaderContentType, echo.MIMETextPlainCharsetUTF8, contentType)
-			}
-
-			// Note: we cannot test the trace header in the response here, as it is set in the trace middleware.
-
-			if recorder.Code != tc.expectStatus {
-				t.Errorf("test %d: expected HTTP status code %d but got %d", i, tc.expectStatus, recorder.Code)
-			}
-
-			if recorder.Body.String() != tc.expectMessage {
-				t.Errorf("test %d: expected message '%s' but got '%s'", i, tc.expectMessage, recorder.Body.String())
-			}
-
-			continue
+		if recorder.Code != tc.expectStatus {
+			t.Errorf("test %d: expected HTTP status code %d but got %d", i, tc.expectStatus, recorder.Code)
 		}

-		func() {
-			rand.Seed(time.Now().UnixNano())
-			webhookPort := rand.Intn(65535-1+1) + 1
-
-			tc.webhookClient.errorURL = fmt.Sprintf(tc.webhookClient.errorURL, webhookPort)
-
-			c.Set("webhookClient", tc.webhookClient)
-
-			webhook := echo.New()
-			webhook.HideBanner = true
-			webhook.HidePort = true
-
-			webhook.POST(
-				"/",
-				func() echo.HandlerFunc {
-					return func(c echo.Context) error {
-						contentType := c.Request().Header.Get(echo.HeaderContentType)
-						if contentType != echo.MIMEApplicationJSONCharsetUTF8 {
-							t.Errorf("test %d: expected %s '%s' but got '%s'", i, echo.HeaderContentType, echo.MIMEApplicationJSONCharsetUTF8, contentType)
-						}
-
-						trace := c.Request().Header.Get("Gotenberg-Trace")
-						if trace != "foo" {
-							t.Errorf("test %d: expected %s '%s' but got '%s'", i, "Gotenberg-Trace", "foo", trace)
-						}
-
-						body, err := ioutil.ReadAll(c.Request().Body)
-						if err != nil {
-							t.Fatalf("test %d: expected not error but got: %v", i, err)
-						}
-
-						result := struct {
-							Status  int    `json:"status"`
-							Message string `json:"message"`
-						}{}
-
-						err = json.Unmarshal(body, &result)
-						if err != nil {
-							t.Fatalf("test %d: expected not error but got: %v", i, err)
-						}
-
-						if result.Status != tc.expectStatus {
-							t.Errorf("test %d: expected status %d from JSON but got %d", i, tc.expectStatus, result.Status)
-						}
-
-						if result.Message != tc.expectMessage {
-							t.Errorf("test %d: expected message '%s' from JSON but got '%s'", i, tc.expectMessage, result.Message)
-						}
-
-						return nil
-					}
-				}(),
-			)
-
-			go func(server *echo.Echo, port, i int) {
-				err := webhook.Start(fmt.Sprintf(":%d", port))
-				if !errors.Is(err, http.ErrServerClosed) {
-					t.Errorf("test %d: expected no error but got: %v", i, err)
-				}
-			}(webhook, webhookPort, i)
-
-			defer func() {
-				err := webhook.Shutdown(context.TODO())
-				if err != nil {
-					t.Errorf("test %d: expected no error but got: %v", i, err)
-				}
-			}()
-
-			handler := httpErrorHandler("Gotenberg-Trace")
-			handler(tc.err, c)
-		}()
+		if recorder.Body.String() != tc.expectMessage {
+			t.Errorf("test %d: expected message '%s' but got '%s'", i, tc.expectMessage, recorder.Body.String())
+		}
 	}
 }

@@ -198,7 +124,6 @@ func TestLatencyMiddleware(t *testing.T) {
 			return nil
 		},
 	)(c)
-
 	if err != nil {
 		t.Fatalf("expected no error but got: %v", err)
 	}
@@ -226,7 +151,6 @@ func TestRootPathMiddleware(t *testing.T) {
 			return nil
 		},
 	)(c)
-
 	if err != nil {
 		t.Fatalf("expected no error but got: %v", err)
 	}
@@ -267,7 +191,6 @@ func TestTraceMiddleware(t *testing.T) {
 				return nil
 			},
 		)(c)
-
 		if err != nil {
 			t.Fatalf("test %d: expected no error but got: %v", i, err)
 		}
@@ -300,9 +223,9 @@ func TestTraceMiddleware(t *testing.T) {

 func TestLoggerMiddleware(t *testing.T) {
 	for i, tc := range []struct {
-		request                *http.Request
-		next                   echo.HandlerFunc
-		skipHealthRouteLogging bool
+		request     *http.Request
+		next        echo.HandlerFunc
+		skipLogging bool
 	}{
 		{
 			request: httptest.NewRequest(http.MethodGet, "/", nil),
@@ -319,7 +242,7 @@ func TestLoggerMiddleware(t *testing.T) {
 					return nil
 				}
 			}(),
-			skipHealthRouteLogging: true,
+			skipLogging: true,
 		},
 		{
 			request: httptest.NewRequest(http.MethodGet, "/health", nil),
@@ -341,15 +264,19 @@ func TestLoggerMiddleware(t *testing.T) {
 		c.Set("trace", "foo")
 		c.Set("rootPath", "/")

-		err := loggerMiddleware(zap.NewNop(), tc.skipHealthRouteLogging)(tc.next)(c)
+		var disableLoggingForPaths []string
+		if tc.skipLogging {
+			disableLoggingForPaths = append(disableLoggingForPaths, tc.request.RequestURI)
+		}

+		err := loggerMiddleware(zap.NewNop(), disableLoggingForPaths)(tc.next)(c)
 		if err != nil {
 			t.Errorf("test %d: expected no error but got: %v", i, err)
 		}
 	}
 }

-func TestContextMiddlewareWithoutWebhook(t *testing.T) {
+func TestContextMiddleware(t *testing.T) {
 	buildMultipartFormDataRequest := func() *http.Request {
 		body := &bytes.Buffer{}
 		writer := multipart.NewWriter(body)
@@ -376,6 +303,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 		request           *http.Request
 		next              echo.HandlerFunc
 		expectErr         bool
+		expectStatus      int
 		expectContentType string
 		expectFilename    string
 	}{
@@ -383,6 +311,15 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 			request:   httptest.NewRequest(http.MethodGet, "/", nil),
 			expectErr: true,
 		},
+		{
+			request: buildMultipartFormDataRequest(),
+			next: func() echo.HandlerFunc {
+				return func(c echo.Context) error {
+					return ErrAsyncProcess
+				}
+			}(),
+			expectStatus: http.StatusNoContent,
+		},
 		{
 			request: buildMultipartFormDataRequest(),
 			next: func() echo.HandlerFunc {
@@ -418,6 +355,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 					return nil
 				}
 			}(),
+			expectStatus:      http.StatusOK,
 			expectContentType: "application/pdf",
 			expectFilename:    "foo.pdf",
 		},
@@ -434,6 +372,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 					return nil
 				}
 			}(),
+			expectStatus:      http.StatusOK,
 			expectContentType: "application/zip",
 		},
 	} {
@@ -448,16 +387,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 		c.Set("trace", "foo")
 		c.Set("startTime", time.Now())

-		cfg := contextMiddlewareConfig{
-			timeout: struct {
-				process time.Duration
-				write   time.Duration
-			}{
-				process: time.Duration(10) * time.Second,
-			},
-		}
-
-		err := contextMiddleware(cfg)(tc.next)(c)
+		err := contextMiddleware(gotenberg.NewFileSystem(), time.Duration(10)*time.Second)(tc.next)(c)

 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)
@@ -471,8 +401,12 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 			continue
 		}

-		if recorder.Code != http.StatusOK {
-			t.Errorf("test %d: expected HTTP status code %d but got %d", i, http.StatusOK, recorder.Code)
+		if recorder.Code != tc.expectStatus {
+			t.Errorf("test %d: expected HTTP status code %d but got %d", i, tc.expectStatus, recorder.Code)
+		}
+
+		if tc.expectStatus == http.StatusNoContent {
+			continue
 		}

 		contentType := recorder.Header().Get(echo.HeaderContentType)
@@ -487,470 +421,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 	}
 }

-func TestContextMiddlewareWithWebhook(t *testing.T) {
-	buildMultipartFormDataRequest := func() *http.Request {
-		body := &bytes.Buffer{}
-		writer := multipart.NewWriter(body)
-
-		defer func() {
-			err := writer.Close()
-			if err != nil {
-				t.Fatalf("expected no error but got: %v", err)
-			}
-		}()
-
-		err := writer.WriteField("foo", "foo")
-		if err != nil {
-			t.Fatalf("expected no error but got: %v", err)
-		}
-
-		req := httptest.NewRequest(http.MethodPost, "/", body)
-		req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
-
-		return req
-	}
-
-	buildContextMiddlewareConfig := func() contextMiddlewareConfig {
-		return contextMiddlewareConfig{
-			traceHeader: "Gotenberg-Trace",
-			timeout: struct {
-				process time.Duration
-				write   time.Duration
-			}{
-				process: time.Duration(10) * time.Second,
-				write:   time.Duration(10) * time.Second,
-			},
-			webhook: struct {
-				allowList      *regexp.Regexp
-				denyList       *regexp.Regexp
-				errorAllowList *regexp.Regexp
-				errorDenyList  *regexp.Regexp
-				maxRetry       int
-				retryMinWait   time.Duration
-				retryMaxWait   time.Duration
-				disable        bool
-			}{
-				allowList:      regexp.MustCompile(""),
-				denyList:       regexp.MustCompile(""),
-				errorAllowList: regexp.MustCompile(""),
-				errorDenyList:  regexp.MustCompile(""),
-			},
-		}
-	}
-
-	for i, tc := range []struct {
-		request                       *http.Request
-		cfg                           contextMiddlewareConfig
-		next                          echo.HandlerFunc
-		autoWebhookURLs               bool
-		expectErr                     bool
-		expectHTTPErr                 bool
-		expectHTTPStatus              int
-		expectWebhookContentType      string
-		expectWebhookMethod           string
-		expectWebhookExtraHTTPHeaders map[string]string
-		expectWebhookFilename         string
-	}{
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.disable = true
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.allowList = regexp.MustCompile("bar")
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.denyList = regexp.MustCompile("foo")
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.errorAllowList = regexp.MustCompile("foo")
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.errorDenyList = regexp.MustCompile("bar")
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Method", http.MethodGet)
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Method", http.MethodPost)
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Method", http.MethodPatch)
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Method", http.MethodPut)
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Extra-Http-Headers", "foo")
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: buildMultipartFormDataRequest(),
-			cfg:     buildContextMiddlewareConfig(),
-			next: func() echo.HandlerFunc {
-				return func(c echo.Context) error {
-					return errors.New("foo")
-				}
-			}(),
-			autoWebhookURLs:          true,
-			expectWebhookContentType: echo.MIMEApplicationJSONCharsetUTF8,
-			expectWebhookMethod:      http.MethodPost,
-		},
-		{
-			request: buildMultipartFormDataRequest(),
-			cfg:     buildContextMiddlewareConfig(),
-			next: func() echo.HandlerFunc {
-				return func(c echo.Context) error {
-					return nil
-				}
-			}(),
-			autoWebhookURLs:          true,
-			expectWebhookContentType: echo.MIMEApplicationJSONCharsetUTF8,
-			expectWebhookMethod:      http.MethodPost,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Output-Filename", "foo")
-				req.Header.Set("Gotenberg-Webhook-Extra-Http-Headers", `{ "foo": "bar" }`)
-
-				return req
-			}(),
-			cfg: buildContextMiddlewareConfig(),
-			next: func() echo.HandlerFunc {
-				return func(c echo.Context) error {
-					ctx := c.Get("context").(*Context)
-					ctx.outputPaths = []string{
-						"/tests/test/testdata/api/sample2.pdf",
-					}
-
-					return nil
-				}
-			}(),
-			autoWebhookURLs:               true,
-			expectWebhookContentType:      "application/pdf",
-			expectWebhookMethod:           http.MethodPost,
-			expectWebhookFilename:         "foo",
-			expectWebhookExtraHTTPHeaders: map[string]string{"foo": "bar"},
-		},
-		{
-			request: buildMultipartFormDataRequest(),
-			cfg:     buildContextMiddlewareConfig(),
-			next: func() echo.HandlerFunc {
-				return func(c echo.Context) error {
-					ctx := c.Get("context").(*Context)
-					ctx.outputPaths = []string{
-						"/tests/test/testdata/api/sample1.txt",
-						"/tests/test/testdata/api/sample2.pdf",
-					}
-
-					return nil
-				}
-			}(),
-			autoWebhookURLs:          true,
-			expectWebhookContentType: "application/zip",
-			expectWebhookMethod:      http.MethodPost,
-		},
-	} {
-		func() {
-			recorder := httptest.NewRecorder()
-
-			srv := echo.New()
-			srv.HideBanner = true
-			srv.HidePort = true
-			srv.HTTPErrorHandler = httpErrorHandler(tc.cfg.traceHeader)
-
-			c := srv.NewContext(tc.request, recorder)
-			c.Set("logger", zap.NewNop())
-			c.Set("trace", "foo")
-			c.Set("startTime", time.Now())
-
-			webhook := echo.New()
-			webhook.HideBanner = true
-			webhook.HidePort = true
-
-			rand.Seed(time.Now().UnixNano())
-			webhookPort := rand.Intn(65535-1+1) + 1
-
-			if tc.autoWebhookURLs {
-				c.Request().Header.Set("Gotenberg-Webhook-Url", fmt.Sprintf("http://localhost:%d/", webhookPort))
-				c.Request().Header.Set("Gotenberg-Webhook-Error-Url", fmt.Sprintf("http://localhost:%d/", webhookPort))
-			}
-
-			errChan := make(chan error, 1)
-
-			webhook.POST(
-				"/",
-				func() echo.HandlerFunc {
-					return func(c echo.Context) error {
-						contentType := c.Request().Header.Get(echo.HeaderContentType)
-						if contentType != tc.expectWebhookContentType {
-							t.Errorf("test %d: expected %s '%s' but got '%s'", i, echo.HeaderContentType, tc.expectWebhookContentType, contentType)
-						}
-
-						trace := c.Request().Header.Get(tc.cfg.traceHeader)
-						if trace != "foo" {
-							t.Errorf("test %d: expected %s '%s' but got '%s'", i, "Gotenberg-Trace", "foo", trace)
-						}
-
-						method := c.Request().Method
-						if method != tc.expectWebhookMethod {
-							t.Errorf("test %d: expected HTTP method '%s' but got '%s'", i, tc.expectWebhookMethod, method)
-						}
-
-						for key, expect := range tc.expectWebhookExtraHTTPHeaders {
-							actual := c.Request().Header.Get(key)
-
-							if actual != expect {
-								t.Errorf("test %d: expected %s '%s' but got '%s'", i, key, expect, actual)
-							}
-						}
-
-						if tc.expectWebhookContentType == echo.MIMEApplicationJSONCharsetUTF8 {
-							errChan <- nil
-							return nil
-						}
-
-						contentLength := c.Request().Header.Get(echo.HeaderContentLength)
-						if contentLength == "" {
-							t.Errorf("test %d: expected non empty %s", i, echo.HeaderContentLength)
-						}
-
-						contentDisposition := c.Request().Header.Get(echo.HeaderContentDisposition)
-						if !strings.Contains(contentDisposition, tc.expectWebhookFilename) {
-							t.Errorf("test %d: expected %s '%s' to contain '%s'", i, echo.HeaderContentDisposition, contentDisposition, tc.expectWebhookFilename)
-						}
-
-						body, err := ioutil.ReadAll(c.Request().Body)
-						if err != nil {
-							errChan <- err
-							return nil
-						}
-
-						if body == nil || len(body) == 0 {
-							t.Errorf("test %d: expected non nil body", i)
-						}
-
-						errChan <- nil
-						return nil
-					}
-				}(),
-			)
-
-			go func(server *echo.Echo, port, i int) {
-				err := server.Start(fmt.Sprintf(":%d", webhookPort))
-				if !errors.Is(err, http.ErrServerClosed) {
-					t.Errorf("test %d: expected no error but got: %v", i, err)
-				}
-			}(webhook, webhookPort, i)
-
-			defer func() {
-				err := webhook.Shutdown(context.TODO())
-				if err != nil {
-					t.Errorf("test %d: expected no error but got: %v", i, err)
-				}
-			}()
-
-			err := contextMiddleware(tc.cfg)(tc.next)(c)
-
-			if tc.expectErr && err == nil {
-				t.Errorf("test %d: expected error but got: %v", i, err)
-			}
-
-			if !tc.expectErr && err != nil {
-				t.Errorf("test %d: expected no error but got: %v", i, err)
-			}
-
-			var httpErr HTTPError
-			isHTTPErr := errors.As(err, &httpErr)
-
-			if tc.expectHTTPErr && !isHTTPErr {
-				t.Errorf("test %d: expected HTTP error but got: %v", i, err)
-			}
-
-			if !tc.expectHTTPErr && isHTTPErr {
-				t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
-			}
-
-			if err != nil && tc.expectHTTPErr && isHTTPErr {
-				status, _ := httpErr.HTTPError()
-				if status != tc.expectHTTPStatus {
-					t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
-				}
-			}
-
-			if err != nil {
-				return
-			}
-
-			if recorder.Code != http.StatusNoContent {
-				t.Errorf("test %d: expected HTTP status code %d but got %d", i, http.StatusNoContent, recorder.Code)
-			}
-
-			err = <-errChan
-			if err != nil {
-				t.Errorf("test %d: expected no error but got: %v", i, err)
-			}
-		}()
-	}
-}
-
-func TestTimeoutMiddleware(t *testing.T) {
+func TestHardTimeoutMiddleware(t *testing.T) {
 	for i, tc := range []struct {
 		next              echo.HandlerFunc
 		timeout           time.Duration
@@ -1007,7 +478,7 @@ func TestTimeoutMiddleware(t *testing.T) {
 		c := srv.NewContext(request, recorder)
 		c.Set("logger", zap.NewNop())

-		err := timeoutMiddleware(tc.timeout)(tc.next)(c)
+		err := hardTimeoutMiddleware(tc.timeout)(tc.next)(c)

 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)
--- a/pkg/modules/api/mocks.go
+++ b/pkg/modules/api/mocks.go
@@ -0,0 +1,124 @@
+package api
+
+import (
+	"github.com/alexliesenfeld/health"
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+)
+
+// ContextMock is a helper for tests.
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+type ContextMock struct {
+	*Context
+}
+
+// SetDirPath sets the context's working directory path.
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	ctx.SetDirPath("/foo")
+func (ctx *ContextMock) SetDirPath(path string) {
+	ctx.dirPath = path
+}
+
+// DirPath returns the context's working directory path.
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	ctx.SetDirPath("/foo")
+//	dirPath := ctx.DirPath()
+func (ctx *ContextMock) DirPath() string {
+	return ctx.dirPath
+}
+
+// SetValues sets the values.
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	ctx.SetValues(map[string][]string{
+//	  "url": {
+//	    "foo",
+//	  },
+//	})
+func (ctx *ContextMock) SetValues(values map[string][]string) {
+	ctx.values = values
+}
+
+// SetFiles sets the files.
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	ctx.SetFiles(map[string]string{
+//	  "foo": "/foo",
+//	})
+func (ctx *ContextMock) SetFiles(files map[string]string) {
+	ctx.files = files
+}
+
+// SetCancelled sets if the context is cancelled or not.
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	ctx.SetCancelled(true)
+func (ctx *ContextMock) SetCancelled(cancelled bool) {
+	ctx.cancelled = cancelled
+}
+
+// OutputPaths returns the registered output paths.
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	outputPaths := ctx.OutputPaths()
+func (ctx *ContextMock) OutputPaths() []string {
+	return ctx.outputPaths
+}
+
+// SetLogger sets the logger.
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	ctx.SetLogger(zap.NewNop())
+func (ctx *ContextMock) SetLogger(logger *zap.Logger) {
+	ctx.logger = logger
+}
+
+// SetEchoContext sets the echo.Context.
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	ctx.setEchoContext(c)
+func (ctx *ContextMock) SetEchoContext(c echo.Context) {
+	ctx.Context.echoCtx = c
+}
+
+// RouterMock is a mock for the [Router] interface.
+type RouterMock struct {
+	RoutesMock func() ([]Route, error)
+}
+
+func (router *RouterMock) Routes() ([]Route, error) {
+	return router.RoutesMock()
+}
+
+// MiddlewareProviderMock is a mock for the [MiddlewareProvider] interface.
+type MiddlewareProviderMock struct {
+	MiddlewaresMock func() ([]Middleware, error)
+}
+
+func (provider *MiddlewareProviderMock) Middlewares() ([]Middleware, error) {
+	return provider.MiddlewaresMock()
+}
+
+// HealthCheckerMock is mock for the [HealthChecker] interface.
+type HealthCheckerMock struct {
+	ChecksMock func() ([]health.CheckerOption, error)
+	ReadyMock  func() error
+}
+
+func (mod *HealthCheckerMock) Checks() ([]health.CheckerOption, error) {
+	return mod.ChecksMock()
+}
+
+func (mod *HealthCheckerMock) Ready() error {
+	return mod.ReadyMock()
+}
+
+// Interface guards.
+var (
+	_ Router             = (*RouterMock)(nil)
+	_ MiddlewareProvider = (*MiddlewareProviderMock)(nil)
+	_ HealthChecker      = (*HealthCheckerMock)(nil)
+)
--- a/pkg/modules/api/mocks_test.go
+++ b/pkg/modules/api/mocks_test.go
@@ -0,0 +1,165 @@
+package api
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/alexliesenfeld/health"
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+)
+
+func TestContextMock_SetDirPath(t *testing.T) {
+	mock := &ContextMock{&Context{}}
+	mock.SetDirPath("/foo")
+
+	actual := mock.dirPath
+	expect := "/foo"
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestContextMock_DirPath(t *testing.T) {
+	mock := &ContextMock{&Context{}}
+	mock.SetDirPath("/foo")
+
+	actual := mock.DirPath()
+	expect := "/foo"
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestContextMock_SetValues(t *testing.T) {
+	mock := &ContextMock{&Context{}}
+	mock.SetValues(map[string][]string{
+		"foo": {"foo"},
+	})
+
+	actual := mock.values
+	expect := map[string][]string{
+		"foo": {"foo"},
+	}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %+v but got: %+v", expect, actual)
+	}
+}
+
+func TestContextMock_SetFiles(t *testing.T) {
+	mock := &ContextMock{&Context{}}
+	mock.SetFiles(map[string]string{
+		"foo": "/foo",
+	})
+
+	actual := mock.files
+	expect := map[string]string{
+		"foo": "/foo",
+	}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %+v but got: %+v", expect, actual)
+	}
+}
+
+func TestContextMock_SetCancelled(t *testing.T) {
+	mock := &ContextMock{&Context{}}
+	mock.SetCancelled(true)
+
+	actual := mock.cancelled
+
+	if !actual {
+		t.Errorf("expected %t but got %t", true, actual)
+	}
+}
+
+func TestContextMock_OutputPaths(t *testing.T) {
+	mock := ContextMock{
+		&Context{
+			outputPaths: []string{"/foo"},
+		},
+	}
+
+	actual := mock.OutputPaths()
+	expect := []string{"/foo"}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %+v but got: %+v", expect, actual)
+	}
+}
+
+func TestContextMock_SetLogger(t *testing.T) {
+	mock := ContextMock{&Context{}}
+
+	expect := zap.NewNop()
+	mock.SetLogger(expect)
+
+	actual := mock.logger
+
+	if actual != expect {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
+func TestContextMock_SetEchoContext(t *testing.T) {
+	mock := ContextMock{&Context{}}
+
+	expect := echo.New().NewContext(nil, nil)
+	mock.SetEchoContext(expect)
+
+	actual := mock.echoCtx
+
+	if actual != expect {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
+func TestRouterMock(t *testing.T) {
+	mock := &RouterMock{
+		RoutesMock: func() ([]Route, error) {
+			return nil, nil
+		},
+	}
+
+	_, err := mock.Routes()
+	if err != nil {
+		t.Errorf("expected no error from RouterMock.Routes, but got: %v", err)
+	}
+}
+
+func TestMiddlewareProviderMock(t *testing.T) {
+	mock := &MiddlewareProviderMock{
+		MiddlewaresMock: func() ([]Middleware, error) {
+			return nil, nil
+		},
+	}
+
+	_, err := mock.Middlewares()
+	if err != nil {
+		t.Errorf("expected no error from MiddlewareProviderMock.Middlewares, but got: %v", err)
+	}
+}
+
+func TestHealthCheckerMock(t *testing.T) {
+	mock := &HealthCheckerMock{
+		ChecksMock: func() ([]health.CheckerOption, error) {
+			return nil, nil
+		},
+		ReadyMock: func() error {
+			return nil
+		},
+	}
+
+	_, err := mock.Checks()
+	if err != nil {
+		t.Errorf("expected no error from HealthCheckerMock.Checks, but got: %v", err)
+	}
+
+	err = mock.Ready()
+	if err != nil {
+		t.Errorf("expected no error from HealthCheckerMock.Ready, but got: %v", err)
+	}
+}
--- a/pkg/modules/chromium/browser.go
+++ b/pkg/modules/chromium/browser.go
@@ -0,0 +1,355 @@
+package chromium
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/chromedp/cdproto/fetch"
+	"github.com/chromedp/cdproto/network"
+	"github.com/chromedp/cdproto/runtime"
+	"github.com/chromedp/chromedp"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+type browser interface {
+	gotenberg.Process
+	pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error
+	screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error
+}
+
+type browserArguments struct {
+	// Executor args.
+	binPath                  string
+	incognito                bool
+	allowInsecureLocalhost   bool
+	ignoreCertificateErrors  bool
+	disableWebSecurity       bool
+	allowFileAccessFromFiles bool
+	hostResolverRules        string
+	proxyServer              string
+	wsUrlReadTimeout         time.Duration
+
+	// Tasks specific.
+	allowList         *regexp.Regexp
+	denyList          *regexp.Regexp
+	clearCache        bool
+	clearCookies      bool
+	disableJavaScript bool
+}
+
+type chromiumBrowser struct {
+	initialCtx         context.Context
+	ctx                context.Context
+	cancelFunc         context.CancelFunc
+	userProfileDirPath string
+	ctxMu              sync.RWMutex
+	isStarted          atomic.Bool
+
+	arguments browserArguments
+	fs        *gotenberg.FileSystem
+}
+
+func newChromiumBrowser(arguments browserArguments) browser {
+	b := &chromiumBrowser{
+		initialCtx: context.Background(),
+		arguments:  arguments,
+		fs:         gotenberg.NewFileSystem(),
+	}
+	b.isStarted.Store(false)
+
+	return b
+}
+
+func (b *chromiumBrowser) Start(logger *zap.Logger) error {
+	if b.isStarted.Load() {
+		return errors.New("browser is already started")
+	}
+
+	debug := &debugLogger{logger: logger}
+	b.userProfileDirPath = b.fs.NewDirPath()
+
+	opts := append(chromedp.DefaultExecAllocatorOptions[:],
+		chromedp.CombinedOutput(debug),
+		chromedp.ExecPath(b.arguments.binPath),
+		chromedp.NoSandbox,
+		// See:
+		// https://github.com/gotenberg/gotenberg/issues/327
+		// https://github.com/chromedp/chromedp/issues/904
+		chromedp.DisableGPU,
+		// See:
+		// https://github.com/puppeteer/puppeteer/issues/661
+		// https://github.com/puppeteer/puppeteer/issues/2410
+		chromedp.Flag("font-render-hinting", "none"),
+		chromedp.UserDataDir(b.userProfileDirPath),
+	)
+
+	if b.arguments.incognito {
+		opts = append(opts, chromedp.Flag("incognito", b.arguments.incognito))
+	}
+
+	if b.arguments.allowInsecureLocalhost {
+		// See https://github.com/gotenberg/gotenberg/issues/488.
+		opts = append(opts, chromedp.Flag("allow-insecure-localhost", true))
+	}
+
+	if b.arguments.ignoreCertificateErrors {
+		opts = append(opts, chromedp.IgnoreCertErrors)
+	}
+
+	if b.arguments.disableWebSecurity {
+		opts = append(opts, chromedp.Flag("disable-web-security", true))
+	}
+
+	if b.arguments.allowFileAccessFromFiles {
+		// See https://github.com/gotenberg/gotenberg/issues/356.
+		opts = append(opts, chromedp.Flag("allow-file-access-from-files", true))
+	}
+
+	if b.arguments.hostResolverRules != "" {
+		// See https://github.com/gotenberg/gotenberg/issues/488.
+		opts = append(opts, chromedp.Flag("host-resolver-rules", b.arguments.hostResolverRules))
+	}
+
+	if b.arguments.proxyServer != "" {
+		// See https://github.com/gotenberg/gotenberg/issues/376.
+		opts = append(opts, chromedp.ProxyServer(b.arguments.proxyServer))
+	}
+
+	// See https://github.com/gotenberg/gotenberg/issues/524.
+	opts = append(opts, chromedp.WSURLReadTimeout(b.arguments.wsUrlReadTimeout))
+
+	allocatorCtx, allocatorCancel := chromedp.NewExecAllocator(b.initialCtx, opts...)
+	ctx, cancel := chromedp.NewContext(allocatorCtx, chromedp.WithDebugf(debug.Printf))
+
+	err := chromedp.Run(ctx)
+	if err != nil {
+		cancel()
+		allocatorCancel()
+		return fmt.Errorf("run exec allocator: %w", err)
+	}
+
+	b.ctxMu.Lock()
+	defer b.ctxMu.Unlock()
+
+	// We have to keep the context around, as we need it to create new tabs
+	// later.
+	b.ctx = ctx
+	b.cancelFunc = func() {
+		cancel()
+		allocatorCancel()
+	}
+	b.isStarted.Store(true)
+
+	return nil
+}
+
+func (b *chromiumBrowser) Stop(logger *zap.Logger) error {
+	if !b.isStarted.Load() {
+		// No big deal? Like calling cancel twice.
+		return nil
+	}
+
+	// Always remove the user profile directory created by Chromium.
+	copyUserProfileDirPath := b.userProfileDirPath
+	defer func(userProfileDirPath string) {
+		go func() {
+			// FIXME: Chromium seems to recreate the user profile directory
+			//  right after its deletion if we do not wait a certain amount
+			//  of time before re-deleting it.
+			<-time.After(10 * time.Second)
+
+			err := os.RemoveAll(userProfileDirPath)
+			if err != nil {
+				logger.Error(fmt.Sprintf("remove Chromium's user profile directory: %s", err))
+			}
+
+			logger.Debug(fmt.Sprintf("'%s' Chromium's user profile directory removed", userProfileDirPath))
+		}()
+	}(copyUserProfileDirPath)
+
+	b.ctxMu.Lock()
+	defer b.ctxMu.Unlock()
+
+	b.cancelFunc()
+	b.ctx = nil
+	b.userProfileDirPath = ""
+	b.isStarted.Store(false)
+
+	return nil
+}
+
+func (b *chromiumBrowser) Healthy(logger *zap.Logger) bool {
+	// Good to know: the supervisor does not call this method if no first start
+	// or if the process is restarting.
+
+	if !b.isStarted.Load() {
+		// Non-started browser but not restarting?
+		return false
+	}
+
+	b.ctxMu.RLock()
+	defer b.ctxMu.RUnlock()
+
+	timeoutCtx, timeoutCancel := context.WithTimeout(b.ctx, time.Duration(10)*time.Second)
+	defer timeoutCancel()
+
+	taskCtx, taskCancel := chromedp.NewContext(timeoutCtx)
+	defer taskCancel()
+
+	err := chromedp.Run(taskCtx, chromedp.Navigate("about:blank"))
+	if err != nil {
+		logger.Error(fmt.Sprintf("browser health check failed: %s", err))
+		return false
+	}
+
+	return true
+}
+
+func (b *chromiumBrowser) pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+	// Note: no error wrapping because it leaks on errors we want to display to
+	// the end user.
+	return b.do(ctx, logger, url, options.Options, chromedp.Tasks{
+		network.Enable(),
+		fetch.Enable(),
+		runtime.Enable(),
+		clearCacheActionFunc(logger, b.arguments.clearCache),
+		clearCookiesActionFunc(logger, b.arguments.clearCookies),
+		disableJavaScriptActionFunc(logger, b.arguments.disableJavaScript),
+		extraHttpHeadersActionFunc(logger, options.ExtraHttpHeaders),
+		navigateActionFunc(logger, url, options.SkipNetworkIdleEvent),
+		hideDefaultWhiteBackgroundActionFunc(logger, options.OmitBackground, options.PrintBackground),
+		forceExactColorsActionFunc(),
+		emulateMediaTypeActionFunc(logger, options.EmulatedMediaType),
+		waitDelayBeforePrintActionFunc(logger, b.arguments.disableJavaScript, options.WaitDelay),
+		waitForExpressionBeforePrintActionFunc(logger, b.arguments.disableJavaScript, options.WaitForExpression),
+		// PDF specific.
+		printToPdfActionFunc(logger, outputPath, options),
+	})
+}
+
+func (b *chromiumBrowser) screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+	// Note: no error wrapping because it leaks on errors we want to display to
+	// the end user.
+	return b.do(ctx, logger, url, options.Options, chromedp.Tasks{
+		network.Enable(),
+		fetch.Enable(),
+		runtime.Enable(),
+		clearCacheActionFunc(logger, b.arguments.clearCache),
+		clearCookiesActionFunc(logger, b.arguments.clearCookies),
+		disableJavaScriptActionFunc(logger, b.arguments.disableJavaScript),
+		extraHttpHeadersActionFunc(logger, options.ExtraHttpHeaders),
+		navigateActionFunc(logger, url, options.SkipNetworkIdleEvent),
+		hideDefaultWhiteBackgroundActionFunc(logger, options.OmitBackground, true),
+		forceExactColorsActionFunc(),
+		emulateMediaTypeActionFunc(logger, options.EmulatedMediaType),
+		waitDelayBeforePrintActionFunc(logger, b.arguments.disableJavaScript, options.WaitDelay),
+		waitForExpressionBeforePrintActionFunc(logger, b.arguments.disableJavaScript, options.WaitForExpression),
+		// Screenshot specific.
+		captureScreenshotActionFunc(logger, outputPath, options),
+	})
+}
+
+func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string, options Options, tasks chromedp.Tasks) error {
+	if !b.isStarted.Load() {
+		return errors.New("browser not started, cannot handle tasks")
+	}
+
+	// We validate the "main" URL against our allow / deny lists.
+	if !b.arguments.allowList.MatchString(url) {
+		return fmt.Errorf("'%s' does not match the expression from the allowed list: %w", url, ErrUrlNotAuthorized)
+	}
+
+	if b.arguments.denyList.String() != "" && b.arguments.denyList.MatchString(url) {
+		return fmt.Errorf("'%s' matches the expression from the denied list: %w", url, ErrUrlNotAuthorized)
+	}
+
+	deadline, ok := ctx.Deadline()
+	if !ok {
+		return errors.New("context has no deadline")
+	}
+
+	b.ctxMu.RLock()
+	defer b.ctxMu.RUnlock()
+
+	timeoutCtx, timeoutCancel := context.WithTimeout(b.ctx, time.Until(deadline))
+	defer timeoutCancel()
+
+	taskCtx, taskCancel := chromedp.NewContext(timeoutCtx)
+	defer taskCancel()
+
+	// We validate all others requests against our allow / deny lists.
+	// If a request does not pass the validation, we make it fail.
+	listenForEventRequestPaused(taskCtx, logger, b.arguments.allowList, b.arguments.denyList)
+
+	var (
+		invalidHttpStatusCode   error
+		invalidHttpStatusCodeMu sync.RWMutex
+	)
+
+	// See https://github.com/gotenberg/gotenberg/issues/613.
+	if len(options.FailOnHttpStatusCodes) != 0 {
+		listenForEventResponseReceived(taskCtx, logger, url, options.FailOnHttpStatusCodes, &invalidHttpStatusCode, &invalidHttpStatusCodeMu)
+	}
+
+	var (
+		consoleExceptions   error
+		consoleExceptionsMu sync.RWMutex
+	)
+
+	// See https://github.com/gotenberg/gotenberg/issues/262.
+	if options.FailOnConsoleExceptions && !b.arguments.disableJavaScript {
+		listenForEventExceptionThrown(taskCtx, logger, &consoleExceptions, &consoleExceptionsMu)
+	}
+
+	err := chromedp.Run(taskCtx, tasks...)
+	if err != nil {
+		errMessage := err.Error()
+
+		if strings.Contains(errMessage, "Show invalid printer settings error (-32000)") || strings.Contains(errMessage, "content area is empty (-32602)") {
+			return ErrInvalidPrinterSettings
+		}
+
+		if strings.Contains(errMessage, "Page range syntax error") {
+			return ErrPageRangesSyntaxError
+		}
+
+		if strings.Contains(errMessage, "rpcc: message too large") {
+			return ErrRpccMessageTooLarge
+		}
+
+		return fmt.Errorf("handle tasks: %w", err)
+	}
+
+	// See https://github.com/gotenberg/gotenberg/issues/613.
+	invalidHttpStatusCodeMu.RLock()
+	defer invalidHttpStatusCodeMu.RUnlock()
+
+	if invalidHttpStatusCode != nil {
+		return fmt.Errorf("%v: %w", invalidHttpStatusCode, ErrInvalidHttpStatusCode)
+	}
+
+	// See https://github.com/gotenberg/gotenberg/issues/262.
+	consoleExceptionsMu.RLock()
+	defer consoleExceptionsMu.RUnlock()
+
+	if consoleExceptions != nil {
+		return fmt.Errorf("%v: %w", consoleExceptions, ErrConsoleExceptions)
+	}
+
+	return nil
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Process = (*chromiumBrowser)(nil)
+	_ browser           = (*chromiumBrowser)(nil)
+)
--- a/pkg/modules/chromium/browser_test.go
+++ b/pkg/modules/chromium/browser_test.go
--- a/pkg/modules/chromium/chromium.go
+++ b/pkg/modules/chromium/chromium.go
@@ -4,73 +4,143 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"os"
-	"regexp"
-	"strings"
 	"time"

-	"github.com/chromedp/cdproto/fetch"
-	"github.com/chromedp/cdproto/network"
-	"github.com/chromedp/cdproto/page"
-	"github.com/chromedp/chromedp"
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/alexliesenfeld/health"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 )

 func init() {
-	gotenberg.MustRegisterModule(Chromium{})
+	gotenberg.MustRegisterModule(new(Chromium))
 }

 var (
-	// ErrURLNotAuthorized happens if a URL is not acceptable according to the
+	// ErrUrlNotAuthorized happens if a URL is not acceptable according to the
 	// allowed/denied lists.
-	ErrURLNotAuthorized = errors.New("URL not authorized")
+	ErrUrlNotAuthorized = errors.New("URL not authorized")

-	// ErrInvalidPrinterSettings happens if the Options have one or more
-	// aberrant values.
-	ErrInvalidPrinterSettings = errors.New("invalid printer settings")
+	// ErrInvalidEmulatedMediaType happens if the emulated media type is not
+	// "screen" nor "print". Empty value are allowed though.
+	ErrInvalidEmulatedMediaType = errors.New("invalid emulated media type")

-	// ErrPageRangesSyntaxError happens if the Options have an invalid page
-	// ranges.
-	ErrPageRangesSyntaxError = errors.New("page ranges syntax error")
+	// ErrInvalidEvaluationExpression happens if an evaluation expression
+	// returns an exception or undefined.
+	ErrInvalidEvaluationExpression = errors.New("invalid evaluation expression")

 	// ErrRpccMessageTooLarge happens when the messages received by
 	// ChromeDevTools are larger than 100 MB.
 	ErrRpccMessageTooLarge = errors.New("rpcc message too large")
+
+	// ErrInvalidHttpStatusCode happens when the status code from the main page
+	// matches with one of the entry in [Options.FailOnHttpStatusCodes].
+	ErrInvalidHttpStatusCode = errors.New("invalid HTTP status code")
+
+	// ErrConsoleExceptions happens when there are exceptions in the Chromium
+	// console. It also happens only if the [Options.FailOnConsoleExceptions]
+	// is set to true.
+	ErrConsoleExceptions = errors.New("console exceptions")
+
+	// PDF specific.
+
+	// ErrOmitBackgroundWithoutPrintBackground happens if
+	// PdfOptions.OmitBackground is set to true but not PdfOptions.PrintBackground.
+	ErrOmitBackgroundWithoutPrintBackground = errors.New("omit background without print background")
+
+	// ErrInvalidPrinterSettings happens if the PdfOptions have one or more
+	// aberrant values.
+	ErrInvalidPrinterSettings = errors.New("invalid printer settings")
+
+	// ErrPageRangesSyntaxError happens if the PdfOptions have an invalid page
+	// ranges.
+	ErrPageRangesSyntaxError = errors.New("page ranges syntax error")
 )

-// Chromium is a module which provides both an API and routes for converting
+// Chromium is a module which provides both an [Api] and routes for converting
 // HTML document to PDF.
 type Chromium struct {
-	binPath                 string
-	engine                  gotenberg.PDFEngine
-	userAgent               string
-	incognito               bool
-	ignoreCertificateErrors bool
-	allowList               *regexp.Regexp
-	denyList                *regexp.Regexp
-	disableRoutes           bool
+	autoStart     bool
+	disableRoutes bool
+	args          browserArguments
+
+	logger     *zap.Logger
+	browser    browser
+	supervisor gotenberg.ProcessSupervisor
+	engine     gotenberg.PdfEngine
 }

-// Options are the available options for converting HTML document to PDF.
+// Options are the common options for all conversions.
 type Options struct {
+	// SkipNetworkIdleEvent set if the conversion should wait for the
+	// "networkIdle" event, drastically improving the conversion speed. It may
+	// not be suitable for all HTML documents, as some may not be fully
+	// rendered until this event is fired.
+	// Optional.
+	SkipNetworkIdleEvent bool
+
+	// FailOnHttpStatusCodes sets if the conversion should fail if the status
+	// code from the main page matches with one of its entries.
+	// Optional.
+	FailOnHttpStatusCodes []int64
+
+	// FailOnConsoleExceptions sets if the conversion should fail if there are
+	// exceptions in the Chromium console.
+	// Optional.
+	FailOnConsoleExceptions bool
+
 	// WaitDelay is the duration to wait when loading an HTML document before
-	// converting it to PDF.
+	// converting it.
 	// Optional.
 	WaitDelay time.Duration

 	// WaitWindowStatus is the window.status value to wait for before
-	// converting an HTML document to PDF.
+	// converting an HTML document.
 	// Optional.
 	WaitWindowStatus string

-	// ExtraHTTPHeaders are the HTTP headers to send by Chromium while loading
+	// WaitForExpression is the custom JavaScript expression to wait before
+	// converting an HTML document until it returns true
+	// Optional.
+	WaitForExpression string
+
+	// ExtraHttpHeaders are the HTTP headers to send by Chromium while loading
 	// the HTML document.
 	// Optional.
-	ExtraHTTPHeaders map[string]string
+	ExtraHttpHeaders map[string]string
+
+	// EmulatedMediaType is the media type to emulate, either "screen" or
+	// "print".
+	// Optional.
+	EmulatedMediaType string
+
+	// OmitBackground hides default white background and allows generating PDFs
+	// with transparency.
+	// Optional.
+	OmitBackground bool
+}
+
+// DefaultOptions returns the default values for Options.
+func DefaultOptions() Options {
+	return Options{
+		SkipNetworkIdleEvent:    false,
+		FailOnHttpStatusCodes:   []int64{499, 599},
+		FailOnConsoleExceptions: false,
+		WaitDelay:               0,
+		WaitWindowStatus:        "",
+		WaitForExpression:       "",
+		ExtraHttpHeaders:        nil,
+		EmulatedMediaType:       "",
+		OmitBackground:          false,
+	}
+}
+
+// PdfOptions are the available options for converting an HTML document to PDF.
+type PdfOptions struct {
+	Options

 	// Landscape sets the paper orientation.
 	// Optional.
@@ -130,18 +200,16 @@ type Options struct {
 	// Optional.
 	FooterTemplate string

-	// PreferCSSPageSize defines whether to prefer page size as defined by CSS.
+	// PreferCssPageSize defines whether to prefer page size as defined by CSS.
 	// If false, the content will be scaled to fit the paper size.
 	// Optional.
-	PreferCSSPageSize bool
+	PreferCssPageSize bool
 }

-// DefaultOptions returns the default values for Options.
-func DefaultOptions() Options {
-	return Options{
-		WaitDelay:         0,
-		WaitWindowStatus:  "",
-		ExtraHTTPHeaders:  nil,
+// DefaultPdfOptions returns the default values for PdfOptions.
+func DefaultPdfOptions() PdfOptions {
+	return PdfOptions{
+		Options:           DefaultOptions(),
 		Landscape:         false,
 		PrintBackground:   false,
 		Scale:             1.0,
@@ -154,37 +222,78 @@ func DefaultOptions() Options {
 		PageRanges:        "",
 		HeaderTemplate:    "<html><head></head><body></body></html>",
 		FooterTemplate:    "<html><head></head><body></body></html>",
-		PreferCSSPageSize: false,
+		PreferCssPageSize: false,
 	}
 }

-// API helps to interact with Chromium for converting HTML documents to PDF.
-type API interface {
-	PDF(ctx context.Context, logger *zap.Logger, URL, outputPath string, options Options) error
+// ScreenshotOptions are the available options for capturing a screenshot from
+// an HTML document.
+type ScreenshotOptions struct {
+	Options
+
+	// Format is the image compression format, either "png" or "jpeg" or
+	// "webp".
+	// Optional.
+	Format string
+
+	// Quality is the compression quality from range [0..100] (jpeg only).
+	// Optional.
+	Quality int
+
+	// OptimizeForSpeed defines whether to optimize image encoding for speed,
+	// not for resulting size.
+	// Optional.
+	OptimizeForSpeed bool
 }

-// Provider is a module interface which exposes a method for creating an API
+// DefaultScreenshotOptions returns the default values for ScreenshotOptions.
+func DefaultScreenshotOptions() ScreenshotOptions {
+	return ScreenshotOptions{
+		Options:          DefaultOptions(),
+		Format:           "png",
+		Quality:          100,
+		OptimizeForSpeed: false,
+	}
+}
+
+// Api helps to interact with Chromium for converting HTML documents to PDF.
+type Api interface {
+	Pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error
+	Screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error
+}
+
+// Provider is a module interface which exposes a method for creating an [Api]
 // for other modules.
 //
 //	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
 //		provider, _ := ctx.Module(new(chromium.Provider))
-//		chromium, _ := provider.(chromium.Provider).Chromium()
+//		api, _ := provider.(chromium.Provider).Chromium()
 //	}
 type Provider interface {
-	Chromium() (API, error)
+	Chromium() (Api, error)
 }

-// Descriptor returns a Chromium's module descriptor.
-func (mod Chromium) Descriptor() gotenberg.ModuleDescriptor {
+// Descriptor returns a [Chromium]'s module descriptor.
+func (mod *Chromium) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID: "chromium",
 		FlagSet: func() *flag.FlagSet {
 			fs := flag.NewFlagSet("chromium", flag.ExitOnError)
-			fs.String("chromium-user-agent", "", "Override the default User-Agent header")
+			fs.Int64("chromium-restart-after", 0, "Number of conversions after which Chromium will automatically restart. Set to 0 to disable this feature")
+			fs.Bool("chromium-auto-start", false, "Automatically launch Chromium upon initialization if set to true; otherwise, Chromium will start at the time of the first conversion")
+			fs.Duration("chromium-start-timeout", time.Duration(20)*time.Second, "Maximum duration to wait for Chromium to start or restart")
 			fs.Bool("chromium-incognito", false, "Start Chromium with incognito mode")
+			fs.Bool("chromium-allow-insecure-localhost", false, "Ignore TLS/SSL errors on localhost")
 			fs.Bool("chromium-ignore-certificate-errors", false, "Ignore the certificate errors")
+			fs.Bool("chromium-disable-web-security", false, "Don't enforce the same-origin policy")
+			fs.Bool("chromium-allow-file-access-from-files", false, "Allow file:// URIs to read other file:// URIs")
+			fs.String("chromium-host-resolver-rules", "", "Set custom mappings to the host resolver")
+			fs.String("chromium-proxy-server", "", "Set the outbound proxy server; this switch only affects HTTP and HTTPS requests")
 			fs.String("chromium-allow-list", "", "Set the allowed URLs for Chromium using a regular expression")
 			fs.String("chromium-deny-list", "^file:///[^tmp].*", "Set the denied URLs for Chromium using a regular expression")
+			fs.Bool("chromium-clear-cache", false, "Clear Chromium cache between each conversion")
+			fs.Bool("chromium-clear-cookies", false, "Clear Chromium cookies between each conversion")
+			fs.Bool("chromium-disable-javascript", false, "Disable JavaScript")
 			fs.Bool("chromium-disable-routes", false, "Disable the routes")

 			return fs
@@ -196,9 +305,7 @@ func (mod Chromium) Descriptor() gotenberg.ModuleDescriptor {
 // Provision sets the module properties.
 func (mod *Chromium) Provision(ctx *gotenberg.Context) error {
 	flags := ctx.ParsedFlags()
-	mod.ignoreCertificateErrors = flags.MustBool("chromium-ignore-certificate-errors")
-	mod.allowList = flags.MustRegexp("chromium-allow-list")
-	mod.denyList = flags.MustRegexp("chromium-deny-list")
+	mod.autoStart = flags.MustBool("chromium-auto-start")
 	mod.disableRoutes = flags.MustBool("chromium-disable-routes")

 	binPath, ok := os.LookupEnv("CHROMIUM_BIN_PATH")
@@ -206,26 +313,56 @@ func (mod *Chromium) Provision(ctx *gotenberg.Context) error {
 		return errors.New("CHROMIUM_BIN_PATH environment variable is not set")
 	}

-	mod.binPath = binPath
+	mod.args = browserArguments{
+		binPath:                  binPath,
+		incognito:                flags.MustBool("chromium-incognito"),
+		allowInsecureLocalhost:   flags.MustBool("chromium-allow-insecure-localhost"),
+		ignoreCertificateErrors:  flags.MustBool("chromium-ignore-certificate-errors"),
+		disableWebSecurity:       flags.MustBool("chromium-disable-web-security"),
+		allowFileAccessFromFiles: flags.MustBool("chromium-allow-file-access-from-files"),
+		hostResolverRules:        flags.MustString("chromium-host-resolver-rules"),
+		proxyServer:              flags.MustString("chromium-proxy-server"),
+		wsUrlReadTimeout:         flags.MustDuration("chromium-start-timeout"),

-	provider, err := ctx.Module(new(gotenberg.PDFEngineProvider))
+		allowList:         flags.MustRegexp("chromium-allow-list"),
+		denyList:          flags.MustRegexp("chromium-deny-list"),
+		clearCache:        flags.MustBool("chromium-clear-cache"),
+		clearCookies:      flags.MustBool("chromium-clear-cookies"),
+		disableJavaScript: flags.MustBool("chromium-disable-javascript"),
+	}
+
+	// Logger.
+	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
+	if err != nil {
+		return fmt.Errorf("get logger provider: %w", err)
+	}
+	logger, err := loggerProvider.(gotenberg.LoggerProvider).Logger(mod)
+	if err != nil {
+		return fmt.Errorf("get logger: %w", err)
+	}
+	mod.logger = logger.Named("browser")
+
+	// Process.
+	mod.browser = newChromiumBrowser(mod.args)
+	mod.supervisor = gotenberg.NewProcessSupervisor(mod.logger, mod.browser, flags.MustInt64("chromium-restart-after"))
+
+	// PDF Engine.
+	provider, err := ctx.Module(new(gotenberg.PdfEngineProvider))
 	if err != nil {
 		return fmt.Errorf("get PDF engine provider: %w", err)
 	}
-
-	engine, err := provider.(gotenberg.PDFEngineProvider).PDFEngine()
+	engine, err := provider.(gotenberg.PdfEngineProvider).PdfEngine()
 	if err != nil {
 		return fmt.Errorf("get PDF engine: %w", err)
 	}
-
 	mod.engine = engine

 	return nil
 }

 // Validate validates the module properties.
-func (mod Chromium) Validate() error {
-	_, err := os.Stat(mod.binPath)
+func (mod *Chromium) Validate() error {
+	_, err := os.Stat(mod.args.binPath)
 	if os.IsNotExist(err) {
 		return fmt.Errorf("chromium binary path does not exist: %w", err)
 	}
@@ -233,252 +370,158 @@ func (mod Chromium) Validate() error {
 	return nil
 }

-// Chromium returns an API for interacting with Chromium for converting HTML
-// documents to PDF.
-func (mod Chromium) Chromium() (API, error) {
-	return mod, nil
-}
-
-// Routes returns the API routes.
-func (mod Chromium) Routes() ([]api.MultipartFormDataRoute, error) {
-	if mod.disableRoutes {
-		return nil, nil
+// Start does nothing if auto-start is not enabled. Otherwise, it starts a
+// browser instance.
+func (mod *Chromium) Start() error {
+	if !mod.autoStart {
+		return nil
 	}

-	return []api.MultipartFormDataRoute{
-		convertURLRoute(mod, mod.engine),
-		convertHTMLRoute(mod, mod.engine),
-		convertMarkdownRoute(mod, mod.engine),
-	}, nil
-}
-
-// PDF converts a URL to PDF. It creates a dedicated Chromium instance.
-// Substantial calls to this method may increase CPU and memory usage
-// drastically. In such a scenario, the given context may also be done before
-// the end of the conversion.
-func (mod Chromium) PDF(ctx context.Context, logger *zap.Logger, URL, outputPath string, options Options) error {
-	userProfileDirPath := gotenberg.NewDirPath()
-
-	args := append(chromedp.DefaultExecAllocatorOptions[:],
-		chromedp.ExecPath(mod.binPath),
-		chromedp.NoSandbox,
-		// See:
-		// https://github.com/puppeteer/puppeteer/issues/661
-		// https://github.com/puppeteer/puppeteer/issues/2410
-		chromedp.Flag("font-render-hinting", "none"),
-		chromedp.UserDataDir(userProfileDirPath),
-	)
-
-	if mod.userAgent != "" {
-		args = append(args, chromedp.UserAgent(mod.userAgent))
-	}
-
-	if mod.incognito {
-		args = append(args, chromedp.Flag("incognito", mod.incognito))
-	}
-
-	if mod.ignoreCertificateErrors {
-		args = append(args, chromedp.IgnoreCertErrors)
-	}
-
-	allocatorCtx, cancel := chromedp.NewExecAllocator(ctx, args...)
-	defer cancel()
-
-	taskCtx, cancel := chromedp.NewContext(allocatorCtx)
-	defer cancel()
-
-	// We validate the "main" URL against our allow / deny lists.
-	if !mod.allowList.MatchString(URL) {
-		return fmt.Errorf("'%s' does not match the expression from the allowed list: %w", URL, ErrURLNotAuthorized)
-	}
-
-	if mod.denyList.String() != "" && mod.denyList.MatchString(URL) {
-		return fmt.Errorf("'%s' matches the expression from the denied list: %w", URL, ErrURLNotAuthorized)
-	}
-
-	printToPDF := func(URL string, options Options, result *[]byte) chromedp.Tasks {
-		// We validate the underlying requests against our allow / deny lists.
-		// If a request does not pass the validation, we make it fail.
-		listenForEventRequestPaused(taskCtx, logger, mod.allowList, mod.denyList)
-
-		return chromedp.Tasks{
-			network.Enable(),
-			fetch.Enable(),
-			chromedp.ActionFunc(func(ctx context.Context) error {
-				if len(options.ExtraHTTPHeaders) == 0 {
-					logger.Debug("no extra HTTP headers")
-
-					return nil
-				}
-
-				logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", options.ExtraHTTPHeaders))
-
-				headers := make(network.Headers, len(options.ExtraHTTPHeaders))
-				for key, value := range options.ExtraHTTPHeaders {
-					headers[key] = value
-				}
-
-				err := network.SetExtraHTTPHeaders(headers).Do(ctx)
-				if err == nil {
-					return nil
-				}
-
-				return fmt.Errorf("set extra HTTP headers: %w", err)
-			}),
-			chromedp.ActionFunc(func(ctx context.Context) error {
-				logger.Debug(fmt.Sprintf("navigate to '%s'", URL))
-
-				_, _, _, err := page.Navigate(URL).Do(ctx)
-				if err != nil {
-					return fmt.Errorf("navigate to '%s': %w", URL, err)
-				}
-
-				err = runBatch(
-					ctx,
-					waitForEventDomContentEventFired(ctx, logger),
-					waitForEventLoadEventFired(ctx, logger),
-					waitForEventNetworkIdle(ctx, logger),
-					waitForEventLoadingFinished(ctx, logger),
-				)
-
-				if err == nil {
-					return nil
-				}
-
-				return fmt.Errorf("wait for events: %w", err)
-			}),
-			chromedp.ActionFunc(func(ctx context.Context) error {
-				if options.WaitDelay > 0 {
-					// We wait for a given amount of time so that JavaScript
-					// scripts have a chance to finish before printing the page
-					// to PDF.
-					logger.Debug(fmt.Sprintf("wait '%s' before print", options.WaitDelay))
-
-					select {
-					case <-ctx.Done():
-						return fmt.Errorf("wait delay: %w", ctx.Err())
-					case <-time.After(options.WaitDelay):
-						return nil
-					}
-				}
-
-				return nil
-			}),
-			chromedp.ActionFunc(func(ctx context.Context) error {
-				if options.WaitWindowStatus == "" {
-					return nil
-				}
-
-				// We wait until the evaluation of
-				// "window.status === options.WaitWindowStatus" is true or
-				// until the context is done.
-				logger.Debug(fmt.Sprintf("wait for window.status === '%s' before print", options.WaitWindowStatus))
-
-				ticker := time.NewTicker(time.Duration(100) * time.Millisecond)
-
-				for {
-					select {
-					case <-ctx.Done():
-						ticker.Stop()
-
-						return fmt.Errorf("wait for window.status === '%s': %w", options.WaitWindowStatus, ctx.Err())
-					case <-ticker.C:
-						var ok bool
-
-						evaluate := chromedp.Evaluate(fmt.Sprintf("window.status === '%s'", options.WaitWindowStatus), &ok)
-						err := evaluate.Do(ctx)
-
-						if err != nil {
-							return fmt.Errorf("evaluate: %w", err)
-						}
-
-						if ok {
-							ticker.Stop()
-
-							return nil
-						}
-
-						continue
-					}
-				}
-			}),
-			chromedp.ActionFunc(func(ctx context.Context) error {
-				printToPDF := page.PrintToPDF().
-					WithLandscape(options.Landscape).
-					WithPrintBackground(options.PrintBackground).
-					WithScale(options.Scale).
-					WithPaperWidth(options.PaperWidth).
-					WithPaperHeight(options.PaperHeight).
-					WithMarginTop(options.MarginTop).
-					WithMarginBottom(options.MarginBottom).
-					WithMarginLeft(options.MarginLeft).
-					WithMarginRight(options.MarginRight).
-					WithIgnoreInvalidPageRanges(false).
-					WithPageRanges(options.PageRanges).
-					WithDisplayHeaderFooter(true).
-					WithHeaderTemplate(options.HeaderTemplate).
-					WithFooterTemplate(options.FooterTemplate).
-					WithPreferCSSPageSize(options.PreferCSSPageSize)
-
-				logger.Debug(fmt.Sprintf("print to PDF with: %+v", printToPDF))
-
-				data, _, err := printToPDF.Do(ctx)
-				if err != nil {
-					return fmt.Errorf("print to PDF: %w", err)
-				}
-
-				*result = data
-
-				return nil
-			}),
-		}
-	}
-
-	var buffer []byte
-	err := chromedp.Run(taskCtx, printToPDF(URL, options, &buffer))
-
-	// Always remove the user profile directory created by Chromium.
-	go func() {
-		logger.Debug(fmt.Sprintf("remove user profile directory '%s'", userProfileDirPath))
-
-		err := os.RemoveAll(userProfileDirPath)
-		if err != nil {
-			logger.Error(fmt.Sprintf("remove user profile directory: %s", err))
-		}
-	}()
-
+	err := mod.supervisor.Launch()
 	if err != nil {
-		errMessage := err.Error()
-
-		if strings.Contains(errMessage, "Show invalid printer settings error (-32000)") {
-			return ErrInvalidPrinterSettings
-		}
-
-		if strings.Contains(errMessage, "Page range syntax error") {
-			return ErrPageRangesSyntaxError
-		}
-
-		if strings.Contains(errMessage, "rpcc: message too large") {
-			return ErrRpccMessageTooLarge
-		}
-
-		return fmt.Errorf("chromium PDF: %w", err)
-	}
-
-	err = ioutil.WriteFile(outputPath, buffer, 0600)
-	if err != nil {
-		return fmt.Errorf("write result to output path: %w", err)
+		return fmt.Errorf("launch supervisor: %w", err)
 	}

 	return nil
 }

+// StartupMessage returns a custom startup message.
+func (mod *Chromium) StartupMessage() string {
+	if !mod.autoStart {
+		return "Chromium ready to start"
+	}
+
+	return "Chromium automatically started"
+}
+
+// Stop stops the current browser instance.
+func (mod *Chromium) Stop(ctx context.Context) error {
+	// Block until the context is done so that other module may gracefully stop
+	// before we do a shutdown.
+	mod.logger.Debug("wait for the end of grace duration")
+
+	<-ctx.Done()
+
+	err := mod.supervisor.Shutdown()
+	if err == nil {
+		return nil
+	}
+
+	return fmt.Errorf("stop Chromium: %w", err)
+}
+
+// Metrics returns the metrics.
+func (mod *Chromium) Metrics() ([]gotenberg.Metric, error) {
+	return []gotenberg.Metric{
+		{
+			Name:        "chromium_requests_queue_size",
+			Description: "Current number of Chromium conversion requests waiting to be treated.",
+			Read: func() float64 {
+				return float64(mod.supervisor.ReqQueueSize())
+			},
+		},
+		{
+			Name:        "chromium_restarts_count",
+			Description: "Current number of Chromium restarts.",
+			Read: func() float64 {
+				return float64(mod.supervisor.RestartsCount())
+			},
+		},
+	}, nil
+}
+
+// Checks adds a health check that verifies if Chromium is healthy.
+func (mod *Chromium) Checks() ([]health.CheckerOption, error) {
+	return []health.CheckerOption{
+		health.WithCheck(health.Check{
+			Name: "chromium",
+			Check: func(_ context.Context) error {
+				if mod.supervisor.Healthy() {
+					return nil
+				}
+
+				return errors.New("Chromium is unhealthy")
+			},
+		}),
+	}, nil
+}
+
+// Ready returns no error if the module is ready.
+func (mod *Chromium) Ready() error {
+	if !mod.autoStart {
+		return nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), mod.args.wsUrlReadTimeout)
+	defer cancel()
+
+	ticker := time.NewTicker(time.Duration(100) * time.Millisecond)
+
+	for {
+		select {
+		case <-ctx.Done():
+			ticker.Stop()
+			return fmt.Errorf("context done while waiting for Chromium to be ready: %w", ctx.Err())
+		case <-ticker.C:
+			ok := mod.browser.Healthy(mod.logger)
+			if ok {
+				ticker.Stop()
+				return nil
+			}
+
+			continue
+		}
+	}
+}
+
+// Chromium returns an [Api] for interacting with Chromium for converting HTML
+// documents to PDF.
+func (mod *Chromium) Chromium() (Api, error) {
+	return mod, nil
+}
+
+// Routes returns the HTTP routes.
+func (mod *Chromium) Routes() ([]api.Route, error) {
+	if mod.disableRoutes {
+		return nil, nil
+	}
+
+	return []api.Route{
+		convertUrlRoute(mod, mod.engine),
+		screenshotUrlRoute(mod),
+		convertHtmlRoute(mod, mod.engine),
+		screenshotHtmlRoute(mod),
+		convertMarkdownRoute(mod, mod.engine),
+		screenshotMarkdownRoute(mod),
+	}, nil
+}
+
+// Pdf converts a URL to PDF.
+func (mod *Chromium) Pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+	// Note: no error wrapping because it leaks on errors we want to display to
+	// the end user.
+	return mod.supervisor.Run(ctx, logger, func() error {
+		return mod.browser.pdf(ctx, logger, url, outputPath, options)
+	})
+}
+
+func (mod *Chromium) Screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+	// Note: no error wrapping because it leaks on errors we want to display to
+	// the end user.
+	return mod.supervisor.Run(ctx, logger, func() error {
+		return mod.browser.screenshot(ctx, logger, url, outputPath, options)
+	})
+}
+
 // Interface guards.
 var (
-	_ gotenberg.Module            = (*Chromium)(nil)
-	_ gotenberg.Provisioner       = (*Chromium)(nil)
-	_ gotenberg.Validator         = (*Chromium)(nil)
-	_ api.MultipartFormDataRouter = (*Chromium)(nil)
-	_ API                         = (*Chromium)(nil)
-	_ Provider                    = (*Chromium)(nil)
+	_ gotenberg.Module          = (*Chromium)(nil)
+	_ gotenberg.Provisioner     = (*Chromium)(nil)
+	_ gotenberg.Validator       = (*Chromium)(nil)
+	_ gotenberg.App             = (*Chromium)(nil)
+	_ gotenberg.MetricsProvider = (*Chromium)(nil)
+	_ api.HealthChecker         = (*Chromium)(nil)
+	_ api.Router                = (*Chromium)(nil)
+	_ Api                       = (*Chromium)(nil)
+	_ Provider                  = (*Chromium)(nil)
 )
--- a/pkg/modules/chromium/chromium_test.go
+++ b/pkg/modules/chromium/chromium_test.go
@@ -3,58 +3,20 @@ package chromium
 import (
 	"context"
 	"errors"
-	"io/ioutil"
 	"os"
 	"reflect"
-	"regexp"
 	"testing"
 	"time"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/alexliesenfeld/health"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

-type ProtoModule struct {
-	descriptor func() gotenberg.ModuleDescriptor
-}
-
-func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
-	return mod.descriptor()
-}
-
-type ProtoAPI struct {
-	pdf func(_ context.Context, _ *zap.Logger, _, _ string, _ Options) error
-}
-
-func (mod ProtoAPI) PDF(ctx context.Context, logger *zap.Logger, URL, outputPath string, options Options) error {
-	return mod.pdf(ctx, logger, URL, outputPath, options)
-}
-
-type ProtoPDFEngineProvider struct {
-	ProtoModule
-	pdfEngine func() (gotenberg.PDFEngine, error)
-}
-
-func (mod ProtoPDFEngineProvider) PDFEngine() (gotenberg.PDFEngine, error) {
-	return mod.pdfEngine()
-}
-
-type ProtoPDFEngine struct {
-	merge   func(_ context.Context, _ *zap.Logger, _ []string, _ string) error
-	convert func(_ context.Context, _ *zap.Logger, _, _, _ string) error
-}
-
-func (mod ProtoPDFEngine) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-	return mod.merge(ctx, logger, inputPaths, outputPath)
-}
-
-func (mod ProtoPDFEngine) Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error {
-	return mod.convert(ctx, logger, format, inputPath, outputPath)
-}
-
 func TestDefaultOptions(t *testing.T) {
-	actual := DefaultOptions()
-	notExpect := Options{}
+	actual := DefaultPdfOptions()
+	notExpect := PdfOptions{}

 	if reflect.DeepEqual(actual, notExpect) {
 		t.Errorf("expected %v and got identical %v", actual, notExpect)
@@ -62,7 +24,7 @@ func TestDefaultOptions(t *testing.T) {
 }

 func TestChromium_Descriptor(t *testing.T) {
-	descriptor := Chromium{}.Descriptor()
+	descriptor := new(Chromium).Descriptor()

 	actual := reflect.TypeOf(descriptor.New())
 	expect := reflect.TypeOf(new(Chromium))
@@ -73,11 +35,13 @@ func TestChromium_Descriptor(t *testing.T) {
 }

 func TestChromium_Provision(t *testing.T) {
-	for i, tc := range []struct {
-		ctx       *gotenberg.Context
-		expectErr bool
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *gotenberg.Context
+		expectError bool
 	}{
 		{
+			scenario: "no logger provider",
 			ctx: func() *gotenberg.Context {
 				return gotenberg.NewContext(
 					gotenberg.ParsedFlags{
@@ -86,15 +50,19 @@ func TestChromium_Provision(t *testing.T) {
 					[]gotenberg.ModuleDescriptor{},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
+			scenario: "no logger from logger provider",
 			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoPDFEngineProvider }{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.LoggerProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
 				}
-				mod.pdfEngine = func() (gotenberg.PDFEngine, error) {
+				mod.LoggerMock = func(mod gotenberg.Module) (*zap.Logger, error) {
 					return nil, errors.New("foo")
 				}

@@ -107,16 +75,78 @@ func TestChromium_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
+			scenario: "no PDF engine provider",
 			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoPDFEngineProvider }{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.LoggerProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
 				}
-				mod.pdfEngine = func() (gotenberg.PDFEngine, error) {
-					return struct{ ProtoPDFEngine }{}, nil
+				mod.LoggerMock = func(mod gotenberg.Module) (*zap.Logger, error) {
+					return zap.NewNop(), nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Chromium).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "no PDF engine from PDF engine provider",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.LoggerProviderMock
+					gotenberg.PdfEngineProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
+				}
+				mod.LoggerMock = func(mod gotenberg.Module) (*zap.Logger, error) {
+					return zap.NewNop(), nil
+				}
+				mod.PdfEngineMock = func() (gotenberg.PdfEngine, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Chromium).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "provision success",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.LoggerProviderMock
+					gotenberg.PdfEngineProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
+				}
+				mod.LoggerMock = func(mod gotenberg.Module) (*zap.Logger, error) {
+					return zap.NewNop(), nil
+				}
+				mod.PdfEngineMock = func() (gotenberg.PdfEngine, error) {
+					return new(gotenberg.PdfEngineMock), nil
 				}

 				return gotenberg.NewContext(
@@ -130,46 +160,287 @@ func TestChromium_Provision(t *testing.T) {
 			}(),
 		},
 	} {
-		mod := new(Chromium)
-		err := mod.Provision(tc.ctx)
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			err := mod.Provision(tc.ctx)

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

 func TestChromium_Validate(t *testing.T) {
-	for i, tc := range []struct {
-		binPath   string
-		expectErr bool
+	for _, tc := range []struct {
+		scenario    string
+		binPath     string
+		expectError bool
 	}{
 		{
-			expectErr: true,
+			scenario:    "empty bin path",
+			binPath:     "",
+			expectError: true,
 		},
 		{
-			binPath:   "/foo",
-			expectErr: true,
+			scenario:    "bin path does not exist",
+			binPath:     "/foo",
+			expectError: true,
 		},
 		{
-			binPath: os.Getenv("CHROMIUM_BIN_PATH"),
+			scenario:    "validate success",
+			binPath:     os.Getenv("CHROMIUM_BIN_PATH"),
+			expectError: false,
 		},
 	} {
-		mod := new(Chromium)
-		mod.binPath = tc.binPath
-		err := mod.Validate()
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.args = browserArguments{
+				binPath: tc.binPath,
+			}
+			err := mod.Validate()

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestChromium_Start(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		autoStart   bool
+		supervisor  *gotenberg.ProcessSupervisorMock
+		expectError bool
+	}{
+		{
+			scenario:    "no auto-start",
+			autoStart:   false,
+			expectError: false,
+		},
+		{
+			scenario:  "auto-start success",
+			autoStart: true,
+			supervisor: &gotenberg.ProcessSupervisorMock{LaunchMock: func() error {
+				return nil
+			}},
+			expectError: false,
+		},
+		{
+			scenario:  "auto-start failed",
+			autoStart: true,
+			supervisor: &gotenberg.ProcessSupervisorMock{LaunchMock: func() error {
+				return errors.New("foo")
+			}},
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.autoStart = tc.autoStart
+			mod.supervisor = tc.supervisor
+
+			err := mod.Start()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestChromium_StartupMessage(t *testing.T) {
+	mod := new(Chromium)
+
+	mod.autoStart = true
+	autoStartMsg := mod.StartupMessage()
+
+	mod.autoStart = false
+	noAutoStartMsg := mod.StartupMessage()
+
+	if autoStartMsg == noAutoStartMsg {
+		t.Errorf("expected differrent startup messages based on auto start, but got '%s'", autoStartMsg)
+	}
+}
+
+func TestChromium_Stop(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		supervisor  *gotenberg.ProcessSupervisorMock
+		expectError bool
+	}{
+		{
+			scenario: "stop success",
+			supervisor: &gotenberg.ProcessSupervisorMock{ShutdownMock: func() error {
+				return nil
+			}},
+			expectError: false,
+		},
+		{
+			scenario: "stop failed",
+			supervisor: &gotenberg.ProcessSupervisorMock{ShutdownMock: func() error {
+				return errors.New("foo")
+			}},
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.logger = zap.NewNop()
+			mod.supervisor = tc.supervisor
+
+			ctx, cancel := context.WithTimeout(context.Background(), 0*time.Second)
+			cancel()
+
+			err := mod.Stop(ctx)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestChromium_Metrics(t *testing.T) {
+	mod := new(Chromium)
+	mod.supervisor = &gotenberg.ProcessSupervisorMock{
+		ReqQueueSizeMock: func() int64 {
+			return 10
+		},
+		RestartsCountMock: func() int64 {
+			return 0
+		},
+	}
+
+	metrics, err := mod.Metrics()
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	if len(metrics) != 2 {
+		t.Fatalf("expected %d metrics, but got %d", 2, len(metrics))
+	}
+
+	actual := metrics[0].Read()
+	if actual != float64(10) {
+		t.Errorf("expected %f for chromium_requests_queue_size, but got %f", float64(10), actual)
+	}
+
+	actual = metrics[1].Read()
+	if actual != float64(0) {
+		t.Errorf("expected %f for chromium_restarts_count, but got %f", float64(0), actual)
+	}
+}
+
+func TestChromium_Checks(t *testing.T) {
+	for _, tc := range []struct {
+		scenario                 string
+		supervisor               gotenberg.ProcessSupervisor
+		expectAvailabilityStatus health.AvailabilityStatus
+	}{
+		{
+			scenario: "healthy module",
+			supervisor: &gotenberg.ProcessSupervisorMock{HealthyMock: func() bool {
+				return true
+			}},
+			expectAvailabilityStatus: health.StatusUp,
+		},
+		{
+			scenario: "unhealthy module",
+			supervisor: &gotenberg.ProcessSupervisorMock{HealthyMock: func() bool {
+				return false
+			}},
+			expectAvailabilityStatus: health.StatusDown,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.supervisor = tc.supervisor
+
+			checks, err := mod.Checks()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			checker := health.NewChecker(checks...)
+			result := checker.Check(context.Background())
+
+			if result.Status != tc.expectAvailabilityStatus {
+				t.Errorf("expected '%s' as availability status, but got '%s'", tc.expectAvailabilityStatus, result.Status)
+			}
+		})
+	}
+}
+
+func TestChromium_Ready(t *testing.T) {
+	for _, tc := range []struct {
+		scenario     string
+		autoStart    bool
+		startTimeout time.Duration
+		browser      browser
+		expectError  bool
+	}{
+		{
+			scenario:     "no auto-start",
+			autoStart:    false,
+			startTimeout: time.Duration(30) * time.Second,
+			browser: &browserMock{ProcessMock: gotenberg.ProcessMock{HealthyMock: func(logger *zap.Logger) bool {
+				return false
+			}}},
+			expectError: false,
+		},
+		{
+			scenario:     "auto-start: context done",
+			autoStart:    true,
+			startTimeout: time.Duration(200) * time.Millisecond,
+			browser: &browserMock{ProcessMock: gotenberg.ProcessMock{HealthyMock: func(logger *zap.Logger) bool {
+				return false
+			}}},
+			expectError: true,
+		},
+		{
+			scenario:     "auto-start success",
+			autoStart:    true,
+			startTimeout: time.Duration(30) * time.Second,
+			browser: &browserMock{ProcessMock: gotenberg.ProcessMock{HealthyMock: func(logger *zap.Logger) bool {
+				return true
+			}}},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.autoStart = tc.autoStart
+			mod.args = browserArguments{wsUrlReadTimeout: tc.startTimeout}
+			mod.browser = tc.browser
+
+			err := mod.Ready()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

@@ -183,191 +454,118 @@ func TestChromium_Chromium(t *testing.T) {
 }

 func TestChromium_Routes(t *testing.T) {
-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario      string
 		expectRoutes  int
 		disableRoutes bool
 	}{
 		{
-			expectRoutes: 3,
+			scenario:      "routes not disabled",
+			expectRoutes:  6,
+			disableRoutes: false,
 		},
 		{
+			scenario:      "routes disabled",
+			expectRoutes:  0,
 			disableRoutes: true,
 		},
 	} {
-		mod := new(Chromium)
-		mod.disableRoutes = tc.disableRoutes
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.disableRoutes = tc.disableRoutes

-		routes, err := mod.Routes()
-		if err != nil {
-			t.Fatalf("test %d: expected no error but got: %v", i, err)
-		}
+			routes, err := mod.Routes()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if tc.expectRoutes != len(routes) {
-			t.Errorf("test %d: expected %d routes but got %d", i, tc.expectRoutes, len(routes))
-		}
+			if tc.expectRoutes != len(routes) {
+				t.Errorf("expected %d routes but got %d", tc.expectRoutes, len(routes))
+			}
+		})
 	}
 }

-func TestChromium_PDF(t *testing.T) {
-	for i, tc := range []struct {
-		timeout                 time.Duration
-		cancel                  context.CancelFunc
-		URL                     string
-		options                 Options
-		userAgent               string
-		incognito               bool
-		ignoreCertificateErrors bool
-		allowList               *regexp.Regexp
-		denyList                *regexp.Regexp
-		expectErr               bool
+func TestChromium_Pdf(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		supervisor  gotenberg.ProcessSupervisor
+		browser     browser
+		expectError bool
 	}{
 		{
-			URL:       "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			allowList: regexp.MustCompile("file:///tmp/*"),
-			expectErr: true,
+			scenario: "PDF task success",
+			browser: &browserMock{pdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return nil
+			}},
+			expectError: false,
 		},
 		{
-			URL:       "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			denyList:  regexp.MustCompile("file:///tests/*"),
-			expectErr: true,
-		},
-		{
-			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				ExtraHTTPHeaders: map[string]string{
-					"foo": "bar",
-				},
-			},
-		},
-		{
-			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				WaitDelay: time.Duration(1) * time.Nanosecond,
-			},
-		},
-		{
-			timeout: time.Duration(3) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample2/index.html",
-			options: Options{
-				WaitWindowStatus: "foo",
-			},
-			expectErr: true,
-		},
-		{
-			timeout: time.Duration(3) * time.Second,
-			URL:     "file:///tests/test/testdata/chromium/html/sample2/index.html",
-			options: Options{
-				WaitWindowStatus: "ready",
-			},
-		},
-		{
-			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				MarginBottom: 100,
-			},
-			expectErr: true,
-		},
-		{
-			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				PageRanges: "foo",
-			},
-			expectErr: true,
-		},
-		{
-			URL:                     "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			userAgent:               "foo",
-			incognito:               true,
-			ignoreCertificateErrors: true,
-		},
-		{
-			URL: "file:///tests/test/testdata/chromium/html/sample1/index.html",
-		},
-		{
-			URL:       "file:///tests/test/testdata/chromium/html/sample3/index.html",
-			allowList: regexp.MustCompile("file:///tests/*"),
-		},
-		{
-			URL:      "file:///tests/test/testdata/chromium/html/sample3/index.html",
-			denyList: regexp.MustCompile("file:///etc/*"),
-		},
-		{
-			URL: "file:///tests/test/testdata/chromium/html/sample4/index.html",
-			options: Options{
-				HeaderTemplate: func() string {
-					b, err := ioutil.ReadFile("/tests/test/testdata/chromium/url/sample2/header.html")
-					if err != nil {
-						t.Fatalf("expected no error but got: %v", err)
-					}
-
-					return string(b)
-				}(),
-				FooterTemplate: func() string {
-					b, err := ioutil.ReadFile("/tests/test/testdata/chromium/url/sample2/footer.html")
-					if err != nil {
-						t.Fatalf("expected no error but got: %v", err)
-					}
-
-					return string(b)
-				}(),
-			},
+			scenario: "PDF task error",
+			browser: &browserMock{pdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return errors.New("PDF task error")
+			}},
+			expectError: true,
 		},
 	} {
-		func() {
+		t.Run(tc.scenario, func(t *testing.T) {
 			mod := new(Chromium)
-			mod.binPath = os.Getenv("CHROMIUM_BIN_PATH")
-			mod.userAgent = tc.userAgent
-			mod.incognito = tc.incognito
-			mod.ignoreCertificateErrors = tc.ignoreCertificateErrors
+			mod.supervisor = &gotenberg.ProcessSupervisorMock{RunMock: func(ctx context.Context, logger *zap.Logger, task func() error) error {
+				return task()
+			}}
+			mod.browser = tc.browser

-			if tc.allowList == nil {
-				tc.allowList = regexp.MustCompile("")
+			err := mod.Pdf(context.Background(), zap.NewNop(), "", "", PdfOptions{})
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
 			}

-			if tc.denyList == nil {
-				tc.denyList = regexp.MustCompile("")
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
 			}
-
-			mod.allowList = tc.allowList
-			mod.denyList = tc.denyList
-
-			outputDir, err := gotenberg.MkdirAll()
-			if err != nil {
-				t.Fatalf("test %d: expected error but got: %v", i, err)
-			}
-
-			defer func() {
-				err := os.RemoveAll(outputDir)
-				if err != nil {
-					t.Fatalf("test %d: expected no error but got: %v", i, err)
-				}
-			}()
-
-			if tc.timeout == 0 {
-				err = mod.PDF(context.Background(), zap.NewNop(), tc.URL, outputDir+"/foo.pdf", tc.options)
-			} else {
-				ctx, cancel := context.WithTimeout(context.Background(), tc.timeout)
-				defer cancel()
-
-				err = mod.PDF(ctx, zap.NewNop(), tc.URL, outputDir+"/foo.pdf", tc.options)
-			}
-
-			if tc.expectErr && err == nil {
-				t.Errorf("test %d: expected error but got: %v", i, err)
-			}
-
-			if !tc.expectErr && err != nil {
-				t.Errorf("test %d: expected no error but got: %v", i, err)
-			}
-		}()
+		})
 	}
 }

-// Interface guards.
-var (
-	_ gotenberg.Module            = (*ProtoModule)(nil)
-	_ API                         = (*ProtoAPI)(nil)
-	_ gotenberg.PDFEngineProvider = (*ProtoPDFEngineProvider)(nil)
-	_ gotenberg.Module            = (*ProtoPDFEngineProvider)(nil)
-	_ gotenberg.PDFEngine         = (*ProtoPDFEngine)(nil)
-)
+func TestChromium_Screenshot(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		supervisor  gotenberg.ProcessSupervisor
+		browser     browser
+		expectError bool
+	}{
+		{
+			scenario: "Screenshot task success",
+			browser: &browserMock{screenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+				return nil
+			}},
+			expectError: false,
+		},
+		{
+			scenario: "Screenshot task error",
+			browser: &browserMock{screenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+				return errors.New("screenshot task error")
+			}},
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Chromium)
+			mod.supervisor = &gotenberg.ProcessSupervisorMock{RunMock: func(ctx context.Context, logger *zap.Logger, task func() error) error {
+				return task()
+			}}
+			mod.browser = tc.browser
+
+			err := mod.Screenshot(context.Background(), zap.NewNop(), "", "", ScreenshotOptions{})
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
--- a/pkg/modules/chromium/debug.go
+++ b/pkg/modules/chromium/debug.go
@@ -0,0 +1,31 @@
+package chromium
+
+import (
+	"fmt"
+	"io"
+
+	"go.uber.org/zap"
+)
+
+// debugLogger is wrapper around a [zap.Logger] which is used for debugging
+// Chromium.
+type debugLogger struct {
+	logger *zap.Logger
+}
+
+// Write logs the bytes in a debug message.
+func (debug *debugLogger) Write(p []byte) (n int, err error) {
+	debug.logger.Debug(string(p))
+
+	return len(p), nil
+}
+
+// Printf logs a debug message.
+func (debug *debugLogger) Printf(format string, v ...interface{}) {
+	debug.logger.Debug(fmt.Sprintf(format, v...))
+}
+
+// Interface guards.
+var (
+	_ io.Writer = (*debugLogger)(nil)
+)
--- a/pkg/modules/chromium/debug_test.go
+++ b/pkg/modules/chromium/debug_test.go
@@ -0,0 +1,24 @@
+package chromium
+
+import (
+	"testing"
+
+	"go.uber.org/zap"
+)
+
+func TestDebugLogger_Write(t *testing.T) {
+	actual, err := (&debugLogger{logger: zap.NewNop()}).Write([]byte("foo"))
+	expected := len([]byte("foo"))
+
+	if actual != expected {
+		t.Errorf("expected %d but got %d", expected, actual)
+	}
+
+	if err != nil {
+		t.Errorf("expected not error but got: %v", err)
+	}
+}
+
+func TestDebugLogger_Printf(t *testing.T) {
+	(&debugLogger{logger: zap.NewNop()}).Printf("%s", "foo")
+}
--- a/pkg/modules/chromium/doc.go
+++ b/pkg/modules/chromium/doc.go
@@ -1,4 +1,4 @@
 // Package chromium provides a module which adds routes for converting HTML
-// documents to PDF. Other modules may also retrieve the API provided by this
+// documents to PDF. Other modules may also retrieve the [Api] provided by this
 // module.
 package chromium
--- a/pkg/modules/chromium/events.go
+++ b/pkg/modules/chromium/events.go
@@ -4,12 +4,16 @@ import (
 	"context"
 	"fmt"
 	"regexp"
+	"slices"
+	"sync"

 	"github.com/chromedp/cdproto/cdp"
 	"github.com/chromedp/cdproto/fetch"
 	"github.com/chromedp/cdproto/network"
 	"github.com/chromedp/cdproto/page"
+	"github.com/chromedp/cdproto/runtime"
 	"github.com/chromedp/chromedp"
+	"go.uber.org/multierr"
 	"go.uber.org/zap"
 	"golang.org/x/sync/errgroup"
 )
@@ -40,7 +44,6 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowL
 				if allow {
 					req := fetch.ContinueRequest(e.RequestID)
 					err := req.Do(executorCtx)
-
 					if err != nil {
 						logger.Error(fmt.Sprintf("continue request: %s", err))
 					}
@@ -50,7 +53,6 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowL

 				req := fetch.FailRequest(e.RequestID, network.ErrorReasonAccessDenied)
 				err := req.Do(executorCtx)
-
 				if err != nil {
 					logger.Error(fmt.Sprintf("fail request: %s", err))
 				}
@@ -59,6 +61,54 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowL
 	})
 }

+// listenForEventResponseReceived listens for an invalid HTTP status code is
+// returned by the main page.
+// See https://github.com/gotenberg/gotenberg/issues/613.
+func listenForEventResponseReceived(ctx context.Context, logger *zap.Logger, url string, failOnHttpStatusCodes []int64, invalidHttpStatusCode *error, invalidHttpStatusCodeMu *sync.RWMutex) {
+	for _, code := range []int64{199, 299, 399, 499, 599} {
+		if slices.Contains(failOnHttpStatusCodes, code) {
+			for i := code - 99; i <= code; i++ {
+				failOnHttpStatusCodes = append(failOnHttpStatusCodes, i)
+			}
+		}
+	}
+
+	chromedp.ListenTarget(ctx, func(ev interface{}) {
+		switch ev := ev.(type) {
+		case *network.EventResponseReceived:
+			if ev.Response.URL != url {
+				return
+			}
+
+			logger.Debug(fmt.Sprintf("event EventResponseReceived fired for main page: %+v", ev.Response))
+
+			if slices.Contains(failOnHttpStatusCodes, ev.Response.Status) {
+				invalidHttpStatusCodeMu.Lock()
+				defer invalidHttpStatusCodeMu.Unlock()
+
+				*invalidHttpStatusCode = fmt.Errorf("%d: %s", ev.Response.Status, ev.Response.StatusText)
+			}
+		}
+	})
+}
+
+// listenForEventExceptionThrown listens for exceptions in the console and
+// appends those exceptions to the given error pointer.
+// See https://github.com/gotenberg/gotenberg/issues/262.
+func listenForEventExceptionThrown(ctx context.Context, logger *zap.Logger, consoleExceptions *error, consoleExceptionsMu *sync.RWMutex) {
+	chromedp.ListenTarget(ctx, func(ev interface{}) {
+		switch ev := ev.(type) {
+		case *runtime.EventExceptionThrown:
+			logger.Debug(fmt.Sprintf("event EventExceptionThrown fired: %+v", ev.ExceptionDetails))
+
+			consoleExceptionsMu.Lock()
+			defer consoleExceptionsMu.Unlock()
+
+			*consoleExceptions = multierr.Append(*consoleExceptions, fmt.Errorf("\n%+v", ev.ExceptionDetails))
+		}
+	})
+}
+
 // waitForEventDomContentEventFired waits until the event DomContentEventFired
 // is fired or the context timeout.
 func waitForEventDomContentEventFired(ctx context.Context, logger *zap.Logger) func() error {
@@ -161,7 +211,6 @@ func waitForEventLoadingFinished(ctx context.Context, logger *zap.Logger) func()
 // completed or an error is encountered.
 func runBatch(ctx context.Context, fn ...func() error) error {
 	eg, _ := errgroup.WithContext(ctx)
-
 	for _, f := range fn {
 		eg.Go(f)
 	}
--- a/pkg/modules/chromium/mocks.go
+++ b/pkg/modules/chromium/mocks.go
@@ -0,0 +1,44 @@
+package chromium
+
+import (
+	"context"
+
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+// ApiMock is a mock for the [Api] interface.
+type ApiMock struct {
+	PdfMock        func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error
+	ScreenshotMock func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error
+}
+
+func (api *ApiMock) Pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+	return api.PdfMock(ctx, logger, url, outputPath, options)
+}
+
+func (api *ApiMock) Screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+	return api.ScreenshotMock(ctx, logger, url, outputPath, options)
+}
+
+// browserMock is a mock for the [browser] interface.
+type browserMock struct {
+	gotenberg.ProcessMock
+	pdfMock        func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error
+	screenshotMock func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error
+}
+
+func (b *browserMock) pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+	return b.pdfMock(ctx, logger, url, outputPath, options)
+}
+
+func (b *browserMock) screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+	return b.screenshotMock(ctx, logger, url, outputPath, options)
+}
+
+// Interface guards.
+var (
+	_ Api     = (*ApiMock)(nil)
+	_ browser = (*browserMock)(nil)
+)
--- a/pkg/modules/chromium/mocks_test.go
+++ b/pkg/modules/chromium/mocks_test.go
@@ -0,0 +1,50 @@
+package chromium
+
+import (
+	"context"
+	"testing"
+
+	"go.uber.org/zap"
+)
+
+func TestApiMock(t *testing.T) {
+	mock := &ApiMock{
+		PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+			return nil
+		},
+		ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+			return nil
+		},
+	}
+
+	err := mock.Pdf(context.Background(), zap.NewNop(), "", "", PdfOptions{})
+	if err != nil {
+		t.Errorf("expected no error from ApiMock.Pdf, but got: %v", err)
+	}
+
+	err = mock.Screenshot(context.Background(), zap.NewNop(), "", "", ScreenshotOptions{})
+	if err != nil {
+		t.Errorf("expected no error from ApiMock.Screenshot, but got: %v", err)
+	}
+}
+
+func TestBrowserMock(t *testing.T) {
+	mock := &browserMock{
+		pdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+			return nil
+		},
+		screenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+			return nil
+		},
+	}
+
+	err := mock.pdf(context.Background(), zap.NewNop(), "", "", PdfOptions{})
+	if err != nil {
+		t.Errorf("expected no error from browserMock.pdf, but got: %v", err)
+	}
+
+	err = mock.screenshot(context.Background(), zap.NewNop(), "", "", ScreenshotOptions{})
+	if err != nil {
+		t.Errorf("expected no error from browserMock.screenshot, but got: %v", err)
+	}
+}
--- a/pkg/modules/chromium/routes.go
+++ b/pkg/modules/chromium/routes.go
@@ -6,71 +6,134 @@ import (
 	"errors"
 	"fmt"
 	"html/template"
-	"io/ioutil"
 	"net/http"
 	"os"
 	"path/filepath"
+	"strconv"
+	"strings"
 	"time"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/labstack/echo/v4"
 	"github.com/microcosm-cc/bluemonday"
 	"github.com/russross/blackfriday/v2"
 	"go.uber.org/multierr"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 )

-// FormDataChromiumPDFOptions creates Options form the form data. Fallback to
+// FormDataChromiumOptions creates [Options] from the form data. Fallback to
 // default value if the considered key is not present.
-func FormDataChromiumPDFOptions(ctx *api.Context) (*api.FormData, Options) {
+func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 	defaultOptions := DefaultOptions()

 	var (
-		waitDelay                                        time.Duration
-		waitWindowStatus                                 string
-		extraHTTPHeaders                                 map[string]string
+		skipNetworkIdleEvent    bool
+		failOnHttpStatusCodes   []int64
+		failOnConsoleExceptions bool
+		waitDelay               time.Duration
+		waitWindowStatus        string
+		waitForExpression       string
+		extraHttpHeaders        map[string]string
+		emulatedMediaType       string
+		omitBackground          bool
+	)
+
+	form := ctx.FormData().
+		Bool("skipNetworkIdleEvent", &skipNetworkIdleEvent, defaultOptions.SkipNetworkIdleEvent).
+		Custom("failOnHttpStatusCodes", func(value string) error {
+			if value == "" {
+				failOnHttpStatusCodes = defaultOptions.FailOnHttpStatusCodes
+				return nil
+			}
+
+			err := json.Unmarshal([]byte(value), &failOnHttpStatusCodes)
+			if err != nil {
+				return fmt.Errorf("unmarshal failOnHttpStatusCodes: %w", err)
+			}
+
+			return nil
+		}).
+		Bool("failOnConsoleExceptions", &failOnConsoleExceptions, defaultOptions.FailOnConsoleExceptions).
+		Duration("waitDelay", &waitDelay, defaultOptions.WaitDelay).
+		String("waitWindowStatus", &waitWindowStatus, defaultOptions.WaitWindowStatus).
+		String("waitForExpression", &waitForExpression, defaultOptions.WaitForExpression).
+		Custom("extraHttpHeaders", func(value string) error {
+			if value == "" {
+				extraHttpHeaders = defaultOptions.ExtraHttpHeaders
+				return nil
+			}
+
+			err := json.Unmarshal([]byte(value), &extraHttpHeaders)
+			if err != nil {
+				return fmt.Errorf("unmarshal extraHttpHeaders: %w", err)
+			}
+
+			return nil
+		}).
+		Custom("emulatedMediaType", func(value string) error {
+			if value == "" {
+				emulatedMediaType = defaultOptions.EmulatedMediaType
+				return nil
+			}
+
+			if value != "screen" && value != "print" {
+				return fmt.Errorf("wrong value, expected either 'screen', 'print' or empty")
+			}
+
+			emulatedMediaType = value
+
+			return nil
+		}).
+		Bool("omitBackground", &omitBackground, defaultOptions.OmitBackground)
+
+	options := Options{
+		SkipNetworkIdleEvent:    skipNetworkIdleEvent,
+		FailOnHttpStatusCodes:   failOnHttpStatusCodes,
+		FailOnConsoleExceptions: failOnConsoleExceptions,
+		WaitDelay:               waitDelay,
+		WaitWindowStatus:        waitWindowStatus,
+		WaitForExpression:       waitForExpression,
+		ExtraHttpHeaders:        extraHttpHeaders,
+		EmulatedMediaType:       emulatedMediaType,
+		OmitBackground:          omitBackground,
+	}
+
+	return form, options
+}
+
+// FormDataChromiumPdfOptions creates [PdfOptions] from the form data. Fallback to
+// default value if the considered key is not present.
+func FormDataChromiumPdfOptions(ctx *api.Context) (*api.FormData, PdfOptions) {
+	form, options := FormDataChromiumOptions(ctx)
+	defaultPdfOptions := DefaultPdfOptions()
+
+	var (
 		landscape, printBackground                       bool
 		scale, paperWidth, paperHeight                   float64
 		marginTop, marginBottom, marginLeft, marginRight float64
 		pageRanges                                       string
 		headerTemplate, footerTemplate                   string
-		preferCSSPageSize                                bool
+		preferCssPageSize                                bool
 	)

-	form := ctx.FormData().
-		Duration("waitDelay", &waitDelay, defaultOptions.WaitDelay).
-		String("waitWindowStatus", &waitWindowStatus, defaultOptions.WaitWindowStatus).
-		Custom("extraHttpHeaders", func(value string) error {
-			if value == "" {
-				extraHTTPHeaders = defaultOptions.ExtraHTTPHeaders
+	form.
+		Bool("landscape", &landscape, defaultPdfOptions.Landscape).
+		Bool("printBackground", &printBackground, defaultPdfOptions.PrintBackground).
+		Float64("scale", &scale, defaultPdfOptions.Scale).
+		Float64("paperWidth", &paperWidth, defaultPdfOptions.PaperWidth).
+		Float64("paperHeight", &paperHeight, defaultPdfOptions.PaperHeight).
+		Float64("marginTop", &marginTop, defaultPdfOptions.MarginTop).
+		Float64("marginBottom", &marginBottom, defaultPdfOptions.MarginBottom).
+		Float64("marginLeft", &marginLeft, defaultPdfOptions.MarginLeft).
+		Float64("marginRight", &marginRight, defaultPdfOptions.MarginRight).
+		String("nativePageRanges", &pageRanges, defaultPdfOptions.PageRanges).
+		Content("header.html", &headerTemplate, defaultPdfOptions.HeaderTemplate).
+		Content("footer.html", &footerTemplate, defaultPdfOptions.FooterTemplate).
+		Bool("preferCssPageSize", &preferCssPageSize, defaultPdfOptions.PreferCssPageSize)

-				return nil
-			}
-
-			err := json.Unmarshal([]byte(value), &extraHTTPHeaders)
-			if err != nil {
-				return fmt.Errorf("unmarshal extra HTTP headers: %w", err)
-			}
-
-			return nil
-		}).
-		Bool("landscape", &landscape, defaultOptions.Landscape).
-		Bool("printBackground", &printBackground, defaultOptions.PrintBackground).
-		Float64("scale", &scale, defaultOptions.Scale).
-		Float64("paperWidth", &paperWidth, defaultOptions.PaperWidth).
-		Float64("paperHeight", &paperHeight, defaultOptions.PaperHeight).
-		Float64("marginTop", &marginTop, defaultOptions.MarginTop).
-		Float64("marginBottom", &marginBottom, defaultOptions.MarginBottom).
-		Float64("marginLeft", &marginLeft, defaultOptions.MarginLeft).
-		Float64("marginRight", &marginRight, defaultOptions.MarginRight).
-		String("nativePageRanges", &pageRanges, defaultOptions.PageRanges).
-		Content("header.html", &headerTemplate, defaultOptions.HeaderTemplate).
-		Content("footer.html", &footerTemplate, defaultOptions.FooterTemplate).
-		Bool("preferCssPageSize", &preferCSSPageSize, defaultOptions.PreferCSSPageSize)
-
-	options := Options{
-		WaitDelay:         waitDelay,
-		WaitWindowStatus:  waitWindowStatus,
-		ExtraHTTPHeaders:  extraHTTPHeaders,
+	pdfOptions := PdfOptions{
+		Options:           options,
 		Landscape:         landscape,
 		PrintBackground:   printBackground,
 		Scale:             scale,
@@ -83,35 +146,111 @@ func FormDataChromiumPDFOptions(ctx *api.Context) (*api.FormData, Options) {
 		PageRanges:        pageRanges,
 		HeaderTemplate:    headerTemplate,
 		FooterTemplate:    footerTemplate,
-		PreferCSSPageSize: preferCSSPageSize,
+		PreferCssPageSize: preferCssPageSize,
 	}

-	return form, options
+	return form, pdfOptions
 }

-// convertURLRoute returns an api.MultipartFormDataRoute route which can
-// convert a URL to PDF.
-func convertURLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/chromium/convert/url",
-		Handler: func(ctx *api.Context) error {
-			form, options := FormDataChromiumPDFOptions(ctx)
+// FormDataChromiumScreenshotOptions creates [ScreenshotOptions] from the form
+// data. Fallback to default value if the considered key is not present.
+func FormDataChromiumScreenshotOptions(ctx *api.Context) (*api.FormData, ScreenshotOptions) {
+	form, options := FormDataChromiumOptions(ctx)
+	defaultScreenshotOptions := DefaultScreenshotOptions()

-			var (
-				URL       string
-				PDFformat string
-			)
+	var (
+		format           string
+		quality          int
+		optimizeForSpeed bool
+	)

+	form.
+		Custom("format", func(value string) error {
+			if value == "" {
+				format = defaultScreenshotOptions.Format
+				return nil
+			}
+
+			if value != "png" && value != "jpeg" && value != "webp" {
+				return fmt.Errorf("wrong value, expected either 'png', 'jpeg' or 'webp'")
+			}
+
+			format = value
+
+			return nil
+		}).
+		Custom("quality", func(value string) error {
+			if value == "" {
+				quality = defaultScreenshotOptions.Quality
+				return nil
+			}
+
+			intValue, err := strconv.Atoi(value)
+			if err != nil {
+				return err
+			}
+
+			if intValue < 0 {
+				return errors.New("value is negative")
+			}
+
+			if intValue > 100 {
+				return errors.New("value is superior to 100")
+			}
+
+			quality = intValue
+			return nil
+		}).
+		Bool("optimizeForSpeed", &optimizeForSpeed, defaultScreenshotOptions.OptimizeForSpeed)
+
+	screenshotOptions := ScreenshotOptions{
+		Options:          options,
+		Format:           format,
+		Quality:          quality,
+		OptimizeForSpeed: optimizeForSpeed,
+	}
+
+	return form, screenshotOptions
+}
+
+// FormDataChromiumPdfFormats creates [gotenberg.PdfFormats] from the form
+// data. Fallback to default value if the considered key is not present.
+func FormDataChromiumPdfFormats(form *api.FormData) gotenberg.PdfFormats {
+	var (
+		pdfa  string
+		pdfua bool
+	)
+
+	form.
+		String("pdfa", &pdfa, "").
+		Bool("pdfua", &pdfua, false)
+
+	return gotenberg.PdfFormats{
+		PdfA:  pdfa,
+		PdfUa: pdfua,
+	}
+}
+
+// convertUrlRoute returns an [api.Route] which can convert a URL to PDF.
+func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/chromium/convert/url",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+			form, options := FormDataChromiumPdfOptions(ctx)
+			pdfFormats := FormDataChromiumPdfFormats(form)
+
+			var url string
 			err := form.
-				MandatoryString("url", &URL).
-				String("pdfFormat", &PDFformat, "").
+				MandatoryString("url", &url).
 				Validate()
-
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			err = convertURL(ctx, chromium, engine, URL, PDFformat, options)
+			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options)
 			if err != nil {
 				return fmt.Errorf("convert URL to PDF: %w", err)
 			}
@@ -121,31 +260,57 @@ func convertURLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartForm
 	}
 }

-// convertHTMLRoute returns an api.MultipartFormDataRoute route which can
-// convert an HTML file to PDF.
-func convertHTMLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/chromium/convert/html",
-		Handler: func(ctx *api.Context) error {
-			form, options := FormDataChromiumPDFOptions(ctx)
-
-			var (
-				inputPath string
-				PDFformat string
-			)
+// screenshotUrlRoute returns an [api.Route] which can take a screenshot from a
+// URL.
+func screenshotUrlRoute(chromium Api) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/chromium/screenshot/url",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+			form, options := FormDataChromiumScreenshotOptions(ctx)

+			var url string
 			err := form.
-				MandatoryPath("index.html", &inputPath).
-				String("pdfFormat", &PDFformat, "").
+				MandatoryString("url", &url).
 				Validate()
-
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			URL := fmt.Sprintf("file://%s", inputPath)
+			err = screenshotUrl(ctx, chromium, url, options)
+			if err != nil {
+				return fmt.Errorf("URL screenshot: %w", err)
+			}

-			err = convertURL(ctx, chromium, engine, URL, PDFformat, options)
+			return nil
+		},
+	}
+}
+
+// convertHtmlRoute returns an [api.Route] which can convert an HTML file to
+// PDF.
+func convertHtmlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/chromium/convert/html",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+			form, options := FormDataChromiumPdfOptions(ctx)
+			pdfFormats := FormDataChromiumPdfFormats(form)
+
+			var inputPath string
+			err := form.
+				MandatoryPath("index.html", &inputPath).
+				Validate()
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			url := fmt.Sprintf("file://%s", inputPath)
+			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options)
 			if err != nil {
 				return fmt.Errorf("convert HTML to PDF: %w", err)
 			}
@@ -155,105 +320,67 @@ func convertHTMLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFor
 	}
 }

-// convertMarkdownRoute returns an api.MultipartFormDataRoute route which can
-// convert markdown files to PDF.
-func convertMarkdownRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/chromium/convert/markdown",
-		Handler: func(ctx *api.Context) error {
-			form, options := FormDataChromiumPDFOptions(ctx)
+// screenshotHtmlRoute returns an [api.Route] which can take a screenshot from
+// an HTML file.
+func screenshotHtmlRoute(chromium Api) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/chromium/screenshot/html",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+			form, options := FormDataChromiumScreenshotOptions(ctx)
+
+			var inputPath string
+			err := form.
+				MandatoryPath("index.html", &inputPath).
+				Validate()
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			url := fmt.Sprintf("file://%s", inputPath)
+			err = screenshotUrl(ctx, chromium, url, options)
+			if err != nil {
+				return fmt.Errorf("HTML screenshot: %w", err)
+			}
+
+			return nil
+		},
+	}
+}
+
+// convertMarkdownRoute returns an [api.Route] which can convert markdown files
+// to PDF.
+func convertMarkdownRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/chromium/convert/markdown",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+			form, options := FormDataChromiumPdfOptions(ctx)
+			pdfFormats := FormDataChromiumPdfFormats(form)

 			var (
 				inputPath     string
 				markdownPaths []string
-				PDFformat     string
 			)

 			err := form.
 				MandatoryPath("index.html", &inputPath).
 				MandatoryPaths([]string{".md"}, &markdownPaths).
-				String("pdfFormat", &PDFformat, "").
 				Validate()
-
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			// We have to convert each markdown file referenced in the HTML
-			// file to... HTML. Thanks to the "html/template" package, we are
-			// able to provide the "toHTML" function which the user may call
-			// directly inside the HTML file.
-
-			var markdownFilesNotFoundErr error
-
-			tmpl, err := template.
-				New(filepath.Base(inputPath)).
-				Funcs(template.FuncMap{
-					"toHTML": func(filename string) (template.HTML, error) {
-						var path string
-
-						for _, markdownPath := range markdownPaths {
-							markdownFilename := filepath.Base(markdownPath)
-
-							if filename == markdownFilename {
-								path = markdownPath
-								break
-							}
-						}
-
-						if path == "" {
-							markdownFilesNotFoundErr = multierr.Append(
-								markdownFilesNotFoundErr,
-								fmt.Errorf("'%s'", filename),
-							)
-
-							return "", nil
-						}
-
-						b, err := ioutil.ReadFile(path)
-						if err != nil {
-							return "", fmt.Errorf("read markdown file '%s': %w", filename, err)
-						}
-
-						unsafe := blackfriday.Run(b)
-						sanitized := bluemonday.UGCPolicy().SanitizeBytes(unsafe)
-
-						// #nosec
-						return template.HTML(sanitized), nil
-					},
-				}).ParseFiles(inputPath)
-
+			url, err := markdownToHtml(ctx, inputPath, markdownPaths)
 			if err != nil {
-				return fmt.Errorf("parse template file: %w", err)
+				return fmt.Errorf("transform markdown file(s) to HTML: %w", err)
 			}

-			var buffer bytes.Buffer
-
-			err = tmpl.Execute(&buffer, &struct{}{})
-			if err != nil {
-				return fmt.Errorf("execute template: %w", err)
-			}
-
-			if markdownFilesNotFoundErr != nil {
-				return api.WrapError(
-					fmt.Errorf("markdown files not found: %w", markdownFilesNotFoundErr),
-					api.NewSentinelHTTPError(
-						http.StatusBadRequest,
-						fmt.Sprintf("Markdown file(s) not found: %s", markdownFilesNotFoundErr),
-					),
-				)
-			}
-
-			inputPath = ctx.GeneratePath(".html")
-
-			err = os.WriteFile(inputPath, buffer.Bytes(), 0600)
-			if err != nil {
-				return fmt.Errorf("write template result: %w", err)
-			}
-
-			URL := fmt.Sprintf("file://%s", inputPath)
-
-			err = convertURL(ctx, chromium, engine, URL, PDFformat, options)
+			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options)
 			if err != nil {
 				return fmt.Errorf("convert markdown to PDF: %w", err)
 			}
@@ -263,19 +390,132 @@ func convertMarkdownRoute(chromium API, engine gotenberg.PDFEngine) api.Multipar
 	}
 }

-// convertURL is a stub which is called by the other methods of this file.
-func convertURL(ctx *api.Context, chromium API, engine gotenberg.PDFEngine, URL, PDFformat string, options Options) error {
+// screenshotMarkdownRoute returns an [api.Route] which can take a screenshot
+// from markdown files.
+func screenshotMarkdownRoute(chromium Api) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/chromium/screenshot/markdown",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+			form, options := FormDataChromiumScreenshotOptions(ctx)
+
+			var (
+				inputPath     string
+				markdownPaths []string
+			)
+
+			err := form.
+				MandatoryPath("index.html", &inputPath).
+				MandatoryPaths([]string{".md"}, &markdownPaths).
+				Validate()
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			url, err := markdownToHtml(ctx, inputPath, markdownPaths)
+			if err != nil {
+				return fmt.Errorf("transform markdown file(s) to HTML: %w", err)
+			}
+
+			err = screenshotUrl(ctx, chromium, url, options)
+			if err != nil {
+				return fmt.Errorf("markdown screenshot: %w", err)
+			}
+
+			return nil
+		},
+	}
+}
+
+func markdownToHtml(ctx *api.Context, inputPath string, markdownPaths []string) (string, error) {
+	// We have to convert each markdown file referenced in the HTML
+	// file to... HTML. Thanks to the "html/template" package, we are
+	// able to provide the "toHTML" function which the user may call
+	// directly inside the HTML file.
+
+	var markdownFilesNotFoundErr error
+
+	tmpl, err := template.
+		New(filepath.Base(inputPath)).
+		Funcs(template.FuncMap{
+			"toHTML": func(filename string) (template.HTML, error) {
+				var path string
+
+				for _, markdownPath := range markdownPaths {
+					markdownFilename := filepath.Base(markdownPath)
+
+					if filename == markdownFilename {
+						path = markdownPath
+						break
+					}
+				}
+
+				if path == "" {
+					markdownFilesNotFoundErr = multierr.Append(
+						markdownFilesNotFoundErr,
+						fmt.Errorf("'%s'", filename),
+					)
+
+					return "", nil
+				}
+
+				b, err := os.ReadFile(path)
+				if err != nil {
+					return "", fmt.Errorf("read markdown file '%s': %w", filename, err)
+				}
+
+				unsafe := blackfriday.Run(b)
+				sanitized := bluemonday.UGCPolicy().SanitizeBytes(unsafe)
+
+				// #nosec
+				return template.HTML(sanitized), nil
+			},
+		}).ParseFiles(inputPath)
+	if err != nil {
+		return "", fmt.Errorf("parse template file: %w", err)
+	}
+
+	var buffer bytes.Buffer
+
+	err = tmpl.Execute(&buffer, &struct{}{})
+	if err != nil {
+		return "", fmt.Errorf("execute template: %w", err)
+	}
+
+	if markdownFilesNotFoundErr != nil {
+		return "", api.WrapError(
+			fmt.Errorf("markdown files not found: %w", markdownFilesNotFoundErr),
+			api.NewSentinelHttpError(
+				http.StatusBadRequest,
+				fmt.Sprintf("Markdown file(s) not found: %s", markdownFilesNotFoundErr),
+			),
+		)
+	}
+
+	inputPath = ctx.GeneratePath(".html")
+
+	err = os.WriteFile(inputPath, buffer.Bytes(), 0o600)
+	if err != nil {
+		return "", fmt.Errorf("write template result: %w", err)
+	}
+
+	return fmt.Sprintf("file://%s", inputPath), nil
+}
+
+func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url string, pdfFormats gotenberg.PdfFormats, options PdfOptions) error {
 	outputPath := ctx.GeneratePath(".pdf")

-	err := chromium.PDF(ctx, ctx.Log(), URL, outputPath, options)
+	err := chromium.Pdf(ctx, ctx.Log(), url, outputPath, options)
+	err = handleChromiumError(err, url, options.Options)
 	if err != nil {
-
-		if errors.Is(err, ErrURLNotAuthorized) {
+		if errors.Is(err, ErrOmitBackgroundWithoutPrintBackground) {
 			return api.WrapError(
-				fmt.Errorf("convert to PDF: %w", err),
-				api.NewSentinelHTTPError(
-					http.StatusForbidden,
-					fmt.Sprintf("'%s' does not match the authorized URLs", URL),
+				err,
+				api.NewSentinelHttpError(
+					http.StatusBadRequest,
+					"omitBackground requires printBackground set to true",
 				),
 			)
 		}
@@ -283,7 +523,7 @@ func convertURL(ctx *api.Context, chromium API, engine gotenberg.PDFEngine, URL,
 		if errors.Is(err, ErrInvalidPrinterSettings) {
 			return api.WrapError(
 				fmt.Errorf("convert to PDF: %w", err),
-				api.NewSentinelHTTPError(
+				api.NewSentinelHttpError(
 					http.StatusBadRequest,
 					"Chromium does not handle the provided settings; please check for aberrant form values",
 				),
@@ -293,7 +533,7 @@ func convertURL(ctx *api.Context, chromium API, engine gotenberg.PDFEngine, URL,
 		if errors.Is(err, ErrPageRangesSyntaxError) {
 			return api.WrapError(
 				fmt.Errorf("convert to PDF: %w", err),
-				api.NewSentinelHTTPError(
+				api.NewSentinelHttpError(
 					http.StatusBadRequest,
 					fmt.Sprintf("Chromium does not handle the page ranges '%s' (nativePageRanges)", options.PageRanges),
 				),
@@ -304,22 +544,22 @@ func convertURL(ctx *api.Context, chromium API, engine gotenberg.PDFEngine, URL,
 	}

 	// So far so good, the URL has been converted to PDF.
-	// Now, let's check if the client want to convert this result PDF
-	// to a specific PDF format.
-
-	if PDFformat != "" {
+	// Now, let's check if the client want to convert the resulting PDF
+	// to specific formats.
+	zeroValued := gotenberg.PdfFormats{}
+	if pdfFormats != zeroValued {
 		convertInputPath := outputPath
 		convertOutputPath := ctx.GeneratePath(".pdf")

-		err = engine.Convert(ctx, ctx.Log(), PDFformat, convertInputPath, convertOutputPath)
+		err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)

 		if err != nil {
-			if errors.Is(err, gotenberg.ErrPDFFormatNotAvailable) {
+			if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
 				return api.WrapError(
 					fmt.Errorf("convert PDF: %w", err),
-					api.NewSentinelHTTPError(
+					api.NewSentinelHttpError(
 						http.StatusBadRequest,
-						fmt.Sprintf("At least one PDF engine does not handle the PDF format '%s' (pdfFormat), while other have failed to convert for other reasons", PDFformat),
+						fmt.Sprintf("At least one PDF engine does not handle one of the PDF format in '%+v', while other have failed to convert for other reasons", pdfFormats),
 					),
 				)
 			}
@@ -338,3 +578,76 @@ func convertURL(ctx *api.Context, chromium API, engine gotenberg.PDFEngine, URL,

 	return nil
 }
+
+func screenshotUrl(ctx *api.Context, chromium Api, url string, options ScreenshotOptions) error {
+	ext := fmt.Sprintf(".%s", options.Format)
+	outputPath := ctx.GeneratePath(ext)
+
+	err := chromium.Screenshot(ctx, ctx.Log(), url, outputPath, options)
+	err = handleChromiumError(err, url, options.Options)
+	if err != nil {
+		return fmt.Errorf("screenshot: %w", err)
+	}
+
+	err = ctx.AddOutputPaths(outputPath)
+	if err != nil {
+		return fmt.Errorf("add output path: %w", err)
+	}
+
+	return nil
+}
+
+func handleChromiumError(err error, url string, options Options) error {
+	if err == nil {
+		return nil
+	}
+
+	if errors.Is(err, ErrUrlNotAuthorized) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusForbidden,
+				fmt.Sprintf("'%s' does not match the authorized URLs", url),
+			),
+		)
+	}
+
+	if errors.Is(err, ErrInvalidEvaluationExpression) {
+		if options.WaitForExpression == "" {
+			// We do not expect the 'waitWindowStatus' form field to return
+			// an ErrInvalidEvaluationExpression error. In such a scenario,
+			// we return a 500.
+			return err
+		}
+
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusBadRequest,
+				fmt.Sprintf("The expression '%s' (waitForExpression) returned an exception or undefined", options.WaitForExpression),
+			),
+		)
+	}
+
+	if errors.Is(err, ErrInvalidHttpStatusCode) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusConflict,
+				fmt.Sprintf("Invalid HTTP status code from the main page: %s", strings.ReplaceAll(err.Error(), fmt.Sprintf(": %s", ErrInvalidHttpStatusCode.Error()), "")),
+			),
+		)
+	}
+
+	if errors.Is(err, ErrConsoleExceptions) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusConflict,
+				fmt.Sprintf("Chromium console exceptions:\n %s", strings.ReplaceAll(err.Error(), ErrConsoleExceptions.Error(), "")),
+			),
+		)
+	}
+
+	return err
+}
--- a/pkg/modules/chromium/routes_test.go
+++ b/pkg/modules/chromium/routes_test.go
--- a/pkg/modules/chromium/stream.go
+++ b/pkg/modules/chromium/stream.go
@@ -0,0 +1,117 @@
+package chromium
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/chromedp/cdproto/cdp"
+	cdprotoio "github.com/chromedp/cdproto/io"
+)
+
+// Credits: https://raw.githubusercontent.com/mafredri/cdp/3c5eab7ffc5cbee667b0a813ce470ac423792811/protocol/io/stream_reader.go.
+type streamReader struct {
+	ctx    context.Context
+	handle cdprotoio.StreamHandle
+	r      io.Reader
+	pos    int
+	eof    bool
+}
+
+// Read a chunk of the stream.
+func (reader *streamReader) Read(p []byte) (n int, err error) {
+	if reader.r != nil {
+		// Continue reading from buffer.
+		return reader.read(p)
+	}
+
+	if reader.eof {
+		return 0, io.EOF
+	}
+
+	if len(p) == 0 {
+		return 0, nil
+	}
+
+	// Chromium might have an off-by-one when deciding the maximum size (at
+	// least for base64 encoded data), usually it will overflow. We subtract
+	// one to make sure it fits into p.
+	size := len(p) - 1
+	if size < 1 {
+		// Safety-check to avoid crashing Chrome (e.g. via SetSize(-1)).
+		size = 1
+	}
+
+	reply, err := reader.next(reader.pos, size)
+	if err != nil {
+		return 0, err
+	}
+
+	reader.eof = reply.EOF
+
+	switch {
+	case reply.Base64encoded:
+		b := []byte(reply.Data)
+		size := base64.StdEncoding.DecodedLen(len(b))
+
+		// Safety-check for fast-path to avoid panics.
+		if len(p) >= size {
+			n, err = base64.StdEncoding.Decode(p, b)
+			reader.pos += n
+
+			return n, err
+		}
+
+		reader.r = base64.NewDecoder(base64.StdEncoding, bytes.NewReader(b))
+	default:
+		reader.r = strings.NewReader(reply.Data)
+	}
+
+	return reader.read(p)
+}
+
+// Close closes the stream, discard any temporary backing storage.
+func (reader *streamReader) Close() error {
+	err := cdprotoio.Close(reader.handle).Do(reader.ctx)
+	if err == nil {
+		return nil
+	}
+
+	return fmt.Errorf("close Chromium stream: %w", err)
+}
+
+func (reader *streamReader) next(pos, size int) (cdprotoio.ReadReturns, error) {
+	params := cdprotoio.
+		Read(reader.handle).
+		WithOffset(int64(pos)).
+		WithSize(int64(size))
+
+	var res cdprotoio.ReadReturns
+	err := cdp.Execute(reader.ctx, cdprotoio.CommandRead, params, &res)
+
+	if err == nil {
+		return res, nil
+	}
+
+	return res, fmt.Errorf("execute IO.read command: %w", err)
+}
+
+func (reader *streamReader) read(p []byte) (n int, err error) {
+	n, err = reader.r.Read(p)
+	reader.pos += n
+
+	if !reader.eof && err == io.EOF {
+		reader.r = nil
+		err = nil
+	}
+
+	return n, err
+}
+
+// Interface guards.
+var (
+	_ io.Reader = (*streamReader)(nil)
+)
--- a/pkg/modules/chromium/tasks.go
+++ b/pkg/modules/chromium/tasks.go
@@ -0,0 +1,397 @@
+package chromium
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/chromedp/cdproto/cdp"
+	"github.com/chromedp/cdproto/emulation"
+	"github.com/chromedp/cdproto/network"
+	"github.com/chromedp/cdproto/page"
+	"github.com/chromedp/chromedp"
+	"go.uber.org/zap"
+)
+
+func printToPdfActionFunc(logger *zap.Logger, outputPath string, options PdfOptions) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		printToPdf := page.PrintToPDF().
+			WithTransferMode(page.PrintToPDFTransferModeReturnAsStream).
+			WithLandscape(options.Landscape).
+			WithPrintBackground(options.PrintBackground).
+			WithScale(options.Scale).
+			WithPaperWidth(options.PaperWidth).
+			WithPaperHeight(options.PaperHeight).
+			WithMarginTop(options.MarginTop).
+			WithMarginBottom(options.MarginBottom).
+			WithMarginLeft(options.MarginLeft).
+			WithMarginRight(options.MarginRight).
+			WithPageRanges(options.PageRanges).
+			WithPreferCSSPageSize(options.PreferCssPageSize)
+
+		hasCustomHeaderFooter := options.HeaderTemplate != DefaultPdfOptions().HeaderTemplate ||
+			options.FooterTemplate != DefaultPdfOptions().FooterTemplate
+
+		if !hasCustomHeaderFooter {
+			logger.Debug("no custom header nor footer")
+
+			printToPdf = printToPdf.WithDisplayHeaderFooter(false)
+		} else {
+			logger.Debug("with custom header and/or footer")
+
+			printToPdf = printToPdf.
+				WithDisplayHeaderFooter(true).
+				WithHeaderTemplate(options.HeaderTemplate).
+				WithFooterTemplate(options.FooterTemplate)
+		}
+
+		logger.Debug(fmt.Sprintf("print to PDF with: %+v", printToPdf))
+
+		_, stream, err := printToPdf.Do(ctx)
+		if err != nil {
+			return fmt.Errorf("print to PDF: %w", err)
+		}
+
+		reader := &streamReader{
+			ctx:    ctx,
+			handle: stream,
+			r:      nil,
+			pos:    0,
+			eof:    false,
+		}
+
+		defer func() {
+			err = reader.Close()
+			if err != nil {
+				logger.Error(fmt.Sprintf("close reader: %s", err))
+			}
+		}()
+
+		file, err := os.OpenFile(outputPath, os.O_CREATE|os.O_WRONLY, 0o600)
+		if err != nil {
+			return fmt.Errorf("open output path: %w", err)
+		}
+
+		defer func() {
+			err = file.Close()
+			if err != nil {
+				logger.Error(fmt.Sprintf("close output path: %s", err))
+			}
+		}()
+
+		buffer := bufio.NewReader(reader)
+
+		_, err = buffer.WriteTo(file)
+		if err != nil {
+			return fmt.Errorf("write result to output path: %w", err)
+		}
+
+		return nil
+	}
+}
+
+func captureScreenshotActionFunc(logger *zap.Logger, outputPath string, options ScreenshotOptions) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		captureScreenshot := page.CaptureScreenshot().
+			WithCaptureBeyondViewport(true).
+			WithFromSurface(true).
+			WithOptimizeForSpeed(options.OptimizeForSpeed).
+			WithFormat(page.CaptureScreenshotFormat(options.Format))
+
+		if options.Format == "jpeg" {
+			captureScreenshot = captureScreenshot.
+				WithQuality(int64(options.Quality))
+		}
+
+		logger.Debug(fmt.Sprintf("capture screenshot with: %+v", captureScreenshot))
+
+		buffer, err := captureScreenshot.Do(ctx)
+		if err != nil {
+			return fmt.Errorf("capture screenshot: %w", err)
+		}
+
+		file, err := os.OpenFile(outputPath, os.O_CREATE|os.O_WRONLY, 0o600)
+		if err != nil {
+			return fmt.Errorf("open output path: %w", err)
+		}
+
+		defer func() {
+			err = file.Close()
+			if err != nil {
+				logger.Error(fmt.Sprintf("close output path: %s", err))
+			}
+		}()
+
+		_, err = file.Write(buffer)
+		if err != nil {
+			return fmt.Errorf("write result to output path: %w", err)
+		}
+
+		return nil
+	}
+}
+
+func clearCacheActionFunc(logger *zap.Logger, clear bool) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		// See https://github.com/gotenberg/gotenberg/issues/753.
+		if !clear {
+			logger.Debug("cache not cleared")
+			return nil
+		}
+
+		logger.Debug("clear cache")
+
+		err := network.ClearBrowserCache().Do(ctx)
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("clear cache: %w", err)
+	}
+}
+
+func clearCookiesActionFunc(logger *zap.Logger, clear bool) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		// See https://github.com/gotenberg/gotenberg/issues/753.
+		if !clear {
+			logger.Debug("cookies not cleared")
+			return nil
+		}
+
+		logger.Debug("clear cookies")
+
+		err := network.ClearBrowserCookies().Do(ctx)
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("clear cookies: %w", err)
+	}
+}
+
+func disableJavaScriptActionFunc(logger *zap.Logger, disable bool) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		// See https://github.com/gotenberg/gotenberg/issues/175.
+		if !disable {
+			logger.Debug("JavaScript not disabled")
+			return nil
+		}
+
+		logger.Debug("disable JavaScript")
+
+		err := emulation.SetScriptExecutionDisabled(true).Do(ctx)
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("disable JavaScript: %w", err)
+	}
+}
+
+func extraHttpHeadersActionFunc(logger *zap.Logger, extraHttpHeaders map[string]string) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		if len(extraHttpHeaders) == 0 {
+			logger.Debug("no extra HTTP headers")
+			return nil
+		}
+
+		logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", extraHttpHeaders))
+
+		headers := make(network.Headers, len(extraHttpHeaders))
+		for key, value := range extraHttpHeaders {
+			headers[key] = value
+		}
+
+		err := network.SetExtraHTTPHeaders(headers).Do(ctx)
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("set extra HTTP headers: %w", err)
+	}
+}
+
+func navigateActionFunc(logger *zap.Logger, url string, skipNetworkIdleEvent bool) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		logger.Debug(fmt.Sprintf("navigate to '%s'", url))
+
+		_, _, _, err := page.Navigate(url).Do(ctx)
+		if err != nil {
+			return fmt.Errorf("navigate to '%s': %w", url, err)
+		}
+
+		waitFunc := []func() error{
+			waitForEventDomContentEventFired(ctx, logger),
+			waitForEventLoadEventFired(ctx, logger),
+			waitForEventLoadingFinished(ctx, logger),
+		}
+
+		if !skipNetworkIdleEvent {
+			waitFunc = append(waitFunc, waitForEventNetworkIdle(ctx, logger))
+		} else {
+			logger.Debug("skipping network idle event")
+		}
+
+		err = runBatch(
+			ctx,
+			waitFunc...,
+		)
+
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("wait for events: %w", err)
+	}
+}
+
+func hideDefaultWhiteBackgroundActionFunc(logger *zap.Logger, omitBackground, printBackground bool) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		// See https://github.com/gotenberg/gotenberg/issues/226.
+		if !omitBackground {
+			logger.Debug("default white background not hidden")
+			return nil
+		}
+
+		if !printBackground {
+			// See https://github.com/chromedp/chromedp/issues/1179#issuecomment-1284794416.
+			return fmt.Errorf("validate omit background: %w", ErrOmitBackgroundWithoutPrintBackground)
+		}
+
+		logger.Debug("hide default white background")
+
+		err := emulation.SetDefaultBackgroundColorOverride().WithColor(
+			&cdp.RGBA{
+				R: 0,
+				G: 0,
+				B: 0,
+				A: 0,
+			}).Do(ctx)
+
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("hide default white background: %w", err)
+	}
+}
+
+func forceExactColorsActionFunc() chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		// See:
+		// https://github.com/gotenberg/gotenberg/issues/354
+		// https://github.com/puppeteer/puppeteer/issues/2685
+		// https://github.com/chromedp/chromedp/issues/520
+		script := `
+(() => {
+	const css = 'html { -webkit-print-color-adjust: exact !important; }';
+
+	const style = document.createElement('style');
+	style.type = 'text/css';
+	style.appendChild(document.createTextNode(css));
+	document.head.appendChild(style);
+})();
+`
+
+		evaluate := chromedp.Evaluate(script, nil)
+		err := evaluate.Do(ctx)
+
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("add CSS for exact colors: %w", err)
+	}
+}
+
+func emulateMediaTypeActionFunc(logger *zap.Logger, mediaType string) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		if mediaType == "" {
+			logger.Debug("no emulated media type")
+			return nil
+		}
+
+		if mediaType != "screen" && mediaType != "print" {
+			return fmt.Errorf("validate emulated media type '%s': %w", mediaType, ErrInvalidEmulatedMediaType)
+		}
+
+		logger.Debug(fmt.Sprintf("emulate media type '%s'", mediaType))
+
+		emulatedMedia := emulation.SetEmulatedMedia()
+		err := emulatedMedia.WithMedia(mediaType).Do(ctx)
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("emulate media type '%s': %w", mediaType, err)
+	}
+}
+
+func waitDelayBeforePrintActionFunc(logger *zap.Logger, disableJavaScript bool, delay time.Duration) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		if disableJavaScript {
+			logger.Debug("JavaScript disabled, skipping wait delay")
+			return nil
+		}
+
+		if delay <= 0 {
+			logger.Debug("no wait delay")
+			return nil
+		}
+
+		// We wait for a given amount of time so that JavaScript
+		// scripts have a chance to finish before printing the page.
+		logger.Debug(fmt.Sprintf("wait '%s' before print", delay))
+
+		select {
+		case <-ctx.Done():
+			return fmt.Errorf("wait delay: %w", ctx.Err())
+		case <-time.After(delay):
+			return nil
+		}
+	}
+}
+
+func waitForExpressionBeforePrintActionFunc(logger *zap.Logger, disableJavaScript bool, expression string) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		if disableJavaScript {
+			logger.Debug("JavaScript disabled, skipping wait expression")
+			return nil
+		}
+
+		if expression == "" {
+			logger.Debug("no wait expression")
+			return nil
+		}
+
+		// We wait until the evaluation of the expression is true or
+		// until the context is done.
+		logger.Debug(fmt.Sprintf("wait until '%s' is true before print", expression))
+		ticker := time.NewTicker(time.Duration(100) * time.Millisecond)
+
+		for {
+			select {
+			case <-ctx.Done():
+				ticker.Stop()
+				return fmt.Errorf("context done while evaluating '%s': %w", expression, ctx.Err())
+			case <-ticker.C:
+				var ok bool
+				evaluate := chromedp.Evaluate(expression, &ok)
+
+				err := evaluate.Do(ctx)
+				if err != nil {
+					return fmt.Errorf("evaluate: %v: %w", err, ErrInvalidEvaluationExpression)
+				}
+
+				if ok {
+					ticker.Stop()
+					return nil
+				}
+
+				continue
+			}
+		}
+	}
+}
--- a/pkg/modules/gc/doc.go
+++ b/pkg/modules/gc/doc.go
@@ -1,3 +0,0 @@
-// Package gc provides a module for removing files and directories that have
-// expired.
-package gc
--- a/pkg/modules/gc/gc.go
+++ b/pkg/modules/gc/gc.go
@@ -1,235 +0,0 @@
-package gc
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"os/signal"
-	"path/filepath"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"go.uber.org/zap"
-)
-
-func init() {
-	gotenberg.MustRegisterModule(GarbageCollector{})
-}
-
-// GarbageCollector is a module for removing files and directories that have
-// expired. It allows us to make sure that the application does not leak files
-// or directories when running.
-type GarbageCollector struct {
-	rootPath      string
-	graceDuration time.Duration
-	excludeSubstr []string
-
-	ticker *time.Ticker
-	done   chan bool
-
-	logger *zap.Logger
-}
-
-// GarbageCollectorGraceDurationModifier is a module interface which allows to
-// update the expiration time of files and directories parsed by the garbage
-// collector. For instance, if the grace duration is 30s, the garbage collector
-// will remove paths that have a modification time older than 30s. If there are
-// many GarbageCollectorGraceDurationModifier, only the longest grace duration
-// is selected.
-type GarbageCollectorGraceDurationModifier interface {
-	GraceDuration() time.Duration
-}
-
-// GarbageCollectorExcludeSubstrModifier is a module interface which adds the
-// given substrings to the exclude list of the garbage collector. If a path
-// contains one of those substrings, the garbage collector ignores it.
-type GarbageCollectorExcludeSubstrModifier interface {
-	ExcludeSubstr() []string
-}
-
-// Descriptor returns a GarbageCollector's module descriptor.
-func (gc GarbageCollector) Descriptor() gotenberg.ModuleDescriptor {
-	return gotenberg.ModuleDescriptor{
-		ID:  "gc",
-		New: func() gotenberg.Module { return new(GarbageCollector) },
-	}
-}
-
-// Provision sets the module properties.
-func (gc *GarbageCollector) Provision(ctx *gotenberg.Context) error {
-	gc.rootPath = gotenberg.TmpPath()
-
-	graceDurationModifiers, err := ctx.Modules(new(GarbageCollectorGraceDurationModifier))
-	if err != nil {
-		return fmt.Errorf("get grace duration modifiers: %w", err)
-	}
-
-	for _, graceDurationModifier := range graceDurationModifiers {
-		modifier := graceDurationModifier.(GarbageCollectorGraceDurationModifier)
-
-		if gc.graceDuration < modifier.GraceDuration() {
-			gc.graceDuration = modifier.GraceDuration()
-		}
-	}
-
-	excludeSubstrModifiers, err := ctx.Modules(new(GarbageCollectorExcludeSubstrModifier))
-	if err != nil {
-		return fmt.Errorf("get exclude substr modifiers: %w", err)
-	}
-
-	gc.excludeSubstr = strings.Split(os.Getenv("GC_EXCLUDE_SUBSTR"), ",")
-
-	for _, excludeSubstrModifier := range excludeSubstrModifiers {
-		modifier := excludeSubstrModifier.(GarbageCollectorExcludeSubstrModifier)
-
-		gc.excludeSubstr = append(gc.excludeSubstr, modifier.ExcludeSubstr()...)
-	}
-
-	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
-	if err != nil {
-		return fmt.Errorf("get logger provider: %w", err)
-	}
-
-	logger, err := loggerProvider.(gotenberg.LoggerProvider).Logger(gc)
-	if err != nil {
-		return fmt.Errorf("get logger: %w", err)
-	}
-
-	gc.logger = logger
-
-	return nil
-}
-
-// Start starts the garbage collector.
-func (gc *GarbageCollector) Start() error {
-	gc.ticker = time.NewTicker(gc.graceDuration + time.Duration(1)*time.Second)
-	gc.done = make(chan bool, 1)
-
-	go func() {
-		for {
-			func() {
-				gcMu.RLock()
-				defer gcMu.RUnlock()
-
-				select {
-				case <-gc.done:
-					return
-				case <-gc.ticker.C:
-					gc.collect(false)
-				}
-			}()
-		}
-	}()
-
-	return nil
-}
-
-// collect parses the root path of the garbage collector and removes files or
-// directories that have expired. It ignores the expiration date if the "force"
-// argument is set to true.
-func (gc GarbageCollector) collect(force bool) {
-	expirationTime := time.Now().Add(-gc.graceDuration)
-
-	// To make sure that the next Walk method stays on
-	// the root level of the considered path, we have to
-	// return a filepath.SkipDir error if the current path
-	// is a directory.
-	skipDirOrNil := func(info os.FileInfo) error {
-		if info.IsDir() {
-			return filepath.SkipDir
-		}
-
-		return nil
-	}
-
-	removePath := func(path string) {
-		err := os.RemoveAll(path)
-		if err != nil {
-			gc.logger.Error(fmt.Sprintf("remove '%s': %s", path, err))
-		}
-
-		gc.logger.Debug(fmt.Sprintf("'%s' removed", path))
-	}
-
-	err := filepath.Walk(gc.rootPath, func(path string, info os.FileInfo, pathErr error) error {
-		if pathErr != nil {
-			// For whatever reasons, the Walk method failed
-			// to process the current path.
-			return pathErr
-		}
-
-		if path == gc.rootPath {
-			return nil
-		}
-
-		for _, substr := range gc.excludeSubstr {
-			if strings.Contains(info.Name(), substr) {
-				return skipDirOrNil(info)
-			}
-		}
-
-		if force {
-			removePath(path)
-
-			return skipDirOrNil(info)
-		}
-
-		if info.ModTime().Before(expirationTime) {
-			removePath(path)
-		}
-
-		return skipDirOrNil(info)
-	})
-
-	if err != nil {
-		gc.logger.Error(err.Error())
-	}
-}
-
-// StartupMessage returns an empty string.
-func (gc GarbageCollector) StartupMessage() string {
-	return ""
-}
-
-// Stop stops the garbage collector.
-func (gc *GarbageCollector) Stop(ctx context.Context) error {
-	_, ok := ctx.Deadline()
-	if !ok {
-		return errors.New("no context dead line")
-	}
-
-	// Block until the context is done so that other module may gracefully stop
-	// before we do a shutdown cleanup. We skip this step if we receive a
-	// SIGINT in the meantime.
-	gc.logger.Debug("wait for the end of grace duration")
-
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, os.Interrupt)
-
-	select {
-	case <-quit:
-		return nil
-	case <-ctx.Done():
-		break
-	}
-
-	gc.ticker.Stop()
-	gc.done <- true
-
-	gc.logger.Debug("shutdown cleanup...")
-	gc.collect(true)
-
-	return nil
-}
-
-var gcMu sync.RWMutex
-
-// Interface guards.
-var (
-	_ gotenberg.Module      = (*GarbageCollector)(nil)
-	_ gotenberg.Provisioner = (*GarbageCollector)(nil)
-	_ gotenberg.App         = (*GarbageCollector)(nil)
-)
--- a/pkg/modules/gc/gc_test.go
+++ b/pkg/modules/gc/gc_test.go
@@ -1,468 +0,0 @@
-package gc
-
-import (
-	"context"
-	"errors"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"go.uber.org/zap"
-)
-
-type ProtoModule struct {
-	descriptor func() gotenberg.ModuleDescriptor
-}
-
-func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
-	return mod.descriptor()
-}
-
-type ProtoValidator struct {
-	ProtoModule
-	validate func() error
-}
-
-func (mod ProtoValidator) Validate() error {
-	return mod.validate()
-}
-
-type ProtoGarbageCollectorGraceDurationModifier struct {
-	ProtoValidator
-	graceDuration func() time.Duration
-}
-
-func (mod ProtoGarbageCollectorGraceDurationModifier) GraceDuration() time.Duration {
-	return mod.graceDuration()
-}
-
-type ProtoGarbageCollectorExcludeSubstrModifier struct {
-	ProtoValidator
-	excludeSubstr func() []string
-}
-
-func (mod ProtoGarbageCollectorExcludeSubstrModifier) ExcludeSubstr() []string {
-	return mod.excludeSubstr()
-}
-
-type ProtoLoggerProvider struct {
-	ProtoModule
-	logger func(mod gotenberg.Module) (*zap.Logger, error)
-}
-
-func (factory ProtoLoggerProvider) Logger(mod gotenberg.Module) (*zap.Logger, error) {
-	return factory.logger(mod)
-}
-
-func TestGarbageCollector_Descriptor(t *testing.T) {
-	descriptor := GarbageCollector{}.Descriptor()
-
-	actual := reflect.TypeOf(descriptor.New())
-	expect := reflect.TypeOf(new(GarbageCollector))
-
-	if actual != expect {
-		t.Errorf("expected '%s' but got '%s'", expect, actual)
-	}
-}
-
-func TestGarbageCollector_Provision(t *testing.T) {
-	for i, tc := range []struct {
-		ctx                 *gotenberg.Context
-		expectGraceDuration time.Duration
-		expectExcludeSubstr []string
-		expectErr           bool
-	}{
-		{
-			ctx: func() *gotenberg.Context {
-				mod := struct {
-					ProtoGarbageCollectorGraceDurationModifier
-				}{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
-				}
-				mod.validate = func() error { return errors.New("foo") }
-
-				return gotenberg.NewContext(gotenberg.ParsedFlags{}, []gotenberg.ModuleDescriptor{
-					mod.Descriptor(),
-				})
-			}(),
-			expectErr: true,
-		},
-		{
-			ctx: func() *gotenberg.Context {
-				mod := struct {
-					ProtoGarbageCollectorExcludeSubstrModifier
-				}{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
-				}
-				mod.validate = func() error { return errors.New("foo") }
-
-				return gotenberg.NewContext(gotenberg.ParsedFlags{}, []gotenberg.ModuleDescriptor{
-					mod.Descriptor(),
-				})
-			}(),
-			expectErr: true,
-		},
-		{
-			ctx:       gotenberg.NewContext(gotenberg.ParsedFlags{}, make([]gotenberg.ModuleDescriptor, 0)),
-			expectErr: true,
-		},
-		{
-			ctx: func() *gotenberg.Context {
-				mod := struct {
-					ProtoLoggerProvider
-				}{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
-				}
-				mod.logger = func(mod gotenberg.Module) (*zap.Logger, error) { return nil, errors.New("foo") }
-
-				return gotenberg.NewContext(gotenberg.ParsedFlags{}, []gotenberg.ModuleDescriptor{
-					mod.Descriptor(),
-				})
-			}(),
-			expectErr: true,
-		},
-		{
-			ctx: func() *gotenberg.Context {
-				mod := struct {
-					ProtoLoggerProvider
-				}{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
-				}
-				mod.logger = func(mod gotenberg.Module) (*zap.Logger, error) { return zap.NewNop(), nil }
-
-				return gotenberg.NewContext(gotenberg.ParsedFlags{}, []gotenberg.ModuleDescriptor{
-					mod.Descriptor(),
-				})
-			}(),
-		},
-		{
-			ctx: func() *gotenberg.Context {
-				mod1 := struct {
-					ProtoGarbageCollectorGraceDurationModifier
-				}{}
-				mod1.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod1 }}
-				}
-				mod1.graceDuration = func() time.Duration { return time.Duration(10) * time.Second }
-				mod1.validate = func() error { return nil }
-
-				mod2 := struct {
-					ProtoGarbageCollectorGraceDurationModifier
-				}{}
-				mod2.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod2 }}
-				}
-				mod2.graceDuration = func() time.Duration { return time.Duration(20) * time.Second }
-				mod2.validate = func() error { return nil }
-
-				mod3 := struct {
-					ProtoLoggerProvider
-				}{}
-				mod3.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "baz", New: func() gotenberg.Module { return mod3 }}
-				}
-				mod3.logger = func(mod gotenberg.Module) (*zap.Logger, error) { return zap.NewNop(), nil }
-
-				return gotenberg.NewContext(gotenberg.ParsedFlags{}, []gotenberg.ModuleDescriptor{
-					mod1.Descriptor(),
-					mod2.Descriptor(),
-					mod3.Descriptor(),
-				})
-			}(),
-			expectGraceDuration: time.Duration(20) * time.Second,
-		},
-		{
-			ctx: func() *gotenberg.Context {
-				mod1 := struct {
-					ProtoGarbageCollectorExcludeSubstrModifier
-				}{}
-				mod1.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod1 }}
-				}
-				mod1.excludeSubstr = func() []string { return []string{"foo"} }
-				mod1.validate = func() error { return nil }
-
-				mod2 := struct {
-					ProtoGarbageCollectorExcludeSubstrModifier
-				}{}
-				mod2.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod2 }}
-				}
-				mod2.excludeSubstr = func() []string { return []string{"bar"} }
-				mod2.validate = func() error { return nil }
-
-				mod3 := struct {
-					ProtoLoggerProvider
-				}{}
-				mod3.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "baz", New: func() gotenberg.Module { return mod3 }}
-				}
-				mod3.logger = func(mod gotenberg.Module) (*zap.Logger, error) { return zap.NewNop(), nil }
-
-				return gotenberg.NewContext(gotenberg.ParsedFlags{}, []gotenberg.ModuleDescriptor{
-					mod1.Descriptor(),
-					mod2.Descriptor(),
-					mod3.Descriptor(),
-				})
-			}(),
-			expectExcludeSubstr: func() []string {
-				expect := strings.Split(os.Getenv("GC_EXCLUDE_SUBSTR"), ",")
-				return append(expect, "foo", "bar")
-			}(),
-		},
-	} {
-		mod := new(GarbageCollector)
-		err := mod.Provision(tc.ctx)
-
-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
-
-		if tc.expectGraceDuration != 0 && tc.expectGraceDuration != mod.graceDuration {
-			t.Errorf("test %d: expected grace duration of '%s' but got '%s'", i, tc.expectGraceDuration, mod.graceDuration)
-		}
-
-		if tc.expectExcludeSubstr != nil && !reflect.DeepEqual(tc.expectExcludeSubstr, mod.excludeSubstr) {
-			t.Errorf("test %d: expected exclude substr '%s' but got '%s'", i, tc.expectExcludeSubstr, mod.excludeSubstr)
-		}
-	}
-}
-
-func TestGarbageCollector_Start(t *testing.T) {
-	mod := new(GarbageCollector)
-	mod.logger = zap.NewNop()
-
-	path, err := gotenberg.MkdirAll()
-	if err != nil {
-		t.Fatalf("expected no error but got: %v", err)
-	}
-
-	mod.rootPath = path
-
-	err = mod.Start()
-	if err != nil {
-		t.Errorf("expected no error but got: %v", err)
-	}
-
-	time.Sleep(time.Duration(2) * time.Second)
-	mod.ticker.Stop()
-	mod.done <- true
-}
-
-func TestGarbageCollector_collect(t *testing.T) {
-	for i, tc := range []struct {
-		gc              *GarbageCollector
-		expectNotExists []string
-		expectExists    []string
-		force           bool
-	}{
-		{
-			gc: func() *GarbageCollector {
-				mod := new(GarbageCollector)
-				mod.logger = zap.NewNop()
-
-				path, err := gotenberg.MkdirAll()
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				mod.rootPath = path
-
-				err = os.WriteFile(path+"/foo", []byte{1}, 0755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				mod.excludeSubstr = []string{
-					"foo",
-				}
-
-				return mod
-			}(),
-			expectExists: []string{
-				"/foo",
-			},
-		},
-		{
-			gc: func() *GarbageCollector {
-				mod := new(GarbageCollector)
-				mod.logger = zap.NewNop()
-
-				path, err := gotenberg.MkdirAll()
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				mod.rootPath = path
-
-				err = os.WriteFile(path+"/foo", []byte{1}, 0755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				err = os.MkdirAll(path+"/bar", 0755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				return mod
-			}(),
-			expectNotExists: []string{
-				"/foo",
-				"/bar",
-			},
-			force: true,
-		},
-		{
-			gc: func() *GarbageCollector {
-				mod := new(GarbageCollector)
-				mod.logger = zap.NewNop()
-				mod.graceDuration = time.Duration(10) * time.Second
-
-				path, err := gotenberg.MkdirAll()
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				mod.rootPath = path
-
-				err = os.WriteFile(path+"/foo", []byte{1}, 0755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				newTime := time.Now().Add(-time.Duration(20) * time.Second)
-				err = os.Chtimes(path+"/foo", newTime, newTime)
-
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				err = os.WriteFile(path+"/bar", []byte{1}, 0755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				newTime = time.Now().Add(time.Duration(10) * time.Second)
-				err = os.Chtimes(path+"/bar", newTime, newTime)
-
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				return mod
-			}(),
-			expectNotExists: []string{
-				"/foo",
-			},
-			expectExists: []string{
-				"/bar",
-			},
-		},
-	} {
-		tc.gc.collect(tc.force)
-
-		for _, name := range tc.expectNotExists {
-			path := tc.gc.rootPath + name
-			_, err := os.Stat(path)
-			if !os.IsNotExist(err) {
-				t.Errorf("test %d: expected '%s' not to exist but got: %v", i, path, err)
-			}
-		}
-
-		for _, name := range tc.expectExists {
-			path := tc.gc.rootPath + name
-			_, err := os.Stat(path)
-			if os.IsNotExist(err) {
-				t.Errorf("test %d: expected '%s' to exist but got: %v", i, path, err)
-			}
-		}
-
-		err := os.RemoveAll(tc.gc.rootPath)
-		if err != nil {
-			t.Fatalf("test %d: expected no error but got: %v", i, err)
-		}
-	}
-}
-
-func TestGarbageCollector_StartupMessage(t *testing.T) {
-	actual := new(GarbageCollector).StartupMessage()
-	expect := ""
-
-	if actual != expect {
-		t.Errorf("expected '%s' but got '%s'", expect, actual)
-	}
-}
-
-func TestGarbageCollector_Stop(t *testing.T) {
-	for i, tc := range []struct {
-		timeout   time.Duration
-		expectErr bool
-	}{
-		{
-			expectErr: true,
-		},
-		{
-			timeout: time.Duration(1) * time.Nanosecond,
-		},
-	} {
-		func() {
-			mod := new(GarbageCollector)
-			mod.logger = zap.NewNop()
-
-			path, err := gotenberg.MkdirAll()
-			if err != nil {
-				t.Fatalf("test %d: expected no error but got: %v", i, err)
-			}
-
-			mod.rootPath = path
-
-			err = mod.Start()
-			if err != nil {
-				t.Fatalf("test %d: expected no error but got: %v", i, err)
-			}
-
-			if tc.timeout == 0 {
-				err = mod.Stop(context.TODO())
-			} else {
-				ctx, cancel := context.WithTimeout(context.Background(), tc.timeout)
-				defer cancel()
-
-				err = mod.Stop(ctx)
-			}
-
-			if tc.expectErr && err == nil {
-				t.Errorf("test %d: expected error but got: %v", i, err)
-			}
-
-			if !tc.expectErr && err != nil {
-				t.Errorf("test %d: expected no error but got: %v", i, err)
-			}
-		}()
-	}
-}
-
-// Interface guards.
-var (
-	_ gotenberg.Module                      = (*ProtoModule)(nil)
-	_ gotenberg.Validator                   = (*ProtoValidator)(nil)
-	_ GarbageCollectorGraceDurationModifier = (*ProtoGarbageCollectorGraceDurationModifier)(nil)
-	_ gotenberg.Module                      = (*ProtoGarbageCollectorGraceDurationModifier)(nil)
-	_ gotenberg.Validator                   = (*ProtoGarbageCollectorGraceDurationModifier)(nil)
-	_ GarbageCollectorExcludeSubstrModifier = (*ProtoGarbageCollectorExcludeSubstrModifier)(nil)
-	_ gotenberg.Module                      = (*ProtoGarbageCollectorExcludeSubstrModifier)(nil)
-	_ gotenberg.Validator                   = (*ProtoGarbageCollectorExcludeSubstrModifier)(nil)
-	_ gotenberg.LoggerProvider              = (*ProtoLoggerProvider)(nil)
-	_ gotenberg.Module                      = (*ProtoLoggerProvider)(nil)
-)
--- a/pkg/modules/libreoffice/api/api.go
+++ b/pkg/modules/libreoffice/api/api.go
@@ -0,0 +1,360 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/alexliesenfeld/health"
+	flag "github.com/spf13/pflag"
+	"go.uber.org/multierr"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(new(Api))
+}
+
+var (
+	// ErrInvalidPdfFormats happens if the PDF formats option cannot be handled
+	// by LibreOffice.
+	ErrInvalidPdfFormats = errors.New("invalid PDF formats")
+
+	// ErrMalformedPageRanges happens if the page ranges option cannot be
+	// interpreted by LibreOffice.
+	ErrMalformedPageRanges = errors.New("page ranges are malformed")
+)
+
+// Api is a module which provides a [Uno] to interact with LibreOffice.
+type Api struct {
+	autoStart bool
+	args      libreOfficeArguments
+
+	logger      *zap.Logger
+	libreOffice libreOffice
+	supervisor  gotenberg.ProcessSupervisor
+}
+
+// Options gathers available options when converting a document to PDF.
+type Options struct {
+	// Landscape allows to change the orientation of the resulting PDF.
+	// Optional.
+	Landscape bool
+
+	// PageRanges allows to select the pages to convert.
+	// Optional.
+	PageRanges string
+
+	// PdfFormats allows to convert the resulting PDF to PDF/A-1b, PDF/A-2b,
+	// PDF/A-3b and PDF/UA.
+	// Optional.
+	PdfFormats gotenberg.PdfFormats
+}
+
+// Uno is an abstraction on top of the Universal Network Objects API.
+type Uno interface {
+	Pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
+	Extensions() []string
+}
+
+// Provider is a module interface which exposes a method for creating a
+// [Uno] for other modules.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(libreofficeapi.Provider))
+//		libreOffice, _      := provider.(api.Provider).LibreOffice()
+//	}
+type Provider interface {
+	LibreOffice() (Uno, error)
+}
+
+// Descriptor returns a [Api]'s module descriptor.
+func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID: "libreoffice-api",
+		FlagSet: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("api", flag.ExitOnError)
+			fs.Int64("libreoffice-restart-after", 10, "Number of conversions after which LibreOffice will automatically restart. Set to 0 to disable this feature")
+			fs.Bool("libreoffice-auto-start", false, "Automatically launch LibreOffice upon initialization if set to true; otherwise, LibreOffice will start at the time of the first conversion")
+			fs.Duration("libreoffice-start-timeout", time.Duration(20)*time.Second, "Maximum duration to wait for LibreOffice to start or restart")
+
+			return fs
+		}(),
+		New: func() gotenberg.Module { return new(Api) },
+	}
+}
+
+// Provision sets the module properties.
+func (a *Api) Provision(ctx *gotenberg.Context) error {
+	flags := ctx.ParsedFlags()
+	a.autoStart = flags.MustBool("libreoffice-auto-start")
+
+	libreOfficeBinPath, ok := os.LookupEnv("LIBREOFFICE_BIN_PATH")
+	if !ok {
+		return errors.New("LIBREOFFICE_BIN_PATH environment variable is not set")
+	}
+
+	unoBinPath, ok := os.LookupEnv("UNOCONVERTER_BIN_PATH")
+	if !ok {
+		return errors.New("UNOCONVERTER_BIN_PATH environment variable is not set")
+	}
+
+	a.args = libreOfficeArguments{
+		binPath:      libreOfficeBinPath,
+		unoBinPath:   unoBinPath,
+		startTimeout: flags.MustDuration("libreoffice-start-timeout"),
+	}
+
+	// Logger.
+	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
+	if err != nil {
+		return fmt.Errorf("get logger provider: %w", err)
+	}
+	logger, err := loggerProvider.(gotenberg.LoggerProvider).Logger(a)
+	if err != nil {
+		return fmt.Errorf("get logger: %w", err)
+	}
+	a.logger = logger.Named("libreoffice")
+
+	// Process.
+	a.libreOffice = newLibreOfficeProcess(a.args)
+	a.supervisor = gotenberg.NewProcessSupervisor(a.logger, a.libreOffice, flags.MustInt64("libreoffice-restart-after"))
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (a *Api) Validate() error {
+	var err error
+
+	_, statErr := os.Stat(a.args.binPath)
+	if os.IsNotExist(statErr) {
+		err = multierr.Append(err, fmt.Errorf("LibreOffice binary path does not exist: %w", statErr))
+	}
+
+	_, statErr = os.Stat(a.args.unoBinPath)
+	if os.IsNotExist(statErr) {
+		err = multierr.Append(err, fmt.Errorf("unoconverter binary path does not exist: %w", statErr))
+	}
+
+	return err
+}
+
+// Start does nothing if auto-start is not enabled. Otherwise, it starts a
+// LibreOffice instance.
+func (a *Api) Start() error {
+	if !a.autoStart {
+		return nil
+	}
+
+	err := a.supervisor.Launch()
+	if err != nil {
+		return fmt.Errorf("launch supervisor: %w", err)
+	}
+
+	return nil
+}
+
+// StartupMessage returns a custom startup message.
+func (a *Api) StartupMessage() string {
+	if !a.autoStart {
+		return "LibreOffice ready to start"
+	}
+
+	return "LibreOffice automatically started"
+}
+
+// Stop stops the current browser instance.
+func (a *Api) Stop(ctx context.Context) error {
+	// Block until the context is done so that other module may gracefully stop
+	// before we do a shutdown.
+	a.logger.Debug("wait for the end of grace duration")
+
+	<-ctx.Done()
+
+	err := a.supervisor.Shutdown()
+	if err == nil {
+		return nil
+	}
+
+	return fmt.Errorf("stop LibreOffice: %w", err)
+}
+
+// Metrics returns the metrics.
+func (a *Api) Metrics() ([]gotenberg.Metric, error) {
+	return []gotenberg.Metric{
+		{
+			Name:        "libreoffice_requests_queue_size",
+			Description: "Current number of LibreOffice conversion requests waiting to be treated.",
+			Read: func() float64 {
+				return float64(a.supervisor.ReqQueueSize())
+			},
+		},
+		{
+			Name:        "libreoffice_restarts_count",
+			Description: "Current number of LibreOffice restarts.",
+			Read: func() float64 {
+				return float64(a.supervisor.RestartsCount())
+			},
+		},
+	}, nil
+}
+
+// Checks adds a health check that verifies if LibreOffice is healthy.
+func (a *Api) Checks() ([]health.CheckerOption, error) {
+	return []health.CheckerOption{
+		health.WithCheck(health.Check{
+			Name: "libreoffice",
+			Check: func(_ context.Context) error {
+				if a.supervisor.Healthy() {
+					return nil
+				}
+
+				return errors.New("LibreOffice is unhealthy")
+			},
+		}),
+	}, nil
+}
+
+// Ready returns no error if the module is ready.
+func (a *Api) Ready() error {
+	if !a.autoStart {
+		return nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), a.args.startTimeout)
+	defer cancel()
+
+	ticker := time.NewTicker(time.Duration(100) * time.Millisecond)
+
+	for {
+		select {
+		case <-ctx.Done():
+			ticker.Stop()
+			return fmt.Errorf("context done while waiting for LibreOffice to be ready: %w", ctx.Err())
+		case <-ticker.C:
+			ok := a.libreOffice.Healthy(a.logger)
+			if ok {
+				ticker.Stop()
+				return nil
+			}
+
+			continue
+		}
+	}
+}
+
+// LibreOffice returns a [Uno] for interacting with LibreOffice.
+func (a *Api) LibreOffice() (Uno, error) {
+	return a, nil
+}
+
+// Pdf converts a document to PDF.
+func (a *Api) Pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+	return a.supervisor.Run(ctx, logger, func() error {
+		return a.libreOffice.pdf(ctx, logger, inputPath, outputPath, options)
+	})
+}
+
+// Extensions returns the file extensions available for conversions.
+// FIXME: don't care, take all on the route level?
+func (a *Api) Extensions() []string {
+	return []string{
+		".bib",
+		".doc",
+		".xml",
+		".docx",
+		".fodt",
+		".html",
+		".ltx",
+		".txt",
+		".odt",
+		".ott",
+		".pdb",
+		".pdf",
+		".psw",
+		".rtf",
+		".sdw",
+		".stw",
+		".sxw",
+		".uot",
+		".vor",
+		".wps",
+		".epub",
+		".png",
+		".bmp",
+		".emf",
+		".eps",
+		".fodg",
+		".gif",
+		".jpg",
+		".jpeg",
+		".met",
+		".odd",
+		".otg",
+		".pbm",
+		".pct",
+		".pgm",
+		".ppm",
+		".ras",
+		".std",
+		".svg",
+		".svm",
+		".swf",
+		".sxd",
+		".sxw",
+		".tif",
+		".tiff",
+		".xhtml",
+		".xpm",
+		".odp",
+		".fodp",
+		".potm",
+		".pot",
+		".pptx",
+		".pps",
+		".ppt",
+		".pwp",
+		".sda",
+		".sdd",
+		".sti",
+		".sxi",
+		".uop",
+		".wmf",
+		".csv",
+		".dbf",
+		".dif",
+		".fods",
+		".ods",
+		".ots",
+		".pxl",
+		".sdc",
+		".slk",
+		".stc",
+		".sxc",
+		".uos",
+		".xls",
+		".xlt",
+		".xlsx",
+		".odg",
+		".dotx",
+		".xltx",
+	}
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module          = (*Api)(nil)
+	_ gotenberg.Provisioner     = (*Api)(nil)
+	_ gotenberg.Validator       = (*Api)(nil)
+	_ gotenberg.App             = (*Api)(nil)
+	_ gotenberg.MetricsProvider = (*Api)(nil)
+	_ api.HealthChecker         = (*Api)(nil)
+	_ Uno                       = (*Api)(nil)
+	_ Provider                  = (*Api)(nil)
+)
--- a/pkg/modules/libreoffice/api/api_test.go
+++ b/pkg/modules/libreoffice/api/api_test.go
@@ -0,0 +1,458 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"os"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/alexliesenfeld/health"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+func TestApi_Descriptor(t *testing.T) {
+	descriptor := new(Api).Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(Api))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestApi_Provision(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *gotenberg.Context
+		expectError bool
+	}{
+		{
+			scenario: "no logger provider",
+			ctx: func() *gotenberg.Context {
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "no logger from logger provider",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.LoggerProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
+				}
+				mod.LoggerMock = func(mod gotenberg.Module) (*zap.Logger, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "provision success",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.LoggerProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
+				}
+				mod.LoggerMock = func(mod gotenberg.Module) (*zap.Logger, error) {
+					return zap.NewNop(), nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			a := new(Api)
+			err := a.Provision(tc.ctx)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestApi_Validate(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		binPath     string
+		unoBinPath  string
+		expectError bool
+	}{
+		{
+			scenario:    "empty LibreOffice bin path",
+			binPath:     "",
+			unoBinPath:  os.Getenv("UNOCONVERTER_BIN_PATH"),
+			expectError: true,
+		},
+		{
+			scenario:    "LibreOffice bin path does not exist",
+			binPath:     "/foo",
+			unoBinPath:  os.Getenv("UNOCONVERTER_BIN_PATH"),
+			expectError: true,
+		},
+		{
+			scenario:    "empty uno bin path",
+			binPath:     os.Getenv("CHROMIUM_BIN_PATH"),
+			unoBinPath:  "",
+			expectError: true,
+		},
+		{
+			scenario:    "uno bin path does not exist",
+			binPath:     os.Getenv("CHROMIUM_BIN_PATH"),
+			unoBinPath:  "/foo",
+			expectError: true,
+		},
+		{
+			scenario:    "validate success",
+			binPath:     os.Getenv("CHROMIUM_BIN_PATH"),
+			unoBinPath:  os.Getenv("UNOCONVERTER_BIN_PATH"),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			a := new(Api)
+			a.args = libreOfficeArguments{
+				binPath:    tc.binPath,
+				unoBinPath: tc.unoBinPath,
+			}
+			err := a.Validate()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestApi_Start(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		autoStart   bool
+		supervisor  *gotenberg.ProcessSupervisorMock
+		expectError bool
+	}{
+		{
+			scenario:    "no auto-start",
+			autoStart:   false,
+			expectError: false,
+		},
+		{
+			scenario:  "auto-start success",
+			autoStart: true,
+			supervisor: &gotenberg.ProcessSupervisorMock{LaunchMock: func() error {
+				return nil
+			}},
+			expectError: false,
+		},
+		{
+			scenario:  "auto-start failed",
+			autoStart: true,
+			supervisor: &gotenberg.ProcessSupervisorMock{LaunchMock: func() error {
+				return errors.New("foo")
+			}},
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			a := new(Api)
+			a.autoStart = tc.autoStart
+			a.supervisor = tc.supervisor
+
+			err := a.Start()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestApi_StartupMessage(t *testing.T) {
+	a := new(Api)
+
+	a.autoStart = true
+	autoStartMsg := a.StartupMessage()
+
+	a.autoStart = false
+	noAutoStartMsg := a.StartupMessage()
+
+	if autoStartMsg == noAutoStartMsg {
+		t.Errorf("expected differrent startup messages based on auto start, but got '%s'", autoStartMsg)
+	}
+}
+
+func TestApi_Stop(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		supervisor  *gotenberg.ProcessSupervisorMock
+		expectError bool
+	}{
+		{
+			scenario: "stop success",
+			supervisor: &gotenberg.ProcessSupervisorMock{ShutdownMock: func() error {
+				return nil
+			}},
+			expectError: false,
+		},
+		{
+			scenario: "stop failed",
+			supervisor: &gotenberg.ProcessSupervisorMock{ShutdownMock: func() error {
+				return errors.New("foo")
+			}},
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			a := new(Api)
+			a.logger = zap.NewNop()
+			a.supervisor = tc.supervisor
+
+			ctx, cancel := context.WithTimeout(context.Background(), 0*time.Second)
+			cancel()
+
+			err := a.Stop(ctx)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestApi_Metrics(t *testing.T) {
+	a := new(Api)
+	a.supervisor = &gotenberg.ProcessSupervisorMock{
+		ReqQueueSizeMock: func() int64 {
+			return 10
+		},
+		RestartsCountMock: func() int64 {
+			return 0
+		},
+	}
+
+	metrics, err := a.Metrics()
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	if len(metrics) != 2 {
+		t.Fatalf("expected %d metrics, but got %d", 2, len(metrics))
+	}
+
+	actual := metrics[0].Read()
+	if actual != float64(10) {
+		t.Errorf("expected %f for libreoffice_requests_queue_size, but got %f", float64(10), actual)
+	}
+
+	actual = metrics[1].Read()
+	if actual != float64(0) {
+		t.Errorf("expected %f for libreoffice_restarts_count, but got %f", float64(0), actual)
+	}
+}
+
+func TestApi_Checks(t *testing.T) {
+	for _, tc := range []struct {
+		scenario                 string
+		supervisor               gotenberg.ProcessSupervisor
+		expectAvailabilityStatus health.AvailabilityStatus
+	}{
+		{
+			scenario: "healthy module",
+			supervisor: &gotenberg.ProcessSupervisorMock{HealthyMock: func() bool {
+				return true
+			}},
+			expectAvailabilityStatus: health.StatusUp,
+		},
+		{
+			scenario: "unhealthy module",
+			supervisor: &gotenberg.ProcessSupervisorMock{HealthyMock: func() bool {
+				return false
+			}},
+			expectAvailabilityStatus: health.StatusDown,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			a := new(Api)
+			a.supervisor = tc.supervisor
+
+			checks, err := a.Checks()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			checker := health.NewChecker(checks...)
+			result := checker.Check(context.Background())
+
+			if result.Status != tc.expectAvailabilityStatus {
+				t.Errorf("expected '%s' as availability status, but got '%s'", tc.expectAvailabilityStatus, result.Status)
+			}
+		})
+	}
+}
+
+func TestChromium_Ready(t *testing.T) {
+	for _, tc := range []struct {
+		scenario     string
+		autoStart    bool
+		startTimeout time.Duration
+		libreOffice  libreOffice
+		expectError  bool
+	}{
+		{
+			scenario:     "no auto-start",
+			autoStart:    false,
+			startTimeout: time.Duration(30) * time.Second,
+			libreOffice: &libreOfficeMock{ProcessMock: gotenberg.ProcessMock{HealthyMock: func(logger *zap.Logger) bool {
+				return false
+			}}},
+			expectError: false,
+		},
+		{
+			scenario:     "auto-start: context done",
+			autoStart:    true,
+			startTimeout: time.Duration(200) * time.Millisecond,
+			libreOffice: &libreOfficeMock{ProcessMock: gotenberg.ProcessMock{HealthyMock: func(logger *zap.Logger) bool {
+				return false
+			}}},
+			expectError: true,
+		},
+		{
+			scenario:     "auto-start success",
+			autoStart:    true,
+			startTimeout: time.Duration(30) * time.Second,
+			libreOffice: &libreOfficeMock{ProcessMock: gotenberg.ProcessMock{HealthyMock: func(logger *zap.Logger) bool {
+				return true
+			}}},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			a := new(Api)
+			a.autoStart = tc.autoStart
+			a.args = libreOfficeArguments{startTimeout: tc.startTimeout}
+			a.libreOffice = tc.libreOffice
+
+			err := a.Ready()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestApi_LibreOffice(t *testing.T) {
+	a := new(Api)
+
+	_, err := a.LibreOffice()
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestApi_Pdf(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		supervisor  gotenberg.ProcessSupervisor
+		libreOffice libreOffice
+		expectError bool
+	}{
+		{
+			scenario: "PDF task success",
+			libreOffice: &libreOfficeMock{pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+				return nil
+			}},
+			expectError: false,
+		},
+		{
+			scenario: "PDF task error",
+			libreOffice: &libreOfficeMock{pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+				return errors.New("PDF task error")
+			}},
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			a := new(Api)
+			a.supervisor = &gotenberg.ProcessSupervisorMock{RunMock: func(ctx context.Context, logger *zap.Logger, task func() error) error {
+				return task()
+			}}
+			a.libreOffice = tc.libreOffice
+
+			err := a.Pdf(context.Background(), zap.NewNop(), "", "", Options{})
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestApi_Extensions(t *testing.T) {
+	a := new(Api)
+	extensions := a.Extensions()
+
+	actual := len(extensions)
+	expect := 79
+
+	if actual != expect {
+		t.Errorf("expected %d extensions, but got %d", expect, actual)
+	}
+}
--- a/pkg/modules/libreoffice/api/doc.go
+++ b/pkg/modules/libreoffice/api/doc.go
@@ -0,0 +1,3 @@
+// Package api provides a module which manages a LibreOffice instance and
+// interacts with it via the UNO (Universal Network Objects) API.
+package api
--- a/pkg/modules/libreoffice/api/freeport.go
+++ b/pkg/modules/libreoffice/api/freeport.go
@@ -0,0 +1,31 @@
+package api
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+
+	"go.uber.org/zap"
+)
+
+func freePort(logger *zap.Logger) (int, error) {
+	netListener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		return 0, fmt.Errorf("listen on the local network address: %w", err)
+	}
+	defer func() {
+		err := netListener.Close()
+		if err != nil {
+			logger.Error(fmt.Sprintf("close network listener: %s", err.Error()))
+		}
+	}()
+
+	addr := netListener.Addr().String()
+
+	_, portStr, err := net.SplitHostPort(addr)
+	if err != nil {
+		return 0, fmt.Errorf("get free port from host: %w", err)
+	}
+
+	return strconv.Atoi(portStr)
+}
--- a/pkg/modules/libreoffice/api/libreoffice.go
+++ b/pkg/modules/libreoffice/api/libreoffice.go
@@ -0,0 +1,395 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/google/uuid"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+type libreOffice interface {
+	gotenberg.Process
+	pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
+}
+
+type libreOfficeArguments struct {
+	binPath      string
+	unoBinPath   string
+	startTimeout time.Duration
+}
+
+type libreOfficeProcess struct {
+	socketPort         int
+	userProfileDirPath string
+	cmd                *gotenberg.Cmd
+	cfgMu              sync.RWMutex
+	isStarted          atomic.Bool
+
+	arguments libreOfficeArguments
+	fs        *gotenberg.FileSystem
+}
+
+func newLibreOfficeProcess(arguments libreOfficeArguments) libreOffice {
+	p := &libreOfficeProcess{
+		arguments: arguments,
+		fs:        gotenberg.NewFileSystem(),
+	}
+	p.isStarted.Store(false)
+
+	return p
+}
+
+func (p *libreOfficeProcess) Start(logger *zap.Logger) error {
+	if p.isStarted.Load() {
+		return errors.New("LibreOffice is already started")
+	}
+
+	port, err := freePort(logger)
+	if err != nil {
+		return fmt.Errorf("get free port: %w", err)
+	}
+
+	userProfileDirPath := p.fs.NewDirPath()
+	args := []string{
+		"--headless",
+		"--invisible",
+		"--nocrashreport",
+		"--nodefault",
+		"--nologo",
+		"--nofirststartwizard",
+		"--norestore",
+		fmt.Sprintf("-env:UserInstallation=file://%s", userProfileDirPath),
+		fmt.Sprintf("--accept=socket,host=127.0.0.1,port=%d,tcpNoDelay=1;urp;StarOffice.ComponentContext", port),
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), p.arguments.startTimeout)
+	defer cancel()
+
+	cmd, err := gotenberg.CommandContext(ctx, logger, p.arguments.binPath, args...)
+	if err != nil {
+		return fmt.Errorf("create LibreOffice command: %w", err)
+	}
+
+	// For whatever reason, LibreOffice requires a first start before being
+	// able to run as a daemon.
+	exitCode, err := cmd.Exec()
+	if err != nil && exitCode != 81 {
+		return fmt.Errorf("execute LibreOffice: %w", err)
+	}
+
+	logger.Debug("got exit code 81, e.g., LibreOffice first start")
+
+	// Second start (daemon).
+	cmd = gotenberg.Command(logger, p.arguments.binPath, args...)
+
+	err = cmd.Start()
+	if err != nil {
+		return fmt.Errorf("start LibreOffice: %w", err)
+	}
+
+	waitChan := make(chan error, 1)
+
+	go func() {
+		// By waiting the process, we avoid the creation of a zombie process
+		// and make sure we catch an early exit if any.
+		waitChan <- cmd.Wait()
+	}()
+
+	connChan := make(chan error, 1)
+
+	go func() {
+		// As the LibreOffice socket may take some time to be available, we
+		// have to ensure that it is indeed accepting connections.
+		for {
+			if ctx.Err() != nil {
+				connChan <- ctx.Err()
+				break
+			}
+
+			conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", port), time.Duration(1)*time.Second)
+			if err != nil {
+				continue
+			}
+
+			connChan <- nil
+			err = conn.Close()
+			if err != nil {
+				logger.Debug(fmt.Sprintf("close connection after health checking the LibreOffice: %v", err))
+			}
+
+			break
+		}
+	}()
+
+	var success bool
+
+	defer func() {
+		if success {
+			p.cfgMu.Lock()
+			defer p.cfgMu.Unlock()
+
+			p.socketPort = port
+			p.userProfileDirPath = userProfileDirPath
+			p.cmd = cmd
+			p.isStarted.Store(true)
+
+			return
+		}
+
+		// Let's make sure the process is killed.
+		err = cmd.Kill()
+		if err != nil {
+			logger.Debug(fmt.Sprintf("kill LibreOffice process: %v", err))
+		}
+
+		// And the user profile directory is deleted.
+		err = os.RemoveAll(userProfileDirPath)
+		if err != nil {
+			logger.Error(fmt.Sprintf("remove LibreOffice's user profile directory: %v", err))
+		}
+
+		logger.Debug(fmt.Sprintf("'%s' LibreOffice's user profile directory removed", userProfileDirPath))
+	}()
+
+	logger.Debug("waiting for the LibreOffice socket to be available...")
+
+	for {
+		select {
+		case err = <-connChan:
+			if err != nil {
+				return fmt.Errorf("LibreOffice socket not available: %w", err)
+			}
+
+			logger.Debug("LibreOffice socket available")
+			success = true
+
+			return nil
+		case err = <-waitChan:
+			return fmt.Errorf("LibreOffice process exited: %w", err)
+		}
+	}
+}
+
+func (p *libreOfficeProcess) Stop(logger *zap.Logger) error {
+	if !p.isStarted.Load() {
+		// No big deal? Like calling cancel twice.
+		return nil
+	}
+
+	// Always remove the user profile directory created by LibreOffice.
+	copyUserProfileDirPath := p.userProfileDirPath
+	defer func(userProfileDirPath string) {
+		go func() {
+			err := os.RemoveAll(userProfileDirPath)
+			if err != nil {
+				logger.Error(fmt.Sprintf("remove LibreOffice's user profile directory: %v", err))
+			}
+
+			logger.Debug(fmt.Sprintf("'%s' LibreOffice's user profile directory removed", userProfileDirPath))
+
+			// Also remove LibreOffice specific files in the temporary directory.
+			err = gotenberg.GarbageCollect(logger, os.TempDir(), []string{"OSL_PIPE", ".tmp"})
+			if err != nil {
+				logger.Error(err.Error())
+			}
+		}()
+	}(copyUserProfileDirPath)
+
+	p.cfgMu.Lock()
+	defer p.cfgMu.Unlock()
+
+	err := p.cmd.Kill()
+	if err != nil {
+		return fmt.Errorf("kill LibreOffice process: %w", err)
+	}
+
+	p.socketPort = 0
+	p.userProfileDirPath = ""
+	p.cmd = nil
+	p.isStarted.Store(false)
+
+	return nil
+}
+
+func (p *libreOfficeProcess) Healthy(logger *zap.Logger) bool {
+	// Good to know: the supervisor does not call this method if no first start
+	// or if the process is restarting.
+
+	if !p.isStarted.Load() {
+		// Non-started browser but not restarting?
+		return false
+	}
+
+	p.cfgMu.RLock()
+	defer p.cfgMu.RUnlock()
+
+	conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", p.socketPort), time.Duration(10)*time.Second)
+	if err == nil {
+		err = conn.Close()
+		if err != nil {
+			logger.Debug(fmt.Sprintf("close connection after health checking LibreOffice: %v", err))
+		}
+
+		return true
+	}
+
+	return false
+}
+
+func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+	if !p.isStarted.Load() {
+		return errors.New("LibreOffice not started, cannot handle PDF conversion")
+	}
+
+	args := []string{
+		"--no-launch",
+		"--format",
+		"pdf",
+	}
+
+	args = append(args, "--port", fmt.Sprintf("%d", p.socketPort))
+
+	checkedEntry := logger.Check(zap.DebugLevel, "check for debug level before setting high verbosity")
+	if checkedEntry != nil {
+		args = append(args, "-vvv")
+	}
+
+	if options.Landscape {
+		args = append(args, "--printer", "PaperOrientation=landscape")
+	}
+
+	if options.PageRanges != "" {
+		args = append(args, "--export", fmt.Sprintf("PageRange=%s", options.PageRanges))
+	}
+
+	switch options.PdfFormats.PdfA {
+	case "":
+	case gotenberg.PdfA1b:
+		args = append(args, "--export", "SelectPdfVersion=1")
+	case gotenberg.PdfA2b:
+		args = append(args, "--export", "SelectPdfVersion=2")
+	case gotenberg.PdfA3b:
+		args = append(args, "--export", "SelectPdfVersion=3")
+	default:
+		return ErrInvalidPdfFormats
+	}
+
+	if options.PdfFormats.PdfUa {
+		args = append(
+			args,
+			"--export", "EnableTextAccessForAccessibilityTools=true",
+			"--export", "UseTaggedPDF=true",
+		)
+	}
+
+	inputPath, err := nonBasicLatinCharactersGuard(logger, inputPath)
+	if err != nil {
+		return fmt.Errorf("non-basic latin characters guard: %w", err)
+	}
+
+	args = append(args, "--output", outputPath, inputPath)
+
+	cmd, err := gotenberg.CommandContext(ctx, logger, p.arguments.unoBinPath, args...)
+	if err != nil {
+		return fmt.Errorf("create uno command: %w", err)
+	}
+
+	logger.Debug(fmt.Sprintf("print to PDF with: %+v", options))
+
+	exitCode, err := cmd.Exec()
+	if err == nil {
+		return nil
+	}
+
+	// LibreOffice's errors are not explicit.
+	// That's why we have to make an educated guess according to the exit code
+	// and given inputs.
+	if exitCode == 5 && options.PageRanges != "" {
+		return ErrMalformedPageRanges
+	}
+
+	// Possible errors:
+	// 1. LibreOffice failed for some reason.
+	// 2. Context done.
+	//
+	// On the second scenario, LibreOffice might not have time to remove some
+	// of its temporary files, as it has been killed without warning. The
+	// garbage collector will delete them for us (if the module is loaded).
+	return fmt.Errorf("convert to PDF: %w", err)
+}
+
+// LibreOffice cannot convert a file with a name containing non-basic Latin
+// characters.
+// See:
+// https://github.com/gotenberg/gotenberg/issues/104
+// https://github.com/gotenberg/gotenberg/issues/730
+func nonBasicLatinCharactersGuard(logger *zap.Logger, inputPath string) (string, error) {
+	hasNonBasicLatinChars := func(str string) bool {
+		for _, r := range str {
+			// Check if the character is outside basic Latin.
+			if r != '.' && (r < ' ' || r > '~') {
+				return true
+			}
+		}
+		return false
+	}
+
+	filename := filepath.Base(inputPath)
+	if !hasNonBasicLatinChars(filename) {
+		logger.Debug("no non-basic latin characters in filename, skip copy")
+		return inputPath, nil
+	}
+
+	logger.Warn("non-basic latin characters in filename, copy to a file with a valid filename")
+	basePath := filepath.Dir(inputPath)
+	ext := filepath.Ext(inputPath)
+	newInputPath := filepath.Join(basePath, fmt.Sprintf("%s%s", uuid.NewString(), ext))
+
+	in, err := os.Open(inputPath)
+	if err != nil {
+		return "", fmt.Errorf("open file: %w", err)
+	}
+
+	defer func() {
+		err := in.Close()
+		if err != nil {
+			logger.Error(fmt.Sprintf("close file: %s", err))
+		}
+	}()
+
+	out, err := os.Create(newInputPath)
+	if err != nil {
+		return "", fmt.Errorf("create new file: %w", err)
+	}
+
+	defer func() {
+		err := out.Close()
+		if err != nil {
+			logger.Error(fmt.Sprintf("close new file: %s", err))
+		}
+	}()
+
+	_, err = io.Copy(out, in)
+	if err != nil {
+		return "", fmt.Errorf("copy file to new file: %w", err)
+	}
+
+	return newInputPath, nil
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Process = (*libreOfficeProcess)(nil)
+	_ libreOffice       = (*libreOfficeProcess)(nil)
+)
--- a/pkg/modules/libreoffice/api/libreoffice_test.go
+++ b/pkg/modules/libreoffice/api/libreoffice_test.go
@@ -0,0 +1,650 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+func TestLibreOfficeProcess_Start(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		libreOffice libreOffice
+		expectError bool
+		cleanup     bool
+	}{
+		{
+			scenario: "successful start",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			expectError: false,
+			cleanup:     true,
+		},
+		{
+			scenario: "LibreOffice already started",
+			libreOffice: func() libreOffice {
+				p := new(libreOfficeProcess)
+				p.isStarted.Store(true)
+				return p
+			}(),
+			expectError: true,
+			cleanup:     false,
+		},
+		{
+			scenario: "non-exit code 81 on first start",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      "foo",
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			expectError: true,
+			cleanup:     false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+			err := tc.libreOffice.Start(logger)
+
+			if tc.cleanup {
+				defer func(p libreOffice, logger *zap.Logger) {
+					err = p.Stop(logger)
+					if err != nil {
+						t.Fatalf("expected no error while cleaning up, but got: %v", err)
+					}
+				}(tc.libreOffice, logger)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestLibreOfficeProcess_Stop(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		libreOffice libreOffice
+		setup       func(libreOffice libreOffice, logger *zap.Logger) error
+		expectError bool
+	}{
+		{
+			scenario: "successful stop",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			setup: func(p libreOffice, logger *zap.Logger) error {
+				return p.Start(logger)
+			},
+			expectError: false,
+		},
+		{
+			scenario: "LibreOffice already stopped",
+			libreOffice: func() libreOffice {
+				p := new(libreOfficeProcess)
+				p.isStarted.Store(false)
+				return p
+			}(),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			if tc.setup != nil {
+				err := tc.setup(tc.libreOffice, logger)
+				if err != nil {
+					t.Fatalf("setup error: %v", err)
+				}
+			}
+
+			err := tc.libreOffice.Stop(logger)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestLibreOfficeProcess_Healthy(t *testing.T) {
+	for _, tc := range []struct {
+		scenario      string
+		libreOffice   libreOffice
+		setup         func(libreOffice libreOffice, logger *zap.Logger) error
+		expectHealthy bool
+		cleanup       bool
+	}{
+		{
+			scenario: "healthy LibreOffice",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			setup: func(p libreOffice, logger *zap.Logger) error {
+				return p.Start(logger)
+			},
+			expectHealthy: true,
+			cleanup:       true,
+		},
+		{
+			scenario: "LibreOffice not started",
+			libreOffice: func() libreOffice {
+				p := new(libreOfficeProcess)
+				p.isStarted.Store(false)
+				return p
+			}(),
+			expectHealthy: false,
+			cleanup:       false,
+		},
+		{
+			scenario: "unhealthy LibreOffice",
+			libreOffice: func() libreOffice {
+				p := new(libreOfficeProcess)
+				p.isStarted.Store(true)
+				p.socketPort = 12345
+				return p
+			}(),
+			expectHealthy: false,
+			cleanup:       false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			if tc.setup != nil {
+				err := tc.setup(tc.libreOffice, logger)
+				if err != nil {
+					t.Fatalf("setup error: %v", err)
+				}
+			}
+
+			if tc.cleanup {
+				defer func(p libreOffice, logger *zap.Logger) {
+					err := p.Stop(logger)
+					if err != nil {
+						t.Fatalf("expected no error while cleaning up, but got: %v", err)
+					}
+				}(tc.libreOffice, logger)
+			}
+
+			healthy := tc.libreOffice.Healthy(logger)
+
+			if !tc.expectHealthy && healthy {
+				t.Fatal("expected unhealthy LibreOffice but got an healthy one")
+			}
+
+			if tc.expectHealthy && !healthy {
+				t.Fatal("expected a healthy LibreOffice but got an unhealthy one")
+			}
+		})
+	}
+}
+
+func TestLibreOfficeProcess_pdf(t *testing.T) {
+	for _, tc := range []struct {
+		scenario      string
+		libreOffice   libreOffice
+		fs            *gotenberg.FileSystem
+		options       Options
+		cancelledCtx  bool
+		start         bool
+		expectError   bool
+		expectedError error
+	}{
+		{
+			scenario: "LibreOffice not started",
+			libreOffice: func() libreOffice {
+				p := new(libreOfficeProcess)
+				p.isStarted.Store(false)
+				return p
+			}(),
+			fs:           gotenberg.NewFileSystem(),
+			cancelledCtx: false,
+			start:        false,
+			expectError:  true,
+		},
+		{
+			scenario: "ErrInvalidPdfFormats",
+			libreOffice: func() libreOffice {
+				p := new(libreOfficeProcess)
+				p.socketPort = 12345
+				p.isStarted.Store(true)
+				return p
+			}(),
+			fs:            gotenberg.NewFileSystem(),
+			options:       Options{PdfFormats: gotenberg.PdfFormats{PdfA: "foo"}},
+			cancelledCtx:  false,
+			start:         false,
+			expectError:   true,
+			expectedError: ErrInvalidPdfFormats,
+		},
+		{
+			scenario: "ErrMalformedPageRanges",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			options: Options{PageRanges: "foo"},
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("ErrMalformedPageRanges"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			cancelledCtx:  false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrMalformedPageRanges,
+		},
+		{
+			scenario: "context done",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Context done"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			cancelledCtx: true,
+			start:        true,
+			expectError:  true,
+		},
+		{
+			scenario: "success (default options)",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Success"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			cancelledCtx: false,
+			start:        true,
+			expectError:  false,
+		},
+		{
+			scenario: "success (landscape)",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Landscape"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options:      Options{Landscape: true},
+			cancelledCtx: false,
+			start:        true,
+			expectError:  false,
+		},
+		{
+			scenario: "success (page ranges)",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Landscape"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options:      Options{PageRanges: "1-1"},
+			cancelledCtx: false,
+			start:        true,
+			expectError:  false,
+		},
+		{
+			scenario: "success (PDF/A-1b)",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Landscape"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options:      Options{PdfFormats: gotenberg.PdfFormats{PdfA: gotenberg.PdfA1b}},
+			cancelledCtx: false,
+			start:        true,
+			expectError:  false,
+		},
+		{
+			scenario: "success (PDF/A-2b)",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Landscape"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options:      Options{PdfFormats: gotenberg.PdfFormats{PdfA: gotenberg.PdfA2b}},
+			cancelledCtx: false,
+			start:        true,
+			expectError:  false,
+		},
+		{
+			scenario: "success (PDF/A-3b)",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Landscape"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options:      Options{PdfFormats: gotenberg.PdfFormats{PdfA: gotenberg.PdfA3b}},
+			cancelledCtx: false,
+			start:        true,
+			expectError:  false,
+		},
+		{
+			scenario: "success (PDF/UA)",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Landscape"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options:      Options{PdfFormats: gotenberg.PdfFormats{PdfUa: true}},
+			cancelledCtx: false,
+			start:        true,
+			expectError:  false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			// Force the debug level.
+			logger := zap.NewExample()
+
+			defer func() {
+				err := os.RemoveAll(tc.fs.WorkingDirPath())
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up, but got: %v", err)
+				}
+			}()
+
+			if tc.start {
+				err := tc.libreOffice.Start(logger)
+				if err != nil {
+					t.Fatalf("setup error: %v", err)
+				}
+
+				defer func(p libreOffice, logger *zap.Logger) {
+					err = p.Stop(logger)
+					if err != nil {
+						t.Fatalf("expected no error while cleaning up, but got: %v", err)
+					}
+				}(tc.libreOffice, logger)
+			}
+
+			ctx, cancel := context.WithTimeout(context.Background(), time.Duration(5)*time.Second)
+			defer cancel()
+
+			if tc.cancelledCtx {
+				cancel()
+			}
+
+			err := tc.libreOffice.pdf(
+				ctx,
+				logger,
+				fmt.Sprintf("%s/document.txt", tc.fs.WorkingDirPath()),
+				fmt.Sprintf("%s/%s.pdf", tc.fs.WorkingDirPath(), uuid.NewString()),
+				tc.options,
+			)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+		})
+	}
+}
+
+func TestNonBasicLatinCharactersGuard(t *testing.T) {
+	for _, tc := range []struct {
+		scenario            string
+		fs                  *gotenberg.FileSystem
+		filename            string
+		expectSameInputPath bool
+		expectError         bool
+	}{
+		{
+			scenario: "basic latin characters",
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Basic latin characters"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			filename:            "document.txt",
+			expectSameInputPath: true,
+			expectError:         false,
+		},
+		{
+			scenario: "non-basic latin characters",
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem()
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/éèßàùä.txt", fs.WorkingDirPath()), []byte("Non-basic latin characters"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			filename:            "éèßàùä.txt",
+			expectSameInputPath: false,
+			expectError:         false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			defer func() {
+				err := os.RemoveAll(tc.fs.WorkingDirPath())
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up, but got: %v", err)
+				}
+			}()
+
+			inputPath := fmt.Sprintf("%s/%s", tc.fs.WorkingDirPath(), tc.filename)
+			newInputPath, err := nonBasicLatinCharactersGuard(
+				zap.NewNop(),
+				inputPath,
+			)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.expectSameInputPath && newInputPath != inputPath {
+				t.Fatalf("expected same input path, but got '%s'", newInputPath)
+			}
+
+			if !tc.expectSameInputPath && newInputPath == inputPath {
+				t.Fatalf("expected different input path, but got same '%s'", newInputPath)
+			}
+		})
+	}
+}
--- a/pkg/modules/libreoffice/api/mocks.go
+++ b/pkg/modules/libreoffice/api/mocks.go
@@ -0,0 +1,49 @@
+package api
+
+import (
+	"context"
+
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+// ApiMock is a mock for the [Uno] interface.
+type ApiMock struct {
+	PdfMock        func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
+	ExtensionsMock func() []string
+}
+
+func (api *ApiMock) Pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+	return api.PdfMock(ctx, logger, inputPath, outputPath, options)
+}
+
+func (api *ApiMock) Extensions() []string {
+	return api.ExtensionsMock()
+}
+
+// ProviderMock is a mock for the [Provider] interface.
+type ProviderMock struct {
+	LibreOfficeMock func() (Uno, error)
+}
+
+func (provider *ProviderMock) LibreOffice() (Uno, error) {
+	return provider.LibreOfficeMock()
+}
+
+// libreOfficeMock is a mock for the [libreOffice] interface.
+type libreOfficeMock struct {
+	gotenberg.ProcessMock
+	pdfMock func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
+}
+
+func (b *libreOfficeMock) pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+	return b.pdfMock(ctx, logger, inputPath, outputPath, options)
+}
+
+// Interface guards.
+var (
+	_ Uno         = (*ApiMock)(nil)
+	_ Provider    = (*ProviderMock)(nil)
+	_ libreOffice = (*libreOfficeMock)(nil)
+)
--- a/pkg/modules/libreoffice/api/mocks_test.go
+++ b/pkg/modules/libreoffice/api/mocks_test.go
@@ -0,0 +1,55 @@
+package api
+
+import (
+	"context"
+	"testing"
+
+	"go.uber.org/zap"
+)
+
+func TestApiMock(t *testing.T) {
+	mock := &ApiMock{
+		PdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+			return nil
+		},
+		ExtensionsMock: func() []string {
+			return nil
+		},
+	}
+
+	err := mock.Pdf(context.Background(), zap.NewNop(), "", "", Options{})
+	if err != nil {
+		t.Errorf("expected no error from ApiMock.Pdf, but got: %v", err)
+	}
+
+	ext := mock.Extensions()
+	if ext != nil {
+		t.Errorf("expected nil result from ApiMock.Extensions, but got: %v", ext)
+	}
+}
+
+func TestProviderMock(t *testing.T) {
+	mock := &ProviderMock{
+		LibreOfficeMock: func() (Uno, error) {
+			return nil, nil
+		},
+	}
+
+	_, err := mock.LibreOffice()
+	if err != nil {
+		t.Errorf("expected no error from ProviderMock.LibreOffice, but got: %v", err)
+	}
+}
+
+func TestLibreOfficeMock(t *testing.T) {
+	mock := &libreOfficeMock{
+		pdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+			return nil
+		},
+	}
+
+	err := mock.pdf(context.Background(), zap.NewNop(), "", "", Options{})
+	if err != nil {
+		t.Errorf("expected no error from libreOfficeMock.pdf, but got: %v", err)
+	}
+}
--- a/pkg/modules/libreoffice/doc.go
+++ b/pkg/modules/libreoffice/doc.go
@@ -1,3 +1,3 @@
 // Package libreoffice provides a module which adds a route for converting
-// document to PDF with LibreOffice.
+// documents to PDF with LibreOffice.
 package libreoffice
--- a/pkg/modules/libreoffice/libreoffice.go
+++ b/pkg/modules/libreoffice/libreoffice.go
@@ -3,26 +3,27 @@ package libreoffice
 import (
 	"fmt"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
 	flag "github.com/spf13/pflag"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
+	libeofficeapi "github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/api"
 )

 func init() {
-	gotenberg.MustRegisterModule(LibreOffice{})
+	gotenberg.MustRegisterModule(new(LibreOffice))
 }

 // LibreOffice is a module which provides a route for converting documents to
 // PDF with LibreOffice.
 type LibreOffice struct {
-	unoconv       unoconv.API
-	engine        gotenberg.PDFEngine
+	api           libeofficeapi.Uno
+	engine        gotenberg.PdfEngine
 	disableRoutes bool
 }

-// Descriptor returns a LibreOffice's module descriptor.
-func (LibreOffice) Descriptor() gotenberg.ModuleDescriptor {
+// Descriptor returns a [LibreOffice]'s module descriptor.
+func (mod *LibreOffice) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID: "libreoffice",
 		FlagSet: func() *flag.FlagSet {
@@ -40,24 +41,24 @@ func (mod *LibreOffice) Provision(ctx *gotenberg.Context) error {
 	flags := ctx.ParsedFlags()
 	mod.disableRoutes = flags.MustBool("libreoffice-disable-routes")

-	provider, err := ctx.Module(new(unoconv.Provider))
+	provider, err := ctx.Module(new(libeofficeapi.Provider))
 	if err != nil {
-		return fmt.Errorf("get unoconv provider: %w", err)
+		return fmt.Errorf("get LibreOffice Uno provider: %w", err)
 	}

-	uno, err := provider.(unoconv.Provider).Unoconv()
+	libreOfficeApi, err := provider.(libeofficeapi.Provider).LibreOffice()
 	if err != nil {
-		return fmt.Errorf("get unoconv API: %w", err)
+		return fmt.Errorf("get LibreOffice Uno: %w", err)
 	}

-	mod.unoconv = uno
+	mod.api = libreOfficeApi

-	provider, err = ctx.Module(new(gotenberg.PDFEngineProvider))
+	provider, err = ctx.Module(new(gotenberg.PdfEngineProvider))
 	if err != nil {
 		return fmt.Errorf("get PDF engine provider: %w", err)
 	}

-	engine, err := provider.(gotenberg.PDFEngineProvider).PDFEngine()
+	engine, err := provider.(gotenberg.PdfEngineProvider).PdfEngine()
 	if err != nil {
 		return fmt.Errorf("get PDF engine: %w", err)
 	}
@@ -67,20 +68,20 @@ func (mod *LibreOffice) Provision(ctx *gotenberg.Context) error {
 	return nil
 }

-// Routes returns the API routes.
-func (mod LibreOffice) Routes() ([]api.MultipartFormDataRoute, error) {
+// Routes returns the HTTP routes.
+func (mod *LibreOffice) Routes() ([]api.Route, error) {
 	if mod.disableRoutes {
 		return nil, nil
 	}

-	return []api.MultipartFormDataRoute{
-		convertRoute(mod.unoconv, mod.engine),
+	return []api.Route{
+		convertRoute(mod.api, mod.engine),
 	}, nil
 }

 // Interface guards.
 var (
-	_ gotenberg.Module            = (*LibreOffice)(nil)
-	_ gotenberg.Provisioner       = (*LibreOffice)(nil)
-	_ api.MultipartFormDataRouter = (*LibreOffice)(nil)
+	_ gotenberg.Module      = (*LibreOffice)(nil)
+	_ gotenberg.Provisioner = (*LibreOffice)(nil)
+	_ api.Router            = (*LibreOffice)(nil)
 )
--- a/pkg/modules/libreoffice/libreoffice_test.go
+++ b/pkg/modules/libreoffice/libreoffice_test.go
@@ -1,70 +1,16 @@
 package libreoffice

 import (
-	"context"
 	"errors"
 	"reflect"
 	"testing"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
-	"go.uber.org/zap"
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	libreofficeapi "github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/api"
 )

-type ProtoModule struct {
-	descriptor func() gotenberg.ModuleDescriptor
-}
-
-func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
-	return mod.descriptor()
-}
-
-type ProtoUnoconvProvider struct {
-	ProtoModule
-	unoconv func() (unoconv.API, error)
-}
-
-func (mod ProtoUnoconvProvider) Unoconv() (unoconv.API, error) {
-	return mod.unoconv()
-}
-
-type ProtoUnoconvAPI struct {
-	pdf        func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error
-	extensions func() []string
-}
-
-func (mod ProtoUnoconvAPI) PDF(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options unoconv.Options) error {
-	return mod.pdf(ctx, logger, inputPath, outputPath, options)
-}
-
-func (mod ProtoUnoconvAPI) Extensions() []string {
-	return mod.extensions()
-}
-
-type ProtoPDFEngineProvider struct {
-	ProtoModule
-	pdfEngine func() (gotenberg.PDFEngine, error)
-}
-
-func (mod ProtoPDFEngineProvider) PDFEngine() (gotenberg.PDFEngine, error) {
-	return mod.pdfEngine()
-}
-
-type ProtoPDFEngine struct {
-	merge   func(_ context.Context, _ *zap.Logger, _ []string, _ string) error
-	convert func(_ context.Context, _ *zap.Logger, _, _, _ string) error
-}
-
-func (mod ProtoPDFEngine) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-	return mod.merge(ctx, logger, inputPaths, outputPath)
-}
-
-func (mod ProtoPDFEngine) Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error {
-	return mod.convert(ctx, logger, format, inputPath, outputPath)
-}
-
 func TestLibreOffice_Descriptor(t *testing.T) {
-	descriptor := LibreOffice{}.Descriptor()
+	descriptor := new(LibreOffice).Descriptor()

 	actual := reflect.TypeOf(descriptor.New())
 	expect := reflect.TypeOf(new(LibreOffice))
@@ -75,35 +21,34 @@ func TestLibreOffice_Descriptor(t *testing.T) {
 }

 func TestLibreOffice_Provision(t *testing.T) {
-	for i, tc := range []struct {
-		ctx       *gotenberg.Context
-		expectErr bool
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *gotenberg.Context
+		expectError bool
 	}{
 		{
+			scenario: "no LibreOffice API provider",
 			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoModule }{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
-				}
-
 				return gotenberg.NewContext(
 					gotenberg.ParsedFlags{
 						FlagSet: new(LibreOffice).Descriptor().FlagSet,
 					},
-					[]gotenberg.ModuleDescriptor{
-						mod.Descriptor(),
-					},
+					[]gotenberg.ModuleDescriptor{},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
+			scenario: "no LibreOffice API from LibreOffice API provider",
 			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoUnoconvProvider }{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				mod := &struct {
+					gotenberg.ModuleMock
+					libreofficeapi.ProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
 				}
-				mod.unoconv = func() (unoconv.API, error) {
+				mod.LibreOfficeMock = func() (libreofficeapi.Uno, error) {
 					return nil, errors.New("foo")
 				}

@@ -116,16 +61,20 @@ func TestLibreOffice_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
+			scenario: "no PDF engine provider",
 			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoUnoconvProvider }{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				mod := &struct {
+					gotenberg.ModuleMock
+					libreofficeapi.ProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
 				}
-				mod.unoconv = func() (unoconv.API, error) {
-					return struct{ ProtoUnoconvAPI }{}, nil
+				mod.LibreOfficeMock = func() (libreofficeapi.Uno, error) {
+					return new(libreofficeapi.ApiMock), nil
 				}

 				return gotenberg.NewContext(
@@ -137,23 +86,23 @@ func TestLibreOffice_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
+			scenario: "no PDF engine from PDF engine provider",
 			ctx: func() *gotenberg.Context {
-				mod1 := struct{ ProtoUnoconvProvider }{}
-				mod1.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod1 }}
+				mod := &struct {
+					gotenberg.ModuleMock
+					libreofficeapi.ProviderMock
+					gotenberg.PdfEngineProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
 				}
-				mod1.unoconv = func() (unoconv.API, error) {
-					return struct{ ProtoUnoconvAPI }{}, nil
+				mod.LibreOfficeMock = func() (libreofficeapi.Uno, error) {
+					return new(libreofficeapi.ApiMock), nil
 				}
-
-				mod2 := struct{ ProtoPDFEngineProvider }{}
-				mod2.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod2 }}
-				}
-				mod2.pdfEngine = func() (gotenberg.PDFEngine, error) {
+				mod.PdfEngineMock = func() (gotenberg.PdfEngine, error) {
 					return nil, errors.New("foo")
 				}

@@ -162,29 +111,28 @@ func TestLibreOffice_Provision(t *testing.T) {
 						FlagSet: new(LibreOffice).Descriptor().FlagSet,
 					},
 					[]gotenberg.ModuleDescriptor{
-						mod1.Descriptor(),
-						mod2.Descriptor(),
+						mod.Descriptor(),
 					},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
+			scenario: "provision success",
 			ctx: func() *gotenberg.Context {
-				mod1 := struct{ ProtoUnoconvProvider }{}
-				mod1.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod1 }}
+				mod := &struct {
+					gotenberg.ModuleMock
+					libreofficeapi.ProviderMock
+					gotenberg.PdfEngineProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod }}
 				}
-				mod1.unoconv = func() (unoconv.API, error) {
-					return struct{ ProtoUnoconvAPI }{}, nil
+				mod.LibreOfficeMock = func() (libreofficeapi.Uno, error) {
+					return new(libreofficeapi.ApiMock), nil
 				}
-
-				mod2 := struct{ ProtoPDFEngineProvider }{}
-				mod2.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod2 }}
-				}
-				mod2.pdfEngine = func() (gotenberg.PDFEngine, error) {
-					return struct{ ProtoPDFEngine }{}, nil
+				mod.PdfEngineMock = func() (gotenberg.PdfEngine, error) {
+					return new(gotenberg.PdfEngineMock), nil
 				}

 				return gotenberg.NewContext(
@@ -192,59 +140,57 @@ func TestLibreOffice_Provision(t *testing.T) {
 						FlagSet: new(LibreOffice).Descriptor().FlagSet,
 					},
 					[]gotenberg.ModuleDescriptor{
-						mod1.Descriptor(),
-						mod2.Descriptor(),
+						mod.Descriptor(),
 					},
 				)
 			}(),
+			expectError: false,
 		},
 	} {
-		mod := new(LibreOffice)
-		err := mod.Provision(tc.ctx)
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(LibreOffice)
+			err := mod.Provision(tc.ctx)

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

 func TestLibreOffice_Routes(t *testing.T) {
-	for i, tc := range []struct {
+	for _, tc := range []struct {
+		scenario      string
 		expectRoutes  int
 		disableRoutes bool
 	}{
 		{
-			expectRoutes: 1,
+			scenario:      "routes not disabled",
+			expectRoutes:  1,
+			disableRoutes: false,
 		},
 		{
+			scenario:      "routes disabled",
+			expectRoutes:  0,
 			disableRoutes: true,
 		},
 	} {
-		mod := new(LibreOffice)
-		mod.disableRoutes = tc.disableRoutes
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(LibreOffice)
+			mod.disableRoutes = tc.disableRoutes

-		routes, err := mod.Routes()
-		if err != nil {
-			t.Fatalf("test %d: expected no error but got: %v", i, err)
-		}
+			routes, err := mod.Routes()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if tc.expectRoutes != len(routes) {
-			t.Errorf("test %d: expected %d routes but got %d", i, tc.expectRoutes, len(routes))
-		}
+			if tc.expectRoutes != len(routes) {
+				t.Errorf("expected %d routes but got %d", tc.expectRoutes, len(routes))
+			}
+		})
 	}
 }
-
-// Interface guards.
-var (
-	_ gotenberg.Module            = (*ProtoModule)(nil)
-	_ unoconv.Provider            = (*ProtoUnoconvProvider)(nil)
-	_ gotenberg.Module            = (*ProtoUnoconvProvider)(nil)
-	_ unoconv.API                 = (*ProtoUnoconvAPI)(nil)
-	_ gotenberg.PDFEngineProvider = (*ProtoPDFEngineProvider)(nil)
-	_ gotenberg.Module            = (*ProtoPDFEngineProvider)(nil)
-	_ gotenberg.PDFEngine         = (*ProtoPDFEngine)(nil)
-)
--- a/pkg/modules/libreoffice/pdfengine/doc.go
+++ b/pkg/modules/libreoffice/pdfengine/doc.go
@@ -1,3 +1,4 @@
-// Package pdfengine provides a module which abstracts the CLI tool unoconv and
-// implements the gotenberg.PDFEngine interface.
+// Package pdfengine provides a module which interacts with LibreOffice via the
+// UNO (Universal Network Objects) API and implements the gotenberg.PdfEngine
+// interface.
 package pdfengine
--- a/pkg/modules/libreoffice/pdfengine/pdfengine.go
+++ b/pkg/modules/libreoffice/pdfengine/pdfengine.go
@@ -2,75 +2,78 @@ package pdfengine

 import (
 	"context"
+	"errors"
 	"fmt"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/api"
 )

 func init() {
-	gotenberg.MustRegisterModule(UnoconvPDFEngine{})
+	gotenberg.MustRegisterModule(new(LibreOfficePdfEngine))
 }

-// UnoconvPDFEngine abstracts the CLI tool unoconv and implements the
-// gotenberg.PDFEngine interface.
-type UnoconvPDFEngine struct {
-	unoconv unoconv.API
+// LibreOfficePdfEngine interacts with the LibreOffice (Universal Network Objects) API
+// and implements the [gotenberg.PdfEngine] interface.
+type LibreOfficePdfEngine struct {
+	unoApi api.Uno
 }

-// Descriptor returns a UnoconvPDFEngine's module descriptor.
-func (engine UnoconvPDFEngine) Descriptor() gotenberg.ModuleDescriptor {
+// Descriptor returns a [LibreOfficePdfEngine]'s module descriptor.
+func (engine *LibreOfficePdfEngine) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
-		ID:  "unoconv-pdfengine",
-		New: func() gotenberg.Module { return new(UnoconvPDFEngine) },
+		ID:  "libreoffice-pdfengine",
+		New: func() gotenberg.Module { return new(LibreOfficePdfEngine) },
 	}
 }

 // Provision sets the module properties.
-func (engine *UnoconvPDFEngine) Provision(ctx *gotenberg.Context) error {
-	provider, err := ctx.Module(new(unoconv.Provider))
+func (engine *LibreOfficePdfEngine) Provision(ctx *gotenberg.Context) error {
+	provider, err := ctx.Module(new(api.Provider))
 	if err != nil {
-		return fmt.Errorf("get unoconv provider: %w", err)
+		return fmt.Errorf("get LibreOffice Uno provider: %w", err)
 	}

-	uno, err := provider.(unoconv.Provider).Unoconv()
+	unoApi, err := provider.(api.Provider).LibreOffice()
 	if err != nil {
-		return fmt.Errorf("get unoconv API: %w", err)
+		return fmt.Errorf("get LibreOffice Uno: %w", err)
 	}

-	engine.unoconv = uno
+	engine.unoApi = unoApi

 	return nil
 }

-// Merge is not available for this PDF engine.
-func (engine UnoconvPDFEngine) Merge(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-	return fmt.Errorf("merge PDFs with unoconv: %w", gotenberg.ErrPDFEngineMethodNotAvailable)
+// Merge is not available in this implementation.
+func (engine *LibreOfficePdfEngine) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+	return fmt.Errorf("merge PDFs with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }

 // Convert converts the given PDF to a specific PDF format. Currently, only the
-// PDF/A-1 format is available. If another PDF format is requested, it returns
-// a gotenberg.ErrPDFFormatNotAvailable error.
-func (engine UnoconvPDFEngine) Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error {
-	if format != gotenberg.FormatPDFA1a {
-		return fmt.Errorf("convert PDF to '%s' with unoconv: %w", format, gotenberg.ErrPDFFormatNotAvailable)
-	}
-
-	err := engine.unoconv.PDF(ctx, logger, inputPath, outputPath, unoconv.Options{
-		PDFArchive: true,
+// PDF/A-1b, PDF/A-2b, PDF/A-3b and PDF/UA formats are available. If another
+// PDF format is requested, it returns a [gotenberg.ErrPdfFormatNotSupported]
+// error.
+func (engine *LibreOfficePdfEngine) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	err := engine.unoApi.Pdf(ctx, logger, inputPath, outputPath, api.Options{
+		PdfFormats: formats,
 	})

 	if err == nil {
 		return nil
 	}

-	return fmt.Errorf("convert PDF to '%s' with unoconv: %w", format, err)
+	if errors.Is(err, api.ErrInvalidPdfFormats) {
+		return fmt.Errorf("convert PDF to '%+v' with LibreOffice: %w", formats, gotenberg.ErrPdfFormatNotSupported)
+	}
+
+	return fmt.Errorf("convert PDF to '%+v' with LibreOffice: %w", formats, err)
 }

 // Interface guards.
 var (
-	_ gotenberg.Module      = (*UnoconvPDFEngine)(nil)
-	_ gotenberg.Provisioner = (*UnoconvPDFEngine)(nil)
-	_ gotenberg.PDFEngine   = (*UnoconvPDFEngine)(nil)
+	_ gotenberg.Module      = (*LibreOfficePdfEngine)(nil)
+	_ gotenberg.Provisioner = (*LibreOfficePdfEngine)(nil)
+	_ gotenberg.PdfEngine   = (*LibreOfficePdfEngine)(nil)
 )
--- a/pkg/modules/libreoffice/pdfengine/pdfengine_test.go
+++ b/pkg/modules/libreoffice/pdfengine/pdfengine_test.go
@@ -6,192 +6,163 @@ import (
 	"reflect"
 	"testing"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
-	flag "github.com/spf13/pflag"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/api"
 )

-type ProtoModule struct {
-	descriptor func() gotenberg.ModuleDescriptor
-}
-
-func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
-	return mod.descriptor()
-}
-
-type ProtoUnoconvProvider struct {
-	ProtoModule
-	unoconv func() (unoconv.API, error)
-}
-
-func (mod ProtoUnoconvProvider) Unoconv() (unoconv.API, error) {
-	return mod.unoconv()
-}
-
-type ProtoUnoconvAPI struct {
-	pdf func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options unoconv.Options) error
-}
-
-func (mod ProtoUnoconvAPI) PDF(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options unoconv.Options) error {
-	return mod.pdf(ctx, logger, inputPath, outputPath, options)
-}
-
-func (mod ProtoUnoconvAPI) Extensions() []string {
-	return nil
-}
-
-func TestUnoconvPDFEngine_Descriptor(t *testing.T) {
-	descriptor := UnoconvPDFEngine{}.Descriptor()
+func TestLibreOfficePdfEngine_Descriptor(t *testing.T) {
+	descriptor := new(LibreOfficePdfEngine).Descriptor()

 	actual := reflect.TypeOf(descriptor.New())
-	expect := reflect.TypeOf(new(UnoconvPDFEngine))
+	expect := reflect.TypeOf(new(LibreOfficePdfEngine))

 	if actual != expect {
 		t.Errorf("expected '%s' but got '%s'", expect, actual)
 	}
 }

-func TestUnoconvPDFEngine_Provision(t *testing.T) {
-	for i, tc := range []struct {
-		ctx       *gotenberg.Context
-		expectErr bool
+func TestLibreOfficePdfEngine_Provider(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *gotenberg.Context
+		expectError bool
 	}{
 		{
-			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoModule }{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
-				}
-
-				return gotenberg.NewContext(
-					gotenberg.ParsedFlags{
-						FlagSet: flag.NewFlagSet("foo", flag.ExitOnError),
-					},
-					[]gotenberg.ModuleDescriptor{
-						mod.Descriptor(),
-					},
-				)
-			}(),
-			expectErr: true,
+			scenario: "no LibreOffice API provider",
+			ctx: gotenberg.NewContext(
+				gotenberg.ParsedFlags{
+					FlagSet: new(LibreOfficePdfEngine).Descriptor().FlagSet,
+				},
+				[]gotenberg.ModuleDescriptor{},
+			),
+			expectError: true,
 		},
 		{
+			scenario: "no API from LibreOffice API provider",
 			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoUnoconvProvider }{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				provider := &struct {
+					gotenberg.ModuleMock
+					api.ProviderMock
+				}{}
+				provider.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module {
+						return provider
+					}}
 				}
-				mod.unoconv = func() (unoconv.API, error) {
+				provider.LibreOfficeMock = func() (api.Uno, error) {
 					return nil, errors.New("foo")
 				}

 				return gotenberg.NewContext(
 					gotenberg.ParsedFlags{
-						FlagSet: flag.NewFlagSet("foo", flag.ExitOnError),
+						FlagSet: new(LibreOfficePdfEngine).Descriptor().FlagSet,
 					},
 					[]gotenberg.ModuleDescriptor{
-						mod.Descriptor(),
+						provider.Descriptor(),
 					},
 				)
 			}(),
-			expectErr: true,
+			expectError: true,
 		},
 		{
+			scenario: "provision success",
 			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoUnoconvProvider }{}
-				mod.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				provider := &struct {
+					gotenberg.ModuleMock
+					api.ProviderMock
+				}{}
+				provider.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module {
+						return provider
+					}}
 				}
-				mod.unoconv = func() (unoconv.API, error) {
-					return struct{ ProtoUnoconvAPI }{}, nil
+				provider.LibreOfficeMock = func() (api.Uno, error) {
+					return new(api.ApiMock), nil
 				}

 				return gotenberg.NewContext(
 					gotenberg.ParsedFlags{
-						FlagSet: flag.NewFlagSet("foo", flag.ExitOnError),
+						FlagSet: new(LibreOfficePdfEngine).Descriptor().FlagSet,
 					},
 					[]gotenberg.ModuleDescriptor{
-						mod.Descriptor(),
+						provider.Descriptor(),
 					},
 				)
 			}(),
+			expectError: false,
 		},
 	} {
-		mod := new(UnoconvPDFEngine)
-		err := mod.Provision(tc.ctx)
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(LibreOfficePdfEngine)
+			err := engine.Provision(tc.ctx)

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

-func TestUnoconvPDFEngine_Merge(t *testing.T) {
-	mod := new(UnoconvPDFEngine)
-	err := mod.Merge(context.TODO(), zap.NewNop(), nil, "")
+func TestLibreOfficePdfEngine_Merge(t *testing.T) {
+	engine := new(LibreOfficePdfEngine)
+	err := engine.Merge(context.Background(), zap.NewNop(), nil, "")

-	if !errors.Is(err, gotenberg.ErrPDFEngineMethodNotAvailable) {
-		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPDFEngineMethodNotAvailable, err)
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
 	}
 }

-func TestUnoconvPDFEngine_Convert(t *testing.T) {
-	for i, tc := range []struct {
-		api       unoconv.API
-		format    string
-		expectErr bool
+func TestLibreOfficePdfEngine_Convert(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		api         api.Uno
+		expectError bool
 	}{
 		{
-			format:    "",
-			expectErr: true,
-		},
-		{
-			api: func() unoconv.API {
-				unoconvAPI := struct{ ProtoUnoconvAPI }{}
-				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, __ string, _ unoconv.Options) error {
-					return errors.New("foo")
-				}
-
-				return unoconvAPI
-			}(),
-			format:    gotenberg.FormatPDFA1a,
-			expectErr: true,
-		},
-		{
-			api: func() unoconv.API {
-				unoconvAPI := struct{ ProtoUnoconvAPI }{}
-				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, __ string, _ unoconv.Options) error {
+			scenario: "convert success",
+			api: &api.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options api.Options) error {
 					return nil
-				}
-
-				return unoconvAPI
-			}(),
-			format: gotenberg.FormatPDFA1a,
+				},
+			},
+			expectError: false,
+		},
+		{
+			scenario: "invalid PDF format",
+			api: &api.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options api.Options) error {
+					return api.ErrInvalidPdfFormats
+				},
+			},
+			expectError: true,
+		},
+		{
+			scenario: "convert fail",
+			api: &api.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options api.Options) error {
+					return errors.New("foo")
+				},
+			},
+			expectError: true,
 		},
 	} {
-		mod := new(UnoconvPDFEngine)
-		mod.unoconv = tc.api
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := &LibreOfficePdfEngine{unoApi: tc.api}
+			err := engine.Convert(context.Background(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")

-		err := mod.Convert(context.TODO(), zap.NewNop(), tc.format, "", "")
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }
-
-// Interface guards.
-var (
-	_ gotenberg.Module = (*ProtoModule)(nil)
-	_ unoconv.Provider = (*ProtoUnoconvProvider)(nil)
-	_ gotenberg.Module = (*ProtoUnoconvProvider)(nil)
-	_ unoconv.API      = (*ProtoUnoconvAPI)(nil)
-)
--- a/pkg/modules/libreoffice/routes.go
+++ b/pkg/modules/libreoffice/routes.go
@@ -5,67 +5,82 @@ import (
 	"fmt"
 	"net/http"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	"github.com/labstack/echo/v4"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
+	libreofficeapi "github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/api"
 )

-// convertRoute returns an api.MultipartFormDataRoute which can convert
-// LibreOffice documents to PDF.
-func convertRoute(uno unoconv.API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/libreoffice/convert",
-		Handler: func(ctx *api.Context) error {
+// convertRoute returns an [api.Route] which can convert LibreOffice documents
+// to PDF.
+func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/libreoffice/convert",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+
 			// Let's get the data from the form and validate them.
 			var (
-				inputPaths         []string
-				landscape          bool
-				nativePageRanges   string
-				nativePDFA1aFormat bool
-				PDFformat          string
-				merge              bool
+				inputPaths       []string
+				landscape        bool
+				nativePageRanges string
+				pdfa             string
+				pdfua            bool
+				nativePdfFormats bool
+				merge            bool
 			)

 			err := ctx.FormData().
-				MandatoryPaths(uno.Extensions(), &inputPaths).
+				MandatoryPaths(libreOffice.Extensions(), &inputPaths).
 				Bool("landscape", &landscape, false).
 				String("nativePageRanges", &nativePageRanges, "").
-				Bool("nativePdfA1aFormat", &nativePDFA1aFormat, false).
-				String("pdfFormat", &PDFformat, "").
+				String("pdfa", &pdfa, "").
+				Bool("pdfua", &pdfua, false).
+				Bool("nativePdfFormats", &nativePdfFormats, true).
 				Bool("merge", &merge, false).
 				Validate()
-
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			if nativePDFA1aFormat && PDFformat != "" {
-				return api.WrapError(
-					errors.New("got both 'pdfFormat' and 'nativePdfA1aFormat' form values"),
-					api.NewSentinelHTTPError(http.StatusBadRequest, "Both 'pdfFormat' and 'nativePdfA1aFormat' form values are provided"),
-				)
+			pdfFormats := gotenberg.PdfFormats{
+				PdfA:  pdfa,
+				PdfUa: pdfua,
 			}

 			// Alright, let's convert each document to PDF.
-
 			outputPaths := make([]string, len(inputPaths))
-
 			for i, inputPath := range inputPaths {
 				outputPaths[i] = ctx.GeneratePath(".pdf")

-				options := unoconv.Options{
+				options := libreofficeapi.Options{
 					Landscape:  landscape,
 					PageRanges: nativePageRanges,
-					PDFArchive: nativePDFA1aFormat,
 				}

-				err = uno.PDF(ctx, ctx.Log(), inputPath, outputPaths[i], options)
+				if nativePdfFormats {
+					options.PdfFormats = pdfFormats
+				}

+				err = libreOffice.Pdf(ctx, ctx.Log(), inputPath, outputPaths[i], options)
 				if err != nil {
-					if errors.Is(err, unoconv.ErrMalformedPageRanges) {
+					if errors.Is(err, libreofficeapi.ErrInvalidPdfFormats) {
 						return api.WrapError(
 							fmt.Errorf("convert to PDF: %w", err),
-							api.NewSentinelHTTPError(http.StatusBadRequest, fmt.Sprintf("Malformed page ranges '%s' (nativePageRanges)", options.PageRanges)),
+							api.NewSentinelHttpError(
+								http.StatusBadRequest,
+								fmt.Sprintf("A PDF format in '%+v' is not supported", pdfFormats),
+							),
+						)
+					}
+
+					if errors.Is(err, libreofficeapi.ErrMalformedPageRanges) {
+						return api.WrapError(
+							fmt.Errorf("convert to PDF: %w", err),
+							api.NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Malformed page ranges '%s' (nativePageRanges)", options.PageRanges)),
 						)
 					}

@@ -85,26 +100,20 @@ func convertRoute(uno unoconv.API, engine gotenberg.PDFEngine) api.MultipartForm
 				}

 				// Now, let's check if the client want to convert this result
-				// PDF to a specific PDF format.
-
-				// Note: nativePdfA1aFormat has not been specified if we reach
-				// this part of the code. Indeed, the handler returns early on
-				// an error if both nativePdfA1aFormat and pdfFormat are
-				// present.
-
-				if PDFformat != "" {
+				// PDF to specific PDF formats.
+				zeroValued := gotenberg.PdfFormats{}
+				if !nativePdfFormats && pdfFormats != zeroValued {
 					convertInputPath := outputPath
 					convertOutputPath := ctx.GeneratePath(".pdf")

-					err = engine.Convert(ctx, ctx.Log(), PDFformat, convertInputPath, convertOutputPath)
-
+					err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)
 					if err != nil {
-						if errors.Is(err, gotenberg.ErrPDFFormatNotAvailable) {
+						if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
 							return api.WrapError(
 								fmt.Errorf("convert PDF: %w", err),
-								api.NewSentinelHTTPError(
+								api.NewSentinelHttpError(
 									http.StatusBadRequest,
-									fmt.Sprintf("At least one PDF engine does not handle the PDF format '%s' (pdfFormat), while other have failed to convert for other reasons", PDFformat),
+									fmt.Sprintf("At least one PDF engine does not handle one of the PDF format in '%+v', while other have failed to convert for other reasons", pdfFormats),
 								),
 							)
 						}
@@ -117,7 +126,7 @@ func convertRoute(uno unoconv.API, engine gotenberg.PDFEngine) api.MultipartForm
 				}

 				// Last but not least, add the output path to the context so that
-				// the API is able to send it as a response to the client.
+				// the Uno is able to send it as a response to the client.

 				err = ctx.AddOutputPaths(outputPath)
 				if err != nil {
@@ -129,27 +138,22 @@ func convertRoute(uno unoconv.API, engine gotenberg.PDFEngine) api.MultipartForm

 			// Ok, we don't have to merge the PDFs. Let's check if the client
 			// want to convert each PDF to a specific PDF format.
-
-			// Note: nativePdfA1aFormat has not been specified if we reach this
-			// part of the code. Indeed, the handler returns early on an error
-			// if both nativePdfA1aFormat and pdfFormat are present.
-
-			if PDFformat != "" {
+			zeroValued := gotenberg.PdfFormats{}
+			if !nativePdfFormats && pdfFormats != zeroValued {
 				convertOutputPaths := make([]string, len(outputPaths))

 				for i, outputPath := range outputPaths {
 					convertInputPath := outputPath
 					convertOutputPaths[i] = ctx.GeneratePath(".pdf")

-					err = engine.Convert(ctx, ctx.Log(), PDFformat, convertInputPath, convertOutputPaths[i])
-
+					err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPaths[i])
 					if err != nil {
-						if errors.Is(err, gotenberg.ErrPDFFormatNotAvailable) {
+						if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
 							return api.WrapError(
 								fmt.Errorf("convert PDF: %w", err),
-								api.NewSentinelHTTPError(
+								api.NewSentinelHttpError(
 									http.StatusBadRequest,
-									fmt.Sprintf("At least one PDF engine does not handle the PDF format '%s' (pdfFormat), while other have failed to convert for other reasons", PDFformat),
+									fmt.Sprintf("At least one PDF engine does not handle one of the PDF format in '%+v', while other have failed to convert for other reasons", pdfFormats),
 								),
 							)
 						}
@@ -164,7 +168,7 @@ func convertRoute(uno unoconv.API, engine gotenberg.PDFEngine) api.MultipartForm
 			}

 			// Last but not least, add the output paths to the context so that
-			// the API is able to send them as a response to the client.
+			// the Uno is able to send them as a response to the client.

 			err = ctx.AddOutputPaths(outputPaths...)
 			if err != nil {
--- a/pkg/modules/libreoffice/routes_test.go
+++ b/pkg/modules/libreoffice/routes_test.go
--- a/pkg/modules/libreoffice/unoconv/doc.go
+++ b/pkg/modules/libreoffice/unoconv/doc.go
@@ -1,2 +0,0 @@
-// Package unoconv provides a module which abstracts the CLI tool unoconv.
-package unoconv
--- a/pkg/modules/libreoffice/unoconv/unoconv.go
+++ b/pkg/modules/libreoffice/unoconv/unoconv.go
@@ -1,287 +0,0 @@
-package unoconv
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"go.uber.org/zap"
-)
-
-func init() {
-	gotenberg.MustRegisterModule(Unoconv{})
-}
-
-// ErrMalformedPageRanges happens if the page ranges option cannot be
-// interpreted by LibreOffice.
-var ErrMalformedPageRanges = errors.New("page ranges are malformed")
-
-// Unoconv is a module which provides an API to interact with unoconv.
-type Unoconv struct {
-	binPath string
-}
-
-// Options gathers available options when converting a document to PDF.
-type Options struct {
-	// Landscape allows to change the orientation of the resulting PDF.
-	// Optional.
-	Landscape bool
-
-	// PageRanges allows to select the pages to convert.
-	// TODO: should prefer a method form PDFEngine.
-	// Optional.
-	PageRanges string
-
-	// PDFArchive allows to convert the resulting PDF to PDF/A-1a.
-	// In a module, prefer the Convert method from the gotenberg.PDFEngine
-	// interface.
-	// Optional.
-	PDFArchive bool
-}
-
-// API is an abstraction on top of unoconv.
-//
-// See https://github.com/unoconv/unoconv.
-type API interface {
-	PDF(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
-	Extensions() []string
-}
-
-// Provider is a module interface which exposes a method for creating an API
-// for other modules.
-//
-//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
-//		provider, _ := ctx.Module(new(unoconv.Provider))
-//		uno, _      := provider.(unoconv.Provider).Unoconv()
-//	}
-type Provider interface {
-	Unoconv() (API, error)
-}
-
-// Descriptor returns a Unoconv's module descriptor.
-func (Unoconv) Descriptor() gotenberg.ModuleDescriptor {
-	return gotenberg.ModuleDescriptor{
-		ID:  "unoconv",
-		New: func() gotenberg.Module { return new(Unoconv) },
-	}
-}
-
-// Provision sets the module properties. It returns an error if the environment
-// variable UNOCONV_BIN_PATH is not set.
-func (mod *Unoconv) Provision(_ *gotenberg.Context) error {
-	binPath, ok := os.LookupEnv("UNOCONV_BIN_PATH")
-	if !ok {
-		return errors.New("UNOCONV_BIN_PATH environment variable is not set")
-	}
-
-	mod.binPath = binPath
-
-	return nil
-}
-
-// Validate validates the module properties.
-func (mod Unoconv) Validate() error {
-	_, err := os.Stat(mod.binPath)
-	if os.IsNotExist(err) {
-		return fmt.Errorf("unoconv binary path does not exist: %w", err)
-	}
-
-	return nil
-}
-
-// Unoconv returns an API for interacting with unoconv.
-func (mod Unoconv) Unoconv() (API, error) {
-	return mod, nil
-}
-
-// PDF converts a document to PDF. It creates a dedicated LibreOffice instance
-// thanks to a custom user profile directory and a free port. Substantial calls
-// to this method may increase CPU and memory usage drastically. In such a
-// scenario, the given context may also be done before the end of the
-// conversion.
-func (mod Unoconv) PDF(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
-	port, err := func() (int, error) {
-		listener, err := net.Listen("tcp", "127.0.0.1:0")
-		if err != nil {
-			return 0, fmt.Errorf("listen on the local network address: %w", err)
-		}
-		defer func() {
-			err := listener.Close()
-			if err != nil {
-				logger.Error(fmt.Sprintf("close listener: %s", err.Error()))
-			}
-		}()
-
-		addr := listener.Addr().String()
-
-		_, portStr, err := net.SplitHostPort(addr)
-		if err != nil {
-			return 0, fmt.Errorf("get free port from host: %w", err)
-		}
-
-		return strconv.Atoi(portStr)
-	}()
-
-	if err != nil {
-		return fmt.Errorf("get free port: %w", err)
-	}
-
-	userProfileDirPath := gotenberg.NewDirPath()
-
-	args := []string{
-		"--user-profile",
-		fmt.Sprintf("//%s", userProfileDirPath),
-		"--port",
-		fmt.Sprintf("%d", port),
-		"--format",
-		"pdf",
-	}
-
-	if options.Landscape {
-		args = append(args, "--printer", "PaperOrientation=landscape")
-	}
-
-	if options.PageRanges != "" {
-		args = append(args, "--export", fmt.Sprintf("PageRange=%s", options.PageRanges))
-	}
-
-	if options.PDFArchive {
-		args = append(args, "--export", "SelectPdfVersion=1")
-	}
-
-	args = append(args, "--output", outputPath, inputPath)
-
-	cmd, err := gotenberg.CommandContext(ctx, logger, mod.binPath, args...)
-	if err != nil {
-		return fmt.Errorf("create unoconv command: %w", err)
-	}
-
-	logger.Debug(fmt.Sprintf("print to PDF with: %+v", options))
-
-	err = cmd.Exec()
-
-	// Always remove the user profile directory created by LibreOffice.
-	// See https://github.com/gotenberg/gotenberg/issues/192.
-	go func() {
-		logger.Debug(fmt.Sprintf("remove user profile directory '%s'", userProfileDirPath))
-
-		err := os.RemoveAll(userProfileDirPath)
-		if err != nil {
-			logger.Error(fmt.Sprintf("remove user profile directory: %s", err))
-		}
-	}()
-
-	if err == nil {
-		return nil
-	}
-
-	// Unoconv/LibreOffice errors are not explicit.
-	// That's why we have to make an educated guess according to the exit code
-	// and given inputs.
-
-	if strings.Contains(err.Error(), "exit status 5") && options.PageRanges != "" {
-		return ErrMalformedPageRanges
-	}
-
-	// Possible errors:
-	// 1. Unoconv/LibreOffice failed for some reason.
-	// 2. Context done.
-	//
-	// On the second scenario, LibreOffice might not had time to remove some of
-	// its temporary files, as it has been killed without warning. The garbage
-	// collector will delete them for us (if the module is loaded).
-	return fmt.Errorf("unoconv PDF: %w", err)
-}
-
-// Extensions returns the file extensions available with unoconv.
-func (mod Unoconv) Extensions() []string {
-	return []string{
-		".bib",
-		".doc",
-		".xml",
-		".docx",
-		".fodt",
-		".html",
-		".ltx",
-		".txt",
-		".odt",
-		".ott",
-		".pdb",
-		".pdf",
-		".psw",
-		".rtf",
-		".sdw",
-		".stw",
-		".sxw",
-		".uot",
-		".vor",
-		".wps",
-		".epub",
-		".png",
-		".bmp",
-		".emf",
-		".eps",
-		".fodg",
-		".gif",
-		".jpg",
-		".met",
-		".odd",
-		".otg",
-		".pbm",
-		".pct",
-		".pgm",
-		".ppm",
-		".ras",
-		".std",
-		".svg",
-		".svm",
-		".swf",
-		".sxd",
-		".sxw",
-		".tiff",
-		".xhtml",
-		".xpm",
-		".fodp",
-		".potm",
-		".pot",
-		".pptx",
-		".pps",
-		".ppt",
-		".pwp",
-		".sda",
-		".sdd",
-		".sti",
-		".sxi",
-		".uop",
-		".wmf",
-		".csv",
-		".dbf",
-		".dif",
-		".fods",
-		".ods",
-		".ots",
-		".pxl",
-		".sdc",
-		".slk",
-		".stc",
-		".sxc",
-		".uos",
-		".xls",
-		".xlt",
-		".xlsx",
-	}
-}
-
-// Interface guards.
-var (
-	_ gotenberg.Module      = (*Unoconv)(nil)
-	_ gotenberg.Provisioner = (*Unoconv)(nil)
-	_ gotenberg.Validator   = (*Unoconv)(nil)
-	_ API                   = (*Unoconv)(nil)
-	_ Provider              = (*Unoconv)(nil)
-)
--- a/pkg/modules/libreoffice/unoconv/unoconv_test.go
+++ b/pkg/modules/libreoffice/unoconv/unoconv_test.go
@@ -1,154 +0,0 @@
-package unoconv
-
-import (
-	"context"
-	"os"
-	"reflect"
-	"testing"
-
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"go.uber.org/zap"
-)
-
-func TestUnoconv_Descriptor(t *testing.T) {
-	descriptor := Unoconv{}.Descriptor()
-
-	actual := reflect.TypeOf(descriptor.New())
-	expect := reflect.TypeOf(new(Unoconv))
-
-	if actual != expect {
-		t.Errorf("expected '%'s' but got '%s'", expect, actual)
-	}
-}
-
-func TestUnoconv_Provision(t *testing.T) {
-	mod := new(Unoconv)
-	ctx := gotenberg.NewContext(gotenberg.ParsedFlags{}, nil)
-
-	err := mod.Provision(ctx)
-	if err != nil {
-		t.Errorf("expected no error but got: %v", err)
-	}
-}
-
-func TestUnoconv_Validate(t *testing.T) {
-	for i, tc := range []struct {
-		binPath   string
-		expectErr bool
-	}{
-		{
-			expectErr: true,
-		},
-		{
-			binPath:   "/foo",
-			expectErr: true,
-		},
-		{
-			binPath: os.Getenv("UNOCONV_BIN_PATH"),
-		},
-	} {
-		mod := new(Unoconv)
-		mod.binPath = tc.binPath
-		err := mod.Validate()
-
-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
-	}
-}
-
-func TestUnoconv_Unoconv(t *testing.T) {
-	mod := new(Unoconv)
-
-	_, err := mod.Unoconv()
-	if err != nil {
-		t.Errorf("expected no error but got: %v", err)
-	}
-}
-
-func TestUnoconv_PDF(t *testing.T) {
-	for i, tc := range []struct {
-		ctx       context.Context
-		inputPath string
-		options   Options
-		expectErr bool
-	}{
-		{
-			expectErr: true,
-		},
-		{
-			ctx:       context.Background(),
-			inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
-			options: Options{
-				Landscape:  true,
-				PageRanges: "1-2",
-				PDFArchive: true,
-			},
-		},
-		{
-			ctx:       context.Background(),
-			inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
-			options: Options{
-				PageRanges: "foo",
-			},
-			expectErr: true,
-		},
-		{
-			ctx: func() context.Context {
-				ctx, cancel := context.WithCancel(context.TODO())
-				defer cancel()
-
-				return ctx
-			}(),
-			inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
-			expectErr: true,
-		},
-	} {
-		func() {
-			mod := new(Unoconv)
-
-			err := mod.Provision(nil)
-			if err != nil {
-				t.Fatalf("test %d: expected error but got: %v", i, err)
-			}
-
-			outputDir, err := gotenberg.MkdirAll()
-			if err != nil {
-				t.Fatalf("test %d: expected error but got: %v", i, err)
-			}
-
-			defer func() {
-				err := os.RemoveAll(outputDir)
-				if err != nil {
-					t.Fatalf("test %d: expected no error but got: %v", i, err)
-				}
-			}()
-
-			err = mod.PDF(tc.ctx, zap.NewNop(), tc.inputPath, outputDir+"/foo.pdf", tc.options)
-
-			if tc.expectErr && err == nil {
-				t.Errorf("test %d: expected error but got: %v", i, err)
-			}
-
-			if !tc.expectErr && err != nil {
-				t.Errorf("test %d: expected no error but got: %v", i, err)
-			}
-		}()
-	}
-}
-
-func TestUnoconv_Extensions(t *testing.T) {
-	mod := new(Unoconv)
-	extensions := mod.Extensions()
-
-	actual := len(extensions)
-	expect := 73
-
-	if actual != expect {
-		t.Errorf("expected %d extensions but got %d", expect, actual)
-	}
-}
--- a/pkg/modules/logging/doc.go
+++ b/pkg/modules/logging/doc.go
@@ -1,3 +1,3 @@
-// Package logging provides a module which creates a zap.Logger for other
-// modules.
+// Package logging provides a module which creates a zap.Logger instance for
+// other modules.
 package logging
--- a/pkg/modules/logging/logging.go
+++ b/pkg/modules/logging/logging.go
@@ -5,16 +5,17 @@ import (
 	"os"
 	"time"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/multierr"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 	"golang.org/x/term"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

 func init() {
-	gotenberg.MustRegisterModule(Logging{})
+	gotenberg.MustRegisterModule(new(Logging))
 }

 const (
@@ -30,20 +31,23 @@ const (
 	textLoggingFormat = "text"
 )

-// Logging is a module which implements the gotenberg.LoggerProvider interface.
+// Logging is a module which implements the [gotenberg.LoggerProvider]
+// interface.
 type Logging struct {
-	level  string
-	format string
+	level        string
+	format       string
+	fieldsPrefix string
 }

-// Descriptor returns a Logging's module descriptor.
-func (Logging) Descriptor() gotenberg.ModuleDescriptor {
+// Descriptor returns a [Logging]'s module descriptor.
+func (log *Logging) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID: "logging",
 		FlagSet: func() *flag.FlagSet {
 			fs := flag.NewFlagSet("logging", flag.ExitOnError)
-			fs.String("log-level", infoLoggingLevel, fmt.Sprintf("Set the log level - %s, %s, %s, or %s", errorLoggingLevel, warnLoggingLevel, infoLoggingLevel, debugLoggingLevel))
-			fs.String("log-format", autoLoggingFormat, fmt.Sprintf("Set log format - %s, %s, or %s", autoLoggingFormat, jsonLoggingFormat, textLoggingFormat))
+			fs.String("log-level", infoLoggingLevel, fmt.Sprintf("Choose the level of logging detail. Options include %s, %s, %s, or %s", errorLoggingLevel, warnLoggingLevel, infoLoggingLevel, debugLoggingLevel))
+			fs.String("log-format", autoLoggingFormat, fmt.Sprintf("Specify the format of logging. Options include %s, %s, or %s", autoLoggingFormat, jsonLoggingFormat, textLoggingFormat))
+			fs.String("log-fields-prefix", "", "Prepend a specified prefix to each field in the logs")

 			return fs
 		}(),
@@ -57,12 +61,13 @@ func (log *Logging) Provision(ctx *gotenberg.Context) error {

 	log.level = flags.MustString("log-level")
 	log.format = flags.MustString("log-format")
+	log.fieldsPrefix = flags.MustString("log-fields-prefix")

 	return nil
 }

 // Validate validates the log level and format.
-func (log Logging) Validate() error {
+func (log *Logging) Validate() error {
 	var err error

 	switch log.level {
@@ -88,8 +93,8 @@ func (log Logging) Validate() error {
 	return err
 }

-// Logger returns a zap.Logger.
-func (log Logging) Logger(mod gotenberg.Module) (*zap.Logger, error) {
+// Logger returns a [zap.Logger].
+func (log *Logging) Logger(mod gotenberg.Module) (*zap.Logger, error) {
 	if logger == nil {
 		lvl, err := newLogLevel(log.level)
 		if err != nil {
@@ -101,29 +106,64 @@ func (log Logging) Logger(mod gotenberg.Module) (*zap.Logger, error) {
 			return nil, fmt.Errorf("get log encoder: %w", err)
 		}

-		core := zapcore.NewCore(encoder, os.Stderr, lvl)
-		logger = zap.New(core)
-
-		// nolint
-		defer logger.Sync()
+		logger = zap.New(customCore{
+			Core:         zapcore.NewCore(encoder, os.Stderr, lvl),
+			fieldsPrefix: log.fieldsPrefix,
+		})
 	}

 	return logger.Named(mod.Descriptor().ID), nil
 }

-func newLogLevel(level string) (zapcore.Level, error) {
-	switch level {
-	case errorLoggingLevel:
-		return zap.ErrorLevel, nil
-	case warnLoggingLevel:
-		return zap.WarnLevel, nil
-	case infoLoggingLevel:
-		return zap.InfoLevel, nil
-	case debugLoggingLevel:
-		return zap.DebugLevel, nil
-	default:
-		return -2, fmt.Errorf("%s is not a recognized log level", level)
+// See https://github.com/gotenberg/gotenberg/issues/659.
+type customCore struct {
+	zapcore.Core
+	fieldsPrefix string
+}
+
+func (c customCore) With(fields []zapcore.Field) zapcore.Core {
+	if c.fieldsPrefix != "" {
+		for i := range fields {
+			fields[i].Key = c.fieldsPrefix + "_" + fields[i].Key
+		}
 	}
+
+	return customCore{
+		Core:         c.Core.With(fields),
+		fieldsPrefix: c.fieldsPrefix,
+	}
+}
+
+func (c customCore) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
+	// This is a copy from the zapcore.ioCore implementation. Indeed, by doing
+	// so, we are able to prefix the fields given to the logger methods like
+	// Debug, Info, Warn, Error, etc.
+	if c.Enabled(ent.Level) {
+		return ce.AddCore(ent, c)
+	}
+
+	return ce
+}
+
+func (c customCore) Write(entry zapcore.Entry, fields []zapcore.Field) error {
+	if c.fieldsPrefix != "" {
+		for i := range fields {
+			fields[i].Key = c.fieldsPrefix + "_" + fields[i].Key
+		}
+	}
+
+	return c.Core.Write(entry, fields)
+}
+
+func newLogLevel(level string) (zapcore.Level, error) {
+	lvl := zapcore.InvalidLevel
+
+	err := lvl.UnmarshalText([]byte(level))
+	if err != nil {
+		return lvl, fmt.Errorf("%q is not a recognized log level: %w", level, err)
+	}
+
+	return lvl, nil
 }

 func newLogEncoder(format string) (zapcore.Encoder, error) {
@@ -158,6 +198,7 @@ func newLogEncoder(format string) (zapcore.Encoder, error) {
 	}
 }

+// Singleton so that we instantiate our logger only once.
 var logger *zap.Logger = nil

 // Interface guards.
@@ -166,4 +207,5 @@ var (
 	_ gotenberg.Provisioner    = (*Logging)(nil)
 	_ gotenberg.Validator      = (*Logging)(nil)
 	_ gotenberg.LoggerProvider = (*Logging)(nil)
+	_ zapcore.Core             = (*customCore)(nil)
 )
--- a/pkg/modules/logging/logging_test.go
+++ b/pkg/modules/logging/logging_test.go
@@ -1,23 +1,19 @@
 package logging

 import (
+	"fmt"
 	"reflect"
 	"testing"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
+	"go.uber.org/zap/zaptest/observer"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

-type ProtoModule struct {
-	descriptor func() gotenberg.ModuleDescriptor
-}
-
-func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
-	return mod.descriptor()
-}
-
 func TestLogging_Descriptor(t *testing.T) {
-	descriptor := Logging{}.Descriptor()
+	descriptor := new(Logging).Descriptor()

 	actual := reflect.TypeOf(descriptor.New())
 	expect := reflect.TypeOf(new(Logging))
@@ -28,172 +24,324 @@ func TestLogging_Descriptor(t *testing.T) {
 }

 func TestLogging_Provision(t *testing.T) {
-	logging := new(Logging)
-	fs := logging.Descriptor().FlagSet
+	for _, tc := range []struct {
+		scenario           string
+		level              string
+		format             string
+		fieldsPrefix       string
+		expectLevel        string
+		expectFormat       string
+		expectFieldsPrefix string
+	}{
+		{
+			scenario:           "default values",
+			expectLevel:        infoLoggingLevel,
+			expectFormat:       autoLoggingFormat,
+			expectFieldsPrefix: "",
+		},
+		{
+			scenario:           "explicit values",
+			level:              "debug",
+			format:             "json",
+			fieldsPrefix:       "gotenberg",
+			expectLevel:        debugLoggingLevel,
+			expectFormat:       jsonLoggingFormat,
+			expectFieldsPrefix: "gotenberg",
+		},
+		{
+			scenario:           "wrong values", // no validation at this point.
+			level:              "foo",
+			format:             "foo",
+			expectLevel:        "foo",
+			expectFormat:       "foo",
+			expectFieldsPrefix: "",
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			var flags []string

-	err := fs.Parse([]string{""})
-	if err != nil {
-		t.Fatalf("expected no error but got: %v", err)
-	}
+			if tc.level != "" {
+				flags = append(flags, "--log-level", tc.level)
+			}

-	ctx := gotenberg.NewContext(gotenberg.ParsedFlags{FlagSet: fs}, nil)
+			if tc.format != "" {
+				flags = append(flags, "--log-format", tc.format)
+			}

-	err = logging.Provision(ctx)
-	if err != nil {
-		t.Errorf("expected no error but got: %v", err)
+			if tc.fieldsPrefix != "" {
+				flags = append(flags, "--log-fields-prefix", tc.fieldsPrefix)
+			}
+
+			logging := new(Logging)
+			fs := logging.Descriptor().FlagSet
+
+			err := fs.Parse(flags)
+			if err != nil {
+				t.Fatalf("expected no error while parsing flags but got: %v", err)
+			}
+
+			ctx := gotenberg.NewContext(gotenberg.ParsedFlags{FlagSet: fs}, nil)
+
+			err = logging.Provision(ctx)
+			if err != nil {
+				t.Fatalf("expected no error while provisioning but got: %v", err)
+			}
+
+			if logging.level != tc.expectLevel {
+				t.Errorf("expected logging level '%s' but got '%s'", tc.expectLevel, logging.level)
+			}
+
+			if logging.format != tc.expectFormat {
+				t.Errorf("expected logging format '%s' but got '%s'", tc.expectFormat, logging.format)
+			}
+
+			if logging.fieldsPrefix != tc.expectFieldsPrefix {
+				t.Errorf("expected logging fields prefix '%s' but got '%s'", tc.expectFieldsPrefix, logging.fieldsPrefix)
+			}
+		})
 	}
 }

 func TestLogging_Validate(t *testing.T) {
-	for i, tc := range []struct {
-		level, format string
-		expectErr     bool
+	for _, tc := range []struct {
+		scenario    string
+		level       string
+		format      string
+		expectError bool
 	}{
 		{
-			level:     "foo",
-			expectErr: true,
+			scenario:    "invalid level",
+			level:       "foo",
+			expectError: true,
 		},
 		{
-			level:     debugLoggingLevel,
-			format:    "foo",
-			expectErr: true,
+			scenario:    "invalid format",
+			level:       debugLoggingLevel,
+			format:      "foo",
+			expectError: true,
 		},
 		{
-			level:  debugLoggingLevel,
-			format: autoLoggingFormat,
+			scenario: "valid level and format",
+			level:    debugLoggingLevel,
+			format:   autoLoggingFormat,
 		},
 	} {
-		mod := new(Logging)
-		mod.level = tc.level
-		mod.format = tc.format
+		logging := new(Logging)
+		logging.level = tc.level
+		logging.format = tc.format

-		err := mod.Validate()
+		err := logging.Validate()

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
+		if tc.expectError && err == nil {
+			t.Errorf("%s: expected error but got: %v", tc.scenario, err)
 		}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
+		if !tc.expectError && err != nil {
+			t.Errorf("%s: expected no error but got: %v", tc.scenario, err)
 		}
 	}
 }

 func TestLogging_Logger(t *testing.T) {
-	for i, tc := range []struct {
-		level, format string
-		expectErr     bool
+	for _, tc := range []struct {
+		scenario     string
+		level        string
+		format       string
+		fieldsPrefix string
+		expectError  bool
 	}{
 		{
-			level:     "foo",
-			expectErr: true,
+			scenario:    "invalid level",
+			level:       "foo",
+			expectError: true,
 		},
 		{
-			level:     debugLoggingLevel,
-			format:    "foo",
-			expectErr: true,
+			scenario:    "invalid format",
+			level:       debugLoggingLevel,
+			format:      "foo",
+			expectError: true,
 		},
 		{
-			level:  debugLoggingLevel,
-			format: autoLoggingFormat,
+			scenario: "valid level and format",
+			level:    debugLoggingLevel,
+			format:   autoLoggingFormat,
 		},
 	} {
-		mod := new(Logging)
-		mod.level = tc.level
-		mod.format = tc.format
+		t.Run(tc.scenario, func(t *testing.T) {
+			logging := new(Logging)
+			logging.level = tc.level
+			logging.format = tc.format
+			logging.fieldsPrefix = tc.fieldsPrefix

-		_, err := mod.Logger(ProtoModule{
-			descriptor: func() gotenberg.ModuleDescriptor {
-				return gotenberg.ModuleDescriptor{ID: "foo", New: nil}
-			},
+			_, err := logging.Logger(&gotenberg.ModuleMock{
+				DescriptorMock: func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "mock", New: nil}
+				},
+			})
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
 		})
-
-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
 	}
 }

-func TestNewLogLevel(t *testing.T) {
-	for i, tc := range []struct {
-		level          string
-		expectZapLevel zapcore.Level
-		expectErr      bool
+func TestCustomCore(t *testing.T) {
+	for _, tc := range []struct {
+		scenario     string
+		level        zapcore.Level
+		fieldsPrefix string
+		expectEntry  bool
 	}{
 		{
+			scenario:     "level enabled",
+			level:        zapcore.DebugLevel,
+			fieldsPrefix: "gotenberg",
+			expectEntry:  true,
+		},
+		{
+			scenario:    "no fields prefix",
+			level:       zapcore.DebugLevel,
+			expectEntry: true,
+		},
+		{
+			scenario: "level disabled",
+			level:    zapcore.ErrorLevel,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			core, obsvr := observer.New(tc.level)
+			lgr := zap.New(customCore{
+				Core:         core,
+				fieldsPrefix: tc.fieldsPrefix,
+			}).With(zap.String("a_field", "a value"))
+
+			lgr.Debug("a debug message", zap.String("another_field", "another value"))
+
+			entries := obsvr.TakeAll()
+
+			if tc.expectEntry && len(entries) == 0 {
+				t.Fatal("expected an entry")
+			}
+
+			if !tc.expectEntry && len(entries) != 0 {
+				t.Fatal("expected no entry")
+			}
+
+			var prefix string
+			if tc.fieldsPrefix != "" {
+				prefix = tc.fieldsPrefix + "_"
+			}
+
+			for _, entry := range entries {
+				fields := entry.Context
+
+				if len(fields) != 2 {
+					t.Fatalf("expected 2 fields but got %d", len(fields))
+				}
+
+				if fields[0].Key != fmt.Sprintf("%sa_field", prefix) {
+					t.Errorf("expected 'gotenberg_a_field' but got '%s'", fields[0].Key)
+				}
+
+				if fields[1].Key != fmt.Sprintf("%sanother_field", prefix) {
+					t.Errorf("expected 'gotenberg_another_field' but got '%s'", fields[1].Key)
+				}
+			}
+		})
+	}
+}
+
+func Test_newLogLevel(t *testing.T) {
+	for _, tc := range []struct {
+		scenario       string
+		level          string
+		expectZapLevel zapcore.Level
+		expectError    bool
+	}{
+		{
+			scenario:       "error level",
 			level:          errorLoggingLevel,
 			expectZapLevel: zapcore.ErrorLevel,
 		},
 		{
+			scenario:       "warning level",
 			level:          warnLoggingLevel,
 			expectZapLevel: zapcore.WarnLevel,
 		},
 		{
+			scenario:       "info level",
 			level:          infoLoggingLevel,
 			expectZapLevel: zapcore.InfoLevel,
 		},
 		{
+			scenario:       "debug level",
 			level:          debugLoggingLevel,
 			expectZapLevel: zapcore.DebugLevel,
 		},
 		{
+			scenario:       "invalid level",
 			level:          "foo",
-			expectZapLevel: -2,
-			expectErr:      true,
+			expectZapLevel: zapcore.InvalidLevel,
+			expectError:    true,
 		},
 	} {
-		actual, err := newLogLevel(tc.level)
+		t.Run(tc.scenario, func(t *testing.T) {
+			actual, err := newLogLevel(tc.level)

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if tc.expectZapLevel != actual {
-			t.Errorf("test %d: expected %d level but got %d", i, tc.expectZapLevel, actual)
-		}
+			if tc.expectZapLevel != actual {
+				t.Errorf("expected %d level but got %d", tc.expectZapLevel, actual)
+			}
+		})
 	}
 }

-func TestNewLogEncoder(t *testing.T) {
-	for i, tc := range []struct {
-		format    string
-		expectErr bool
+func Test_newLogEncoder(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		format      string
+		expectError bool
 	}{
 		{
-			format: autoLoggingFormat,
+			scenario: "auto format",
+			format:   autoLoggingFormat,
 		},
 		{
-			format: textLoggingFormat,
+			scenario: "text format",
+			format:   textLoggingFormat,
 		},
 		{
-			format: jsonLoggingFormat,
+			scenario: "json format",
+			format:   jsonLoggingFormat,
 		},
 		{
-			format:    "foo",
-			expectErr: true,
+			scenario:    "invalid format",
+			format:      "foo",
+			expectError: true,
 		},
 	} {
-		_, err := newLogEncoder(tc.format)
+		t.Run(tc.scenario, func(t *testing.T) {
+			_, err := newLogEncoder(tc.format)

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Errorf("expected no error but got: %v", err)
+			}
+		})
 	}
 }
-
-// Interface guards.
-var (
-	_ gotenberg.Module = (*ProtoModule)(nil)
-)
--- a/pkg/modules/pdfcpu/doc.go
+++ b/pkg/modules/pdfcpu/doc.go
@@ -1,4 +1,6 @@
-// Package pdfcpu provides a module which wraps the
-// https://github.com/pdfcpu/pdfcpu library and implements the
-// gotenberg.PDFEngine interface.
+// Package pdfcpu provides an implementation of the gotenberg.PdfEngine
+// interface using the pdfcpu library. This package allows for the merging of
+// PDF files but does not support conversion to specific PDF formats.
+//
+// See: https://github.com/pdfcpu/pdfcpu.
 package pdfcpu
--- a/pkg/modules/pdfcpu/pdfcpu.go
+++ b/pkg/modules/pdfcpu/pdfcpu.go
@@ -4,44 +4,44 @@ import (
 	"context"
 	"fmt"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	pdfcpuAPI "github.com/pdfcpu/pdfcpu/pkg/api"
 	pdfcpuLog "github.com/pdfcpu/pdfcpu/pkg/log"
-	pdfcpuConfig "github.com/pdfcpu/pdfcpu/pkg/pdfcpu"
+	pdfcpuConfig "github.com/pdfcpu/pdfcpu/pkg/pdfcpu/model"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

 func init() {
-	gotenberg.MustRegisterModule(PDFcpu{})
+	gotenberg.MustRegisterModule(new(PdfCpu))
 }

-// PDFcpu is a module which wraps the https://github.com/pdfcpu/pdfcpu library
-// and implements the gotenberg.PDFEngine interface.
-type PDFcpu struct {
+// PdfCpu abstracts the pdfcpu library and implements the [gotenberg.PdfEngine]
+// interface.
+type PdfCpu struct {
 	conf *pdfcpuConfig.Configuration
 }

-// Descriptor returns a PDFcpu's module descriptor.
-func (engine PDFcpu) Descriptor() gotenberg.ModuleDescriptor {
+// Descriptor returns a [PdfCpu]'s module descriptor.
+func (engine *PdfCpu) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID:  "pdfcpu",
-		New: func() gotenberg.Module { return new(PDFcpu) },
+		New: func() gotenberg.Module { return new(PdfCpu) },
 	}
 }

 // Provision sets the engine properties.
-func (engine *PDFcpu) Provision(_ *gotenberg.Context) error {
+func (engine *PdfCpu) Provision(ctx *gotenberg.Context) error {
 	pdfcpuConfig.ConfigPath = "disable"
 	pdfcpuLog.DisableLoggers()
-
 	engine.conf = pdfcpuConfig.NewDefaultConfiguration()

 	return nil
 }

-// Merge merges the given PDFs into a unique PDF.
-func (engine PDFcpu) Merge(_ context.Context, _ *zap.Logger, inputPaths []string, outputPath string) error {
-	err := pdfcpuAPI.MergeCreateFile(inputPaths, outputPath, engine.conf)
+// Merge combines multiple PDFs into a single PDF.
+func (engine *PdfCpu) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+	err := pdfcpuAPI.MergeCreateFile(inputPaths, outputPath, false, engine.conf)
 	if err == nil {
 		return nil
 	}
@@ -49,14 +49,14 @@ func (engine PDFcpu) Merge(_ context.Context, _ *zap.Logger, inputPaths []string
 	return fmt.Errorf("merge PDFs with PDFcpu: %w", err)
 }

-// Convert is not available for this PDF engine.
-func (engine PDFcpu) Convert(_ context.Context, _ *zap.Logger, format, _, _ string) error {
-	return fmt.Errorf("convert PDF to '%s' with PDFcpu: %w", format, gotenberg.ErrPDFEngineMethodNotAvailable)
+// Convert is not available in this implementation.
+func (engine *PdfCpu) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	return fmt.Errorf("convert PDF to '%+v' with PDFcpu: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }

 // Interface guards.
 var (
-	_ gotenberg.Module      = (*PDFcpu)(nil)
-	_ gotenberg.Provisioner = (*PDFcpu)(nil)
-	_ gotenberg.PDFEngine   = (*PDFcpu)(nil)
+	_ gotenberg.Module      = (*PdfCpu)(nil)
+	_ gotenberg.Provisioner = (*PdfCpu)(nil)
+	_ gotenberg.PdfEngine   = (*PdfCpu)(nil)
 )
--- a/pkg/modules/pdfcpu/pdfcpu_test.go
+++ b/pkg/modules/pdfcpu/pdfcpu_test.go
@@ -7,92 +7,98 @@ import (
 	"reflect"
 	"testing"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

-func TestPDFcpu_Descriptor(t *testing.T) {
-	descriptor := PDFcpu{}.Descriptor()
+func TestPdfCpu_Descriptor(t *testing.T) {
+	descriptor := new(PdfCpu).Descriptor()

 	actual := reflect.TypeOf(descriptor.New())
-	expect := reflect.TypeOf(new(PDFcpu))
+	expect := reflect.TypeOf(new(PdfCpu))

 	if actual != expect {
 		t.Errorf("expected '%s' but got '%s'", expect, actual)
 	}
 }

-func TestPDFcpu_Provision(t *testing.T) {
-	mod := new(PDFcpu)
+func TestPdfCpu_Provision(t *testing.T) {
+	engine := new(PdfCpu)
 	ctx := gotenberg.NewContext(gotenberg.ParsedFlags{}, nil)

-	err := mod.Provision(ctx)
+	err := engine.Provision(ctx)
 	if err != nil {
 		t.Errorf("expected no error but got: %v", err)
 	}
 }

-func TestPDFcpu_Merge(t *testing.T) {
-	for i, tc := range []struct {
-		inputPaths []string
-		expectErr  bool
+func TestPdfCpu_Merge(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		inputPaths  []string
+		expectError bool
 	}{
 		{
+			scenario: "invalid input path",
+			inputPaths: []string{
+				"foo",
+			},
+			expectError: true,
+		},
+		{
+			scenario: "single file success",
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 			},
+			expectError: false,
 		},
 		{
+			scenario: "many files success",
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 				"/tests/test/testdata/pdfengines/sample2.pdf",
 			},
 		},
-		{
-			inputPaths: []string{
-				"foo",
-			},
-			expectErr: true,
-		},
 	} {
-		func() {
-			mod := new(PDFcpu)
-
-			err := mod.Provision(nil)
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(PdfCpu)
+			err := engine.Provision(nil)
 			if err != nil {
-				t.Fatalf("test %d: expected error but got: %v", i, err)
+				t.Fatalf("expected error but got: %v", err)
 			}

-			outputDir, err := gotenberg.MkdirAll()
+			fs := gotenberg.NewFileSystem()
+			outputDir, err := fs.MkdirAll()
 			if err != nil {
-				t.Fatalf("test %d: expected error but got: %v", i, err)
+				t.Fatalf("expected error but got: %v", err)
 			}

 			defer func() {
-				err := os.RemoveAll(outputDir)
+				err = os.RemoveAll(fs.WorkingDirPath())
 				if err != nil {
-					t.Fatalf("test %d: expected no error but got: %v", i, err)
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
 				}
 			}()

-			err = mod.Merge(nil, nil, tc.inputPaths, outputDir+"/foo.pdf")
+			err = engine.Merge(nil, nil, tc.inputPaths, outputDir+"/foo.pdf")

-			if tc.expectErr && err == nil {
-				t.Errorf("test %d: expected error but got: %v", i, err)
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
 			}

-			if !tc.expectErr && err != nil {
-				t.Errorf("test %d: expected no error but got: %v", i, err)
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
 			}
-		}()
+		})
 	}
 }

-func TestPDFcpu_Convert(t *testing.T) {
-	mod := new(PDFcpu)
-	err := mod.Convert(context.TODO(), zap.NewNop(), "", "", "")
+func TestPdfCpu_Convert(t *testing.T) {
+	mod := new(PdfCpu)
+	err := mod.Convert(context.TODO(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")

-	if !errors.Is(err, gotenberg.ErrPDFEngineMethodNotAvailable) {
-		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPDFEngineMethodNotAvailable, err)
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
 	}
 }
--- a/pkg/modules/pdfengines/doc.go
+++ b/pkg/modules/pdfengines/doc.go
@@ -1,3 +1,3 @@
-// Package pdfengines provides a module which gathers modules that implements
-// the gotenberg.PDFEngine interface.
+// Package pdfengines a way to gather and manage multiple modules that
+// implement the gotenberg.PdfEngine interface.
 package pdfengines
--- a/pkg/modules/pdfengines/multi.go
+++ b/pkg/modules/pdfengines/multi.go
@@ -4,35 +4,30 @@ import (
 	"context"
 	"fmt"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"go.uber.org/multierr"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

-// multiPDFEngines implements the gotenberg.PDFEngine interface and gathers one
-// or more gotenberg.PDFEngine. It provides a sort of fallback mechanism: if an
-// engine's method returns an error, it calls the same method from another
-// engine.
-type multiPDFEngines struct {
-	engines []gotenberg.PDFEngine
+type multiPdfEngines struct {
+	engines []gotenberg.PdfEngine
 }

-// newMultiPDFEngines returns a multiPDFEngines. Arguments' order determines the
-// order of the engines called.
-func newMultiPDFEngines(engines ...gotenberg.PDFEngine) *multiPDFEngines {
-	return &multiPDFEngines{
+func newMultiPdfEngines(engines ...gotenberg.PdfEngine) *multiPdfEngines {
+	return &multiPdfEngines{
 		engines: engines,
 	}
 }

 // Merge tries to merge the given PDFs into a unique PDF thanks to its
 // children. If the context is done, it stops and returns an error.
-func (multi multiPDFEngines) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+func (multi *multiPdfEngines) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
 	var err error
 	errChan := make(chan error, 1)

 	for _, engine := range multi.engines {
-		go func(engine gotenberg.PDFEngine) {
+		go func(engine gotenberg.PdfEngine) {
 			errChan <- engine.Merge(ctx, logger, inputPaths, outputPath)
 		}(engine)

@@ -52,13 +47,13 @@ func (multi multiPDFEngines) Merge(ctx context.Context, logger *zap.Logger, inpu

 // Convert converts the given PDF to a specific PDF format. thanks to its
 // children. If the context is done, it stops and returns an error.
-func (multi multiPDFEngines) Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error {
+func (multi *multiPdfEngines) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 	var err error
 	errChan := make(chan error, 1)

 	for _, engine := range multi.engines {
-		go func(engine gotenberg.PDFEngine) {
-			errChan <- engine.Convert(ctx, logger, format, inputPath, outputPath)
+		go func(engine gotenberg.PdfEngine) {
+			errChan <- engine.Convert(ctx, logger, formats, inputPath, outputPath)
 		}(engine)

 		select {
@@ -72,10 +67,10 @@ func (multi multiPDFEngines) Convert(ctx context.Context, logger *zap.Logger, fo
 		}
 	}

-	return fmt.Errorf("convert PDF to '%s' with multi PDF engines: %w", format, err)
+	return fmt.Errorf("convert PDF to '%+v' with multi PDF engines: %w", formats, err)
 }

 // Interface guards.
 var (
-	_ gotenberg.PDFEngine = (*multiPDFEngines)(nil)
+	_ gotenberg.PdfEngine = (*multiPdfEngines)(nil)
 )
--- a/pkg/modules/pdfengines/multi_test.go
+++ b/pkg/modules/pdfengines/multi_test.go
@@ -3,213 +3,177 @@ package pdfengines
 import (
 	"context"
 	"errors"
-	"reflect"
 	"testing"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

-func TestNewMultiPDFEngines(t *testing.T) {
-	engine1 := &ProtoPDFEngine{
-		merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-			return nil
-		},
-		convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-			return nil
-		},
-	}
-
-	engine2 := &ProtoPDFEngine{
-		merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-			return errors.New("foo")
-		},
-		convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-			return errors.New("foo")
-		},
-	}
-
-	multi := newMultiPDFEngines(engine1, engine2)
-
-	if len(multi.engines) != 2 {
-		t.Fatalf("expected %d engines but got %d", 2, len(multi.engines))
-	}
-
-	if !reflect.DeepEqual(engine1, multi.engines[0]) {
-		t.Errorf("expected %v, but got: %v", engine1, multi.engines[0])
-	}
-
-	if !reflect.DeepEqual(engine2, multi.engines[1]) {
-		t.Errorf("expected %v, but got: %v", engine2, multi.engines[1])
-	}
-}
-
-func TestMultiPDFEngines_Merge(t *testing.T) {
-	for i, tc := range []struct {
-		ctx       context.Context
-		engines   []gotenberg.PDFEngine
-		expectErr bool
+func TestMultiPdfEngines_Merge(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
 	}{
 		{
-			ctx: context.TODO(),
-			engines: func() []gotenberg.PDFEngine {
-				return []gotenberg.PDFEngine{
-					ProtoPDFEngine{
-						merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-							return nil
-						},
+			scenario: "nominal behavior",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+						return nil
 					},
-				}
-			}(),
+				},
+			),
+			ctx:         context.Background(),
+			expectError: false,
 		},
 		{
-			ctx: context.TODO(),
-			engines: func() []gotenberg.PDFEngine {
-				return []gotenberg.PDFEngine{
-					ProtoPDFEngine{
-						merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-							return errors.New("foo")
-						},
+			scenario: "at least one engine does not return an error",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+						return errors.New("foo")
 					},
-					ProtoPDFEngine{
-						merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-							return nil
-						},
+				},
+				&gotenberg.PdfEngineMock{
+					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+						return nil
 					},
-				}
-			}(),
+				},
+			),
+			ctx:         context.Background(),
+			expectError: false,
 		},
 		{
-			ctx: context.TODO(),
-			engines: func() []gotenberg.PDFEngine {
-				return []gotenberg.PDFEngine{
-					ProtoPDFEngine{
-						merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-							return errors.New("foo")
-						},
+			scenario: "all engines return an error",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+						return errors.New("foo")
 					},
-					ProtoPDFEngine{
-						merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-							return errors.New("bar")
-						},
+				},
+				&gotenberg.PdfEngineMock{
+					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+						return errors.New("foo")
 					},
-				}
-			}(),
-			expectErr: true,
+				},
+			),
+			ctx:         context.Background(),
+			expectError: true,
 		},
 		{
+			scenario: "context expired",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+						return nil
+					},
+				},
+			),
 			ctx: func() context.Context {
-				ctx, cancel := context.WithCancel(context.TODO())
-				defer cancel()
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()

 				return ctx
 			}(),
-			engines: func() []gotenberg.PDFEngine {
-				return []gotenberg.PDFEngine{
-					ProtoPDFEngine{
-						merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-							return nil
-						},
-					},
-				}
-			}(),
-			expectErr: true,
+			expectError: true,
 		},
 	} {
-		multi := newMultiPDFEngines(tc.engines...)
-		err := multi.Merge(tc.ctx, nil, nil, "")
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.Merge(tc.ctx, zap.NewNop(), nil, "")

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

-func TestMultiPDFEngines_Convert(t *testing.T) {
-	for i, tc := range []struct {
-		ctx       context.Context
-		engines   []gotenberg.PDFEngine
-		expectErr bool
+func TestMultiPdfEngines_Convert(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
 	}{
 		{
-			ctx: context.TODO(),
-			engines: func() []gotenberg.PDFEngine {
-				return []gotenberg.PDFEngine{
-					ProtoPDFEngine{
-						convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-							return nil
-						},
+			scenario: "nominal behavior",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+						return nil
 					},
-				}
-			}(),
+				},
+			),
+			ctx: context.Background(),
 		},
 		{
-			ctx: context.TODO(),
-			engines: func() []gotenberg.PDFEngine {
-				return []gotenberg.PDFEngine{
-					ProtoPDFEngine{
-						convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-							return errors.New("foo")
-						},
+			scenario: "at least one engine does not return an error",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+						return errors.New("foo")
 					},
-					ProtoPDFEngine{
-						convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-							return nil
-						},
+				},
+				&gotenberg.PdfEngineMock{
+					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+						return nil
 					},
-				}
-			}(),
+				},
+			),
+			ctx: context.Background(),
 		},
 		{
-			ctx: context.TODO(),
-			engines: func() []gotenberg.PDFEngine {
-				return []gotenberg.PDFEngine{
-					ProtoPDFEngine{
-						convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-							return errors.New("foo")
-						},
+			scenario: "all engines return an error",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+						return errors.New("foo")
 					},
-					ProtoPDFEngine{
-						convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-							return errors.New("bar")
-						},
+				},
+				&gotenberg.PdfEngineMock{
+					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+						return errors.New("foo")
 					},
-				}
-			}(),
-			expectErr: true,
+				},
+			),
+			ctx:         context.Background(),
+			expectError: true,
 		},
 		{
+			scenario: "context expired",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+						return nil
+					},
+				},
+			),
 			ctx: func() context.Context {
-				ctx, cancel := context.WithCancel(context.TODO())
-				defer cancel()
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()

 				return ctx
 			}(),
-			engines: func() []gotenberg.PDFEngine {
-				return []gotenberg.PDFEngine{
-					ProtoPDFEngine{
-						convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-							return nil
-						},
-					},
-				}
-			}(),
-			expectErr: true,
+			expectError: true,
 		},
 	} {
-		multi := newMultiPDFEngines(tc.engines...)
-		err := multi.Convert(tc.ctx, nil, "", "", "")
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.Convert(tc.ctx, zap.NewNop(), gotenberg.PdfFormats{}, "", "")

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }
--- a/pkg/modules/pdfengines/pdfengines.go
+++ b/pkg/modules/pdfengines/pdfengines.go
@@ -3,70 +3,80 @@ package pdfengines
 import (
 	"errors"
 	"fmt"
+	"strings"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
 	flag "github.com/spf13/pflag"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 )

 func init() {
-	gotenberg.MustRegisterModule(PDFEngines{})
+	gotenberg.MustRegisterModule(new(PdfEngines))
 }

-// PDFEngines is a module which gathers available gotenberg.PDFEngine modules.
-// The available gotenberg.PDFEngine modules can be either all
-// gotenberg.PDFEngine modules or the modules selected by the user thanks to
-// the "engines" flag.
+// PdfEngines acts as an aggregator and manager for multiple PDF engine
+// modules. It enables the selection and ordering of PDF engines based on user
+// preferences passed via command-line flags. The [PdfEngines] module also
+// implements the [gotenberg.PdfEngine] interface, providing a unified approach
+// to PDF processing across the various engines it manages.
 //
-// PDFEngines wraps the gotenberg.PDFEngine modules in an internal struct which
-// also implements gotenberg.PDFEngine. This struct provides a sort of fallback
-// mechanism: if an engine's method returns an error, it calls the same method
-// from another engine.
-//
-// This module implements the gotenberg.PDFEngineProvider interface.
-type PDFEngines struct {
+// When processing PDFs, [PdfEngines] will attempt to use the engines in the
+// order they were defined. If the primary engine encounters an error,
+// [PdfEngines] can fall back to the next available engine. It also implements
+// the [api.Router] interface to expose relevant PDF processing routes if
+// enabled.
+type PdfEngines struct {
 	names         []string
-	engines       []gotenberg.PDFEngine
+	engines       []gotenberg.PdfEngine
 	disableRoutes bool
 }

-// Descriptor returns a PDFEngines' module descriptor.
-func (PDFEngines) Descriptor() gotenberg.ModuleDescriptor {
+// Descriptor returns a PdfEngines' module descriptor.
+func (mod *PdfEngines) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID: "pdfengines",
 		FlagSet: func() *flag.FlagSet {
 			fs := flag.NewFlagSet("pdfengines", flag.ExitOnError)
-			fs.StringSlice("pdfengines-engines", make([]string, 0), "Set the PDF engines - all by default")
+			fs.StringSlice("pdfengines-engines", make([]string, 0), "Set the PDF engines and their order - all by default")
 			fs.Bool("pdfengines-disable-routes", false, "Disable the routes")

 			return fs
 		}(),
-		New: func() gotenberg.Module { return new(PDFEngines) },
+		New: func() gotenberg.Module { return new(PdfEngines) },
 	}
 }

-// Provision gets either all gotenberg.PDFEngine modules or the modules
+// Provision gets either all [gotenberg.PdfEngine] modules or the modules
 // selected by the user thanks to the "engines" flag.
-func (mod *PDFEngines) Provision(ctx *gotenberg.Context) error {
+func (mod *PdfEngines) Provision(ctx *gotenberg.Context) error {
 	flags := ctx.ParsedFlags()
 	names := flags.MustStringSlice("pdfengines-engines")
 	mod.disableRoutes = flags.MustBool("pdfengines-disable-routes")

-	engines, err := ctx.Modules(new(gotenberg.PDFEngine))
+	engines, err := ctx.Modules(new(gotenberg.PdfEngine))
 	if err != nil {
 		return fmt.Errorf("get PDF engines: %w", err)
 	}

-	mod.engines = make([]gotenberg.PDFEngine, len(engines))
+	mod.engines = make([]gotenberg.PdfEngine, len(engines))

 	for i, engine := range engines {
-		mod.engines[i] = engine.(gotenberg.PDFEngine)
+		mod.engines[i] = engine.(gotenberg.PdfEngine)
 	}

 	if len(names) > 0 {
 		// Selection from user.
 		mod.names = names

+		// Example in case of deprecated module name.
+		//for i, name := range names {
+		//	if name == "unoconv-pdfengine" || name == "uno-pdfengine" {
+		//		logger.Warn(fmt.Sprintf("%s is deprecated; prefer libreoffice-pdfengine instead", name))
+		//		mod.names[i] = "libreoffice-pdfengine"
+		//	}
+		//}
+
 		return nil
 	}

@@ -80,10 +90,10 @@ func (mod *PDFEngines) Provision(ctx *gotenberg.Context) error {
 	return nil
 }

-// Validate validates there is at least one gotenberg.PDFEngine module
-// available. It also validates that selected gotenberg.PDFEngine modules
+// Validate validates there is at least one [gotenberg.PdfEngine] module
+// available. It also validates that selected [gotenberg.PdfEngine] modules
 // actually exist.
-func (mod PDFEngines) Validate() error {
+func (mod *PdfEngines) Validate() error {
 	if len(mod.engines) == 0 {
 		return errors.New("no PDF engine")
 	}
@@ -118,33 +128,44 @@ func (mod PDFEngines) Validate() error {
 	return fmt.Errorf("non-existing PDF engine(s): %s - available PDF engine(s): %s", nonExistingEngines, availableEngines)
 }

-// PDFEngine returns a gotenberg.PDFEngine.
-func (mod PDFEngines) PDFEngine() (gotenberg.PDFEngine, error) {
-	engines := make([]gotenberg.PDFEngine, len(mod.engines))
-
-	i := 0
-	for _, engine := range mod.engines {
-		engines[i] = engine
-		i++
+// SystemMessages returns one message with the selected [gotenberg.PdfEngine]
+// modules.
+func (mod *PdfEngines) SystemMessages() []string {
+	return []string{
+		strings.Join(mod.names[:], " "),
 	}
-
-	return newMultiPDFEngines(engines...), nil
 }

-// Routes returns the API routes.
-func (mod PDFEngines) Routes() ([]api.MultipartFormDataRoute, error) {
+// PdfEngine returns a [gotenberg.PdfEngine].
+func (mod *PdfEngines) PdfEngine() (gotenberg.PdfEngine, error) {
+	engines := make([]gotenberg.PdfEngine, len(mod.names))
+
+	for i, name := range mod.names {
+		for _, engine := range mod.engines {
+			if name == engine.(gotenberg.Module).Descriptor().ID {
+				engines[i] = engine
+				break
+			}
+		}
+	}
+
+	return newMultiPdfEngines(engines...), nil
+}
+
+// Routes returns the HTTP routes.
+func (mod *PdfEngines) Routes() ([]api.Route, error) {
 	if mod.disableRoutes {
 		return nil, nil
 	}

-	engine, err := mod.PDFEngine()
+	engine, err := mod.PdfEngine()
 	if err != nil {
 		// Should not happen, unless our provider implementation
 		// changes in the future.
-		return nil, fmt.Errorf("get pdf engine: %w", err)
+		return nil, fmt.Errorf("get pdf mod: %w", err)
 	}

-	return []api.MultipartFormDataRoute{
+	return []api.Route{
 		mergeRoute(engine),
 		convertRoute(engine),
 	}, nil
@@ -152,9 +173,10 @@ func (mod PDFEngines) Routes() ([]api.MultipartFormDataRoute, error) {

 // Interface guards.
 var (
-	_ gotenberg.Module            = (*PDFEngines)(nil)
-	_ gotenberg.Provisioner       = (*PDFEngines)(nil)
-	_ gotenberg.Validator         = (*PDFEngines)(nil)
-	_ gotenberg.PDFEngineProvider = (*PDFEngines)(nil)
-	_ api.MultipartFormDataRouter = (*PDFEngines)(nil)
+	_ gotenberg.Module            = (*PdfEngines)(nil)
+	_ gotenberg.Provisioner       = (*PdfEngines)(nil)
+	_ gotenberg.Validator         = (*PdfEngines)(nil)
+	_ gotenberg.SystemLogger      = (*PdfEngines)(nil)
+	_ gotenberg.PdfEngineProvider = (*PdfEngines)(nil)
+	_ api.Router                  = (*PdfEngines)(nil)
 )
--- a/pkg/modules/pdfengines/pdfengines_test.go
+++ b/pkg/modules/pdfengines/pdfengines_test.go
@@ -1,120 +1,106 @@
 package pdfengines

 import (
-	"context"
 	"errors"
 	"reflect"
+	"strings"
 	"testing"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"go.uber.org/zap"
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

-type ProtoModule struct {
-	descriptor func() gotenberg.ModuleDescriptor
-}
-
-func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
-	return mod.descriptor()
-}
-
-type ProtoValidator struct {
-	ProtoModule
-	validate func() error
-}
-
-func (mod ProtoValidator) Validate() error {
-	return mod.validate()
-}
-
-type ProtoPDFEngine struct {
-	ProtoValidator
-	merge   func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error
-	convert func(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error
-}
-
-func (mod ProtoPDFEngine) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-	return mod.merge(ctx, logger, inputPaths, outputPath)
-}
-
-func (mod ProtoPDFEngine) Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error {
-	return mod.convert(ctx, logger, format, inputPath, outputPath)
-}
-
-func TestPDFEngine_Descriptor(t *testing.T) {
-	descriptor := PDFEngines{}.Descriptor()
+func TestPdfEngines_Descriptor(t *testing.T) {
+	descriptor := new(PdfEngines).Descriptor()

 	actual := reflect.TypeOf(descriptor.New())
-	expect := reflect.TypeOf(new(PDFEngines))
+	expect := reflect.TypeOf(new(PdfEngines))

 	if actual != expect {
 		t.Errorf("expected '%s' but got '%s'", expect, actual)
 	}
 }

-func TestPDFEngine_Provision(t *testing.T) {
-	for i, tc := range []struct {
+func TestPdfEngines_Provision(t *testing.T) {
+	for _, tc := range []struct {
+		scenario           string
 		ctx                *gotenberg.Context
-		expectNames        []string
-		expectEnginesCount int
-		expectErr          bool
+		expectedPdfEngines []string
+		expectError        bool
 	}{
 		{
+			scenario: "no selection from user",
 			ctx: func() *gotenberg.Context {
-				engine := struct{ ProtoPDFEngine }{}
-				engine.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return engine }}
+				provider := &struct {
+					gotenberg.ModuleMock
+				}{}
+				provider.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module {
+						return provider
+					}}
+				}
+
+				engine := &struct {
+					gotenberg.ModuleMock
+					gotenberg.ValidatorMock
+					gotenberg.PdfEngineMock
+				}{}
+				engine.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return engine }}
+				}
+				engine.ValidateMock = func() error {
+					return nil
 				}
-				engine.validate = func() error { return errors.New("foo") }

 				return gotenberg.NewContext(
 					gotenberg.ParsedFlags{
-						FlagSet: new(PDFEngines).Descriptor().FlagSet,
+						FlagSet: new(PdfEngines).Descriptor().FlagSet,
 					},
 					[]gotenberg.ModuleDescriptor{
+						provider.Descriptor(),
 						engine.Descriptor(),
 					},
 				)
 			}(),
-			expectErr: true,
+			expectedPdfEngines: []string{"bar"},
+			expectError:        false,
 		},
 		{
+			scenario: "selection from user",
 			ctx: func() *gotenberg.Context {
-				engine := struct{ ProtoPDFEngine }{}
-				engine.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return engine }}
+				provider := &struct {
+					gotenberg.ModuleMock
+				}{}
+				provider.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module {
+						return provider
+					}}
 				}
-				engine.validate = func() error { return nil }
-
-				return gotenberg.NewContext(
-					gotenberg.ParsedFlags{
-						FlagSet: new(PDFEngines).Descriptor().FlagSet,
-					},
-					[]gotenberg.ModuleDescriptor{
-						engine.Descriptor(),
-					},
-				)
-			}(),
-			expectNames:        []string{"foo"},
-			expectEnginesCount: 1,
-		},
-		{
-			ctx: func() *gotenberg.Context {
-				engine1 := struct{ ProtoPDFEngine }{}
-				engine1.descriptor = func() gotenberg.ModuleDescriptor {
+				engine1 := &struct {
+					gotenberg.ModuleMock
+					gotenberg.ValidatorMock
+					gotenberg.PdfEngineMock
+				}{}
+				engine1.DescriptorMock = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "a", New: func() gotenberg.Module { return engine1 }}
 				}
-				engine1.validate = func() error { return nil }
+				engine1.ValidateMock = func() error {
+					return nil
+				}

-				engine2 := struct{ ProtoPDFEngine }{}
-				engine2.descriptor = func() gotenberg.ModuleDescriptor {
+				engine2 := &struct {
+					gotenberg.ModuleMock
+					gotenberg.ValidatorMock
+					gotenberg.PdfEngineMock
+				}{}
+				engine2.DescriptorMock = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "b", New: func() gotenberg.Module { return engine2 }}
 				}
-				engine2.validate = func() error { return nil }
+				engine2.ValidateMock = func() error {
+					return nil
+				}

-				fs := new(PDFEngines).Descriptor().FlagSet
+				fs := new(PdfEngines).Descriptor().FlagSet
 				err := fs.Parse([]string{"--pdfengines-engines=b", "--pdfengines-engines=a"})
-
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -124,181 +110,229 @@ func TestPDFEngine_Provision(t *testing.T) {
 						FlagSet: fs,
 					},
 					[]gotenberg.ModuleDescriptor{
+						provider.Descriptor(),
 						engine1.Descriptor(),
 						engine2.Descriptor(),
 					},
 				)
 			}(),
-			expectNames:        []string{"b", "a"},
-			expectEnginesCount: 2,
+			expectedPdfEngines: []string{"b", "a"},
+			expectError:        false,
 		},
 		{
+			scenario: "no valid PDF engine",
 			ctx: func() *gotenberg.Context {
-				engine1 := struct{ ProtoPDFEngine }{}
-				engine1.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "a", New: func() gotenberg.Module { return engine1 }}
+				provider := &struct {
+					gotenberg.ModuleMock
+				}{}
+				provider.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module {
+						return provider
+					}}
 				}
-				engine1.validate = func() error { return nil }
-
-				engine2 := struct{ ProtoPDFEngine }{}
-				engine2.descriptor = func() gotenberg.ModuleDescriptor {
-					return gotenberg.ModuleDescriptor{ID: "b", New: func() gotenberg.Module { return engine2 }}
+				engine := &struct {
+					gotenberg.ModuleMock
+					gotenberg.ValidatorMock
+					gotenberg.PdfEngineMock
+				}{}
+				engine.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return engine }}
 				}
-				engine2.validate = func() error { return nil }
-
-				fs := new(PDFEngines).Descriptor().FlagSet
-				err := fs.Parse([]string{"--pdfengines-engines=b"})
-
-				if err != nil {
-					t.Fatalf("expected error but got: %v", err)
+				engine.ValidateMock = func() error {
+					return errors.New("foo")
 				}

 				return gotenberg.NewContext(
 					gotenberg.ParsedFlags{
-						FlagSet: fs,
+						FlagSet: new(PdfEngines).Descriptor().FlagSet,
 					},
 					[]gotenberg.ModuleDescriptor{
-						engine1.Descriptor(),
-						engine2.Descriptor(),
+						provider.Descriptor(),
+						engine.Descriptor(),
 					},
 				)
 			}(),
-			expectNames:        []string{"b"},
-			expectEnginesCount: 2,
+			expectError: true,
 		},
 	} {
-		mod := new(PDFEngines)
-		err := mod.Provision(tc.ctx)
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(PdfEngines)
+			err := mod.Provision(tc.ctx)

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
-
-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
-
-		if len(tc.expectNames) != len(mod.names) {
-			t.Errorf("test %d: expected %d names but got %d", i, len(tc.expectNames), len(mod.names))
-		}
-
-		if tc.expectEnginesCount != len(mod.engines) {
-			t.Errorf("test %d: expected %d engines but got %d", i, tc.expectEnginesCount, len(mod.engines))
-		}
-
-		for index, name := range mod.names {
-			if name != tc.expectNames[index] {
-				t.Errorf("test %d: expected name at index %d to be %s, but got: %s", i, index, name, tc.expectNames[index])
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
 			}
-		}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if len(tc.expectedPdfEngines) != len(mod.names) {
+				t.Fatalf("expected %d names but got %d", len(tc.expectedPdfEngines), len(mod.names))
+			}
+
+			for index, name := range mod.names {
+				if name != tc.expectedPdfEngines[index] {
+					t.Fatalf("expected scenario at index %d to be %s, but got: %s", index, name, tc.expectedPdfEngines[index])
+				}
+			}
+		})
 	}
 }

-func TestPDFEngine_Validate(t *testing.T) {
-	for i, tc := range []struct {
-		names     []string
-		engines   []gotenberg.PDFEngine
-		expectErr bool
+func TestPdfEngines_Validate(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		names       []string
+		engines     []gotenberg.PdfEngine
+		expectError bool
 	}{
 		{
-			expectErr: true,
-		},
-		{
-			names: []string{"foo"},
-			engines: func() []gotenberg.PDFEngine {
-				engine := struct{ ProtoPDFEngine }{}
-				engine.descriptor = func() gotenberg.ModuleDescriptor {
+			scenario: "existing PDF engine",
+			names:    []string{"foo"},
+			engines: func() []gotenberg.PdfEngine {
+				engine := &struct {
+					gotenberg.ModuleMock
+					gotenberg.PdfEngineMock
+				}{}
+				engine.DescriptorMock = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return engine }}
 				}

-				return []gotenberg.PDFEngine{
+				return []gotenberg.PdfEngine{
 					engine,
 				}
 			}(),
+			expectError: false,
 		},
 		{
-			names: []string{"foo", "bar", "baz"},
-			engines: func() []gotenberg.PDFEngine {
-				engine1 := struct{ ProtoPDFEngine }{}
-				engine1.descriptor = func() gotenberg.ModuleDescriptor {
+			scenario: "non-existing bar PDF engine",
+			names:    []string{"foo", "bar", "baz"},
+			engines: func() []gotenberg.PdfEngine {
+				engine1 := &struct {
+					gotenberg.ModuleMock
+					gotenberg.PdfEngineMock
+				}{}
+				engine1.DescriptorMock = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return engine1 }}
 				}

-				engine2 := struct{ ProtoPDFEngine }{}
-				engine2.descriptor = func() gotenberg.ModuleDescriptor {
+				engine2 := &struct {
+					gotenberg.ModuleMock
+					gotenberg.PdfEngineMock
+				}{}
+				engine2.DescriptorMock = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "baz", New: func() gotenberg.Module { return engine2 }}
 				}

-				return []gotenberg.PDFEngine{
+				return []gotenberg.PdfEngine{
 					engine1,
 					engine2,
 				}
 			}(),
-			expectErr: true,
+			expectError: true,
+		},
+		{
+			scenario:    "no PDF engine",
+			expectError: true,
 		},
 	} {
-		mod := new(PDFEngines)
-		mod.names = tc.names
-		mod.engines = tc.engines
-		err := mod.Validate()
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := PdfEngines{
+				names:   tc.names,
+				engines: tc.engines,
+			}

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			err := mod.Validate()

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

-func TestPDFEngine_PDFEngine(t *testing.T) {
-	mod := new(PDFEngines)
-	mod.engines = []gotenberg.PDFEngine{
-		struct{ ProtoPDFEngine }{},
+func TestPdfEngines_SystemMessages(t *testing.T) {
+	mod := new(PdfEngines)
+	mod.names = []string{"foo", "bar"}
+
+	messages := mod.SystemMessages()
+	if len(messages) != 1 {
+		t.Errorf("expected one and only one message, but got %d", len(messages))
 	}

-	_, err := mod.PDFEngine()
+	expect := strings.Join(mod.names[:], " ")
+	if messages[0] != expect {
+		t.Errorf("expected message '%s', but got '%s'", expect, messages[0])
+	}
+}
+
+func TestPdfEngines_PdfEngine(t *testing.T) {
+	mod := PdfEngines{
+		names: []string{"foo", "bar"},
+		engines: func() []gotenberg.PdfEngine {
+			engine1 := &struct {
+				gotenberg.ModuleMock
+				gotenberg.PdfEngineMock
+			}{}
+			engine1.DescriptorMock = func() gotenberg.ModuleDescriptor {
+				return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return engine1 }}
+			}
+
+			engine2 := &struct {
+				gotenberg.ModuleMock
+				gotenberg.PdfEngineMock
+			}{}
+			engine2.DescriptorMock = func() gotenberg.ModuleDescriptor {
+				return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return engine2 }}
+			}
+
+			return []gotenberg.PdfEngine{
+				engine1,
+				engine2,
+			}
+		}(),
+	}
+
+	_, err := mod.PdfEngine()
 	if err != nil {
 		t.Errorf("expected no error but got: %v", err)
 	}
 }

-func TestPDFEngine_Routes(t *testing.T) {
-	for i, tc := range []struct {
+func TestPdfEngines_Routes(t *testing.T) {
+	for _, tc := range []struct {
+		scenario      string
 		expectRoutes  int
 		disableRoutes bool
 	}{
 		{
-			expectRoutes: 2,
+			scenario:      "routes not disabled",
+			expectRoutes:  2,
+			disableRoutes: false,
 		},
 		{
+			scenario:      "routes disabled",
+			expectRoutes:  0,
 			disableRoutes: true,
 		},
 	} {
-		mod := new(PDFEngines)
-		mod.engines = []gotenberg.PDFEngine{
-			struct{ ProtoPDFEngine }{},
-		}
-		mod.disableRoutes = tc.disableRoutes
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(PdfEngines)
+			mod.disableRoutes = tc.disableRoutes

-		routes, err := mod.Routes()
-		if err != nil {
-			t.Fatalf("test %d: expected no error but got: %v", i, err)
-		}
+			routes, err := mod.Routes()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if tc.expectRoutes != len(routes) {
-			t.Errorf("test %d: expected %d routes but got %d", i, tc.expectRoutes, len(routes))
-		}
+			if tc.expectRoutes != len(routes) {
+				t.Errorf("expected %d routes but got %d", tc.expectRoutes, len(routes))
+			}
+		})
 	}
 }
-
-// Interface guards.
-var (
-	_ gotenberg.Module    = (*ProtoModule)(nil)
-	_ gotenberg.Validator = (*ProtoValidator)(nil)
-	_ gotenberg.Module    = (*ProtoValidator)(nil)
-	_ gotenberg.PDFEngine = (*ProtoPDFEngine)(nil)
-	_ gotenberg.Module    = (*ProtoPDFEngine)(nil)
-	_ gotenberg.Validator = (*ProtoPDFEngine)(nil)
-)
--- a/pkg/modules/pdfengines/routes.go
+++ b/pkg/modules/pdfengines/routes.go
@@ -5,30 +5,42 @@ import (
 	"fmt"
 	"net/http"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/labstack/echo/v4"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 )

-// mergeRoute returns an api.MultipartFormDataRoute which can merge PDFs.
-func mergeRoute(engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/pdfengines/merge",
-		Handler: func(ctx *api.Context) error {
+// mergeRoute returns an [api.Route] which can merge PDFs.
+func mergeRoute(engine gotenberg.PdfEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/pdfengines/merge",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+
 			// Let's get the data from the form and validate them.
 			var (
 				inputPaths []string
-				PDFformat  string
+				pdfa       string
+				pdfua      bool
 			)

 			err := ctx.FormData().
 				MandatoryPaths([]string{".pdf"}, &inputPaths).
-				String("pdfFormat", &PDFformat, "").
+				String("pdfa", &pdfa, "").
+				Bool("pdfua", &pdfua, false).
 				Validate()
-
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}

+			pdfFormats := gotenberg.PdfFormats{
+				PdfA:  pdfa,
+				PdfUa: pdfua,
+			}
+
 			// Alright, let's merge the PDFs.

 			outputPath := ctx.GeneratePath(".pdf")
@@ -40,21 +52,21 @@ func mergeRoute(engine gotenberg.PDFEngine) api.MultipartFormDataRoute {

 			// So far so good, the PDFs are merged into one unique PDF.
 			// Now, let's check if the client want to convert this result PDF
-			// to a specific PDF format.
-
-			if PDFformat != "" {
+			// to specific PDF formats.
+			zeroValued := gotenberg.PdfFormats{}
+			if pdfFormats != zeroValued {
 				convertInputPath := outputPath
 				convertOutputPath := ctx.GeneratePath(".pdf")

-				err = engine.Convert(ctx, ctx.Log(), PDFformat, convertInputPath, convertOutputPath)
+				err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)

 				if err != nil {
-					if errors.Is(err, gotenberg.ErrPDFFormatNotAvailable) {
+					if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
 						return api.WrapError(
 							fmt.Errorf("convert PDF: %w", err),
-							api.NewSentinelHTTPError(
+							api.NewSentinelHttpError(
 								http.StatusBadRequest,
-								fmt.Sprintf("At least one PDF engine does not handle the PDF format '%s' (pdfFormat), while other have failed to convert for other reasons", PDFformat),
+								fmt.Sprintf("At least one PDF engine does not handle one of the PDF format in '%+v', while other have failed to convert for other reasons", pdfFormats),
 							),
 						)
 					}
@@ -79,43 +91,63 @@ func mergeRoute(engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
 	}
 }

-// convertRoute returns an api.MultipartFormDataRoute which can convert a PDF
-// to a specific PDF format.
-func convertRoute(engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/pdfengines/convert",
-		Handler: func(ctx *api.Context) error {
+// convertRoute returns an [api.Route] which can convert a PDF to a specific
+// PDF format.
+func convertRoute(engine gotenberg.PdfEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/pdfengines/convert",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+
 			// Let's get the data from the form and validate them.
 			var (
 				inputPaths []string
-				PDFformat  string
+				pdfa       string
+				pdfua      bool
 			)

 			err := ctx.FormData().
 				MandatoryPaths([]string{".pdf"}, &inputPaths).
-				MandatoryString("pdfFormat", &PDFformat).
+				String("pdfa", &pdfa, "").
+				Bool("pdfua", &pdfua, false).
 				Validate()
-
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			// Alright, let's merge the PDFs.
+			pdfFormats := gotenberg.PdfFormats{
+				PdfA:  pdfa,
+				PdfUa: pdfua,
+			}

+			zeroValued := gotenberg.PdfFormats{}
+			if pdfFormats == zeroValued {
+				return api.WrapError(
+					errors.New("no PDF formats"),
+					api.NewSentinelHttpError(
+						http.StatusBadRequest,
+						"Invalid form data: either 'pdfa' or 'pdfua' form fields must be provided",
+					),
+				)
+			}
+
+			// Alright, let's convert the PDFs.
 			outputPaths := make([]string, len(inputPaths))

 			for i, inputPath := range inputPaths {
 				outputPaths[i] = ctx.GeneratePath(".pdf")

-				err = engine.Convert(ctx, ctx.Log(), PDFformat, inputPath, outputPaths[i])
+				err = engine.Convert(ctx, ctx.Log(), pdfFormats, inputPath, outputPaths[i])

 				if err != nil {
-					if errors.Is(err, gotenberg.ErrPDFFormatNotAvailable) {
+					if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
 						return api.WrapError(
 							fmt.Errorf("convert PDF: %w", err),
-							api.NewSentinelHTTPError(
+							api.NewSentinelHttpError(
 								http.StatusBadRequest,
-								fmt.Sprintf("At least one PDF engine does not handle the PDF format '%s' (pdfFormat), while other have failed to convert for other reasons", PDFformat),
+								fmt.Sprintf("At least one PDF engine does not handle one of the PDF format in '%+v', while other have failed to convert for other reasons", pdfFormats),
 							),
 						)
 					}
--- a/pkg/modules/pdfengines/routes_test.go
+++ b/pkg/modules/pdfengines/routes_test.go
@@ -6,387 +6,408 @@ import (
 	"net/http"
 	"testing"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
-	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 )

 func TestMergeHandler(t *testing.T) {
-	for i, tc := range []struct {
-		ctx                    *api.MockContext
-		engine                 gotenberg.PDFEngine
-		expectErr              bool
-		expectHTTPErr          bool
-		expectHTTPStatus       int
+	for _, tc := range []struct {
+		scenario               string
+		ctx                    *api.ContextMock
+		engine                 gotenberg.PdfEngine
+		expectError            bool
+		expectHttpError        bool
+		expectHttpStatus       int
 		expectOutputPathsCount int
 	}{
 		{
-			ctx:              &api.MockContext{Context: &api.Context{}},
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
+			scenario:               "missing at least one mandatory file",
+			ctx:                    &api.ContextMock{Context: new(api.Context)},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
 		},
 		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
+			scenario: "error from PDF engine",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
+					"file.pdf":  "/file.pdf",
+					"file2.pdf": "/file2.pdf",
 				})
-
 				return ctx
 			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-						return errors.New("foo")
-					},
-				}
-			}(),
-			expectErr: true,
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
 		},
 		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
+			scenario: "cannot add output paths",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
+					"file.pdf":  "/file.pdf",
+					"file2.pdf": "/file2.pdf",
 				})
-				ctx.SetValues(map[string][]string{
-					"pdfFormat": {
-						"foo",
-					},
-				})
-
-				return ctx
-			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-						return nil
-					},
-					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-						return gotenberg.ErrPDFFormatNotAvailable
-					},
-				}
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
-				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
-				})
-				ctx.SetValues(map[string][]string{
-					"pdfFormat": {
-						"foo",
-					},
-				})
-
-				return ctx
-			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-						return nil
-					},
-					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-						return errors.New("foo")
-					},
-				}
-			}(),
-			expectErr: true,
-		},
-		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
 				ctx.SetCancelled(true)
-				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
-				})
-
 				return ctx
 			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-						return nil
-					},
-				}
-			}(),
-			expectErr: true,
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
 		},
 		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
+			scenario: "success",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
+					"file.pdf":  "/file.pdf",
+					"file2.pdf": "/file2.pdf",
 				})
-				ctx.SetValues(map[string][]string{
-					"pdfFormat": {
-						"foo",
-					},
-				})
-
 				return ctx
 			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-						return nil
-					},
-					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-						return nil
-					},
-				}
-			}(),
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
 			expectOutputPathsCount: 1,
 		},
 		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
+			scenario: "ErrPdfFormatNotSupported",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
+					"file.pdf":  "/file.pdf",
+					"file2.pdf": "/file2.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"pdfa": {
+						gotenberg.PdfA1b,
+					},
 				})
-
 				return ctx
 			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
-						return nil
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return gotenberg.ErrPdfFormatNotSupported
+				},
+			},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "error from PDF engine (convert)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf":  "/file.pdf",
+					"file2.pdf": "/file2.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"pdfa": {
+						gotenberg.PdfA1b,
 					},
-				}
+				})
+				return ctx
 			}(),
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "success with PDF/A & PDF/UA form fields",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf":  "/file.pdf",
+					"file2.pdf": "/file2.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"pdfa": {
+						gotenberg.PdfA1b,
+					},
+					"pdfua": {
+						"true",
+					},
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
 			expectOutputPathsCount: 1,
 		},
 	} {
-		err := mergeRoute(tc.engine).Handler(tc.ctx.Context)
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.SetLogger(zap.NewNop())
+			c := echo.New().NewContext(nil, nil)
+			c.Set("context", tc.ctx.Context)

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			err := mergeRoute(tc.engine).Handler(c)

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
-
-		var httpErr api.HTTPError
-		isHTTPErr := errors.As(err, &httpErr)
-
-		if tc.expectHTTPErr && !isHTTPErr {
-			t.Errorf("test %d: expected HTTP error but got: %v", i, err)
-		}
-
-		if !tc.expectHTTPErr && isHTTPErr {
-			t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
-		}
-
-		if err != nil && tc.expectHTTPErr && isHTTPErr {
-			status, _ := httpErr.HTTPError()
-			if status != tc.expectHTTPStatus {
-				t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
 			}
-		}

-		if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
-			t.Errorf("test %d: expected %d output paths but got %d", i, tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			var httpErr api.HttpError
+			isHttpError := errors.As(err, &httpErr)
+
+			if tc.expectHttpError && !isHttpError {
+				t.Errorf("expected an HTTP error but got: %v", err)
+			}
+
+			if !tc.expectHttpError && isHttpError {
+				t.Errorf("expected no HTTP error but got one: %v", httpErr)
+			}
+
+			if err != nil && tc.expectHttpError && isHttpError {
+				status, _ := httpErr.HttpError()
+				if status != tc.expectHttpStatus {
+					t.Errorf("expected %d as HTTP status code but got %d", tc.expectHttpStatus, status)
+				}
+			}
+
+			if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
+				t.Errorf("expected %d output paths but got %d", tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
+			}
+		})
 	}
 }

 func TestConvertHandler(t *testing.T) {
-	for i, tc := range []struct {
-		ctx                    *api.MockContext
-		engine                 gotenberg.PDFEngine
-		expectErr              bool
-		expectHTTPErr          bool
-		expectHTTPStatus       int
+	for _, tc := range []struct {
+		scenario               string
+		ctx                    *api.ContextMock
+		engine                 gotenberg.PdfEngine
+		expectError            bool
+		expectHttpError        bool
+		expectHttpStatus       int
 		expectOutputPathsCount int
 	}{
 		{
-			ctx:              &api.MockContext{Context: &api.Context{}},
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
+			scenario:               "missing at least one mandatory file",
+			ctx:                    &api.ContextMock{Context: new(api.Context)},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
 		},
 		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-				ctx.SetValues(map[string][]string{
-					"pdfFormat": {
-						"foo",
-					},
-				})
-
-				return ctx
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
+			scenario: "no PDF formats",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
+					"file.pdf": "/file.pdf",
 				})
-				ctx.SetValues(map[string][]string{
-					"pdfFormat": {
-						"foo",
-					},
-				})
-
 				return ctx
 			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-						return gotenberg.ErrPDFFormatNotAvailable
-					},
-				}
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
 		},
 		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
+			scenario: "ErrPdfFormatNotSupported",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
+					"file.pdf": "/file.pdf",
 				})
 				ctx.SetValues(map[string][]string{
-					"pdfFormat": {
-						"foo",
+					"pdfa": {
+						gotenberg.PdfA1b,
 					},
 				})
-
 				return ctx
 			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-						return errors.New("foo")
-					},
-				}
-			}(),
-			expectErr: true,
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return gotenberg.ErrPdfFormatNotSupported
+				},
+			},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
 		},
 		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
+			scenario: "error from PDF engine",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"pdfa": {
+						gotenberg.PdfA1b,
+					},
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "cannot add output paths",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"pdfa": {
+						gotenberg.PdfA1b,
+					},
+				})
 				ctx.SetCancelled(true)
-				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
-				})
-				ctx.SetValues(map[string][]string{
-					"pdfFormat": {
-						"foo",
-					},
-				})
-
 				return ctx
 			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-						return nil
-					},
-				}
-			}(),
-			expectErr: true,
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
 		},
 		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
+			scenario: "success with PDF/A & PDF/UA form fields (single file)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
+					"file.pdf": "/file.pdf",
 				})
 				ctx.SetValues(map[string][]string{
-					"pdfFormat": {
-						"foo",
+					"pdfa": {
+						gotenberg.PdfA1b,
+					},
+					"pdfua": {
+						"true",
 					},
 				})
-
 				return ctx
 			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-						return nil
-					},
-				}
-			}(),
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
 			expectOutputPathsCount: 1,
 		},
 		{
-			ctx: func() *api.MockContext {
-				ctx := &api.MockContext{Context: &api.Context{}}
-
+			scenario: "success with PDF/A & PDF/UA form fields (many files)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"foo.pdf": "/foo/foo.pdf",
-					"bar.pdf": "/foo/bar.pdf",
+					"file.pdf":  "/file.pdf",
+					"file2.pdf": "/file2.pdf",
 				})
 				ctx.SetValues(map[string][]string{
-					"pdfFormat": {
-						"foo",
+					"pdfa": {
+						gotenberg.PdfA1b,
+					},
+					"pdfua": {
+						"true",
 					},
 				})
-
 				return ctx
 			}(),
-			engine: func() gotenberg.PDFEngine {
-				return &ProtoPDFEngine{
-					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
-						return nil
-					},
-				}
-			}(),
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
 			expectOutputPathsCount: 2,
 		},
 	} {
-		err := convertRoute(tc.engine).Handler(tc.ctx.Context)
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.SetLogger(zap.NewNop())
+			c := echo.New().NewContext(nil, nil)
+			c.Set("context", tc.ctx.Context)

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			err := convertRoute(tc.engine).Handler(c)

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
-
-		var httpErr api.HTTPError
-		isHTTPErr := errors.As(err, &httpErr)
-
-		if tc.expectHTTPErr && !isHTTPErr {
-			t.Errorf("test %d: expected HTTP error but got: %v", i, err)
-		}
-
-		if !tc.expectHTTPErr && isHTTPErr {
-			t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
-		}
-
-		if err != nil && tc.expectHTTPErr && isHTTPErr {
-			status, _ := httpErr.HTTPError()
-			if status != tc.expectHTTPStatus {
-				t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
 			}
-		}

-		if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
-			t.Errorf("test %d: expected %d output paths but got %d", i, tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			var httpErr api.HttpError
+			isHttpError := errors.As(err, &httpErr)
+
+			if tc.expectHttpError && !isHttpError {
+				t.Errorf("expected an HTTP error but got: %v", err)
+			}
+
+			if !tc.expectHttpError && isHttpError {
+				t.Errorf("expected no HTTP error but got one: %v", httpErr)
+			}
+
+			if err != nil && tc.expectHttpError && isHttpError {
+				status, _ := httpErr.HttpError()
+				if status != tc.expectHttpStatus {
+					t.Errorf("expected %d as HTTP status code but got %d", tc.expectHttpStatus, status)
+				}
+			}
+
+			if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
+				t.Errorf("expected %d output paths but got %d", tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
+			}
+		})
 	}
 }
--- a/pkg/modules/pdftk/doc.go
+++ b/pkg/modules/pdftk/doc.go
@@ -1,3 +1,8 @@
-// Package pdftk provides a module which abstracts the CLI tool PDFtk and
-// implements the gotenberg.PDFEngine interface.
+// Package pdftk provides an implementation of the gotenberg.PdfEngine
+// interface using the PDFtk command-line tool. This package allows for the
+// merging  of PDF files but does not support conversion to specific PDF
+// formats. The path to the PDFtk binary must be specified using the
+// PDFTK_BIN_PATH environment variable.
+//
+// See: https://gitlab.com/pdftk-java/pdftk.
 package pdftk
--- a/pkg/modules/pdftk/pdftk.go
+++ b/pkg/modules/pdftk/pdftk.go
@@ -6,31 +6,31 @@ import (
 	"fmt"
 	"os"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

 func init() {
-	gotenberg.MustRegisterModule(PDFtk{})
+	gotenberg.MustRegisterModule(new(PdfTk))
 }

-// PDFtk abstracts the CLI tool PDFtk and implements the gotenberg.PDFEngine
+// PdfTk abstracts the CLI tool PDFtk and implements the [gotenberg.PdfEngine]
 // interface.
-type PDFtk struct {
+type PdfTk struct {
 	binPath string
 }

-// Descriptor returns a PDFtk's module descriptor.
-func (engine PDFtk) Descriptor() gotenberg.ModuleDescriptor {
+// Descriptor returns a [PdfTk]'s module descriptor.
+func (engine *PdfTk) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID:  "pdftk",
-		New: func() gotenberg.Module { return new(PDFtk) },
+		New: func() gotenberg.Module { return new(PdfTk) },
 	}
 }

-// Provision sets the modules properties. It returns an error if the
-// environment variable PDFTK_BIN_PATH is not set.
-func (engine *PDFtk) Provision(_ *gotenberg.Context) error {
+// Provision sets the modules properties.
+func (engine *PdfTk) Provision(ctx *gotenberg.Context) error {
 	binPath, ok := os.LookupEnv("PDFTK_BIN_PATH")
 	if !ok {
 		return errors.New("PDFTK_BIN_PATH environment variable is not set")
@@ -42,17 +42,17 @@ func (engine *PDFtk) Provision(_ *gotenberg.Context) error {
 }

 // Validate validates the module properties.
-func (engine PDFtk) Validate() error {
+func (engine *PdfTk) Validate() error {
 	_, err := os.Stat(engine.binPath)
 	if os.IsNotExist(err) {
-		return fmt.Errorf("PDFtk binary path does not exist: %w", err)
+		return fmt.Errorf("PdfTk binary path does not exist: %w", err)
 	}

 	return nil
 }

-// Merge merges the given PDFs into a unique PDF.
-func (engine PDFtk) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+// Merge combines multiple PDFs into a single PDF.
+func (engine *PdfTk) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
 	var args []string
 	args = append(args, inputPaths...)
 	args = append(args, "cat", "output", outputPath)
@@ -62,7 +62,7 @@ func (engine PDFtk) Merge(ctx context.Context, logger *zap.Logger, inputPaths []
 		return fmt.Errorf("create command: %w", err)
 	}

-	err = cmd.Exec()
+	_, err = cmd.Exec()
 	if err == nil {
 		return nil
 	}
@@ -70,15 +70,15 @@ func (engine PDFtk) Merge(ctx context.Context, logger *zap.Logger, inputPaths []
 	return fmt.Errorf("merge PDFs with PDFtk: %w", err)
 }

-// Convert is not available for this PDF engine.
-func (engine PDFtk) Convert(_ context.Context, _ *zap.Logger, format, _, _ string) error {
-	return fmt.Errorf("convert PDF to '%s' with PDFtk: %w", format, gotenberg.ErrPDFEngineMethodNotAvailable)
+// Convert is not available in this implementation.
+func (engine *PdfTk) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	return fmt.Errorf("convert PDF to '%+v' with PDFtk: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }

 // Interface guards.
 var (
-	_ gotenberg.Module      = (*PDFtk)(nil)
-	_ gotenberg.Provisioner = (*PDFtk)(nil)
-	_ gotenberg.Validator   = (*PDFtk)(nil)
-	_ gotenberg.PDFEngine   = (*PDFtk)(nil)
+	_ gotenberg.Module      = (*PdfTk)(nil)
+	_ gotenberg.Provisioner = (*PdfTk)(nil)
+	_ gotenberg.Validator   = (*PdfTk)(nil)
+	_ gotenberg.PdfEngine   = (*PdfTk)(nil)
 )
--- a/pkg/modules/pdftk/pdftk_test.go
+++ b/pkg/modules/pdftk/pdftk_test.go
@@ -7,130 +7,144 @@ import (
 	"reflect"
 	"testing"

-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

-func TestPDFtk_Descriptor(t *testing.T) {
-	descriptor := PDFtk{}.Descriptor()
+func TestPdfTk_Descriptor(t *testing.T) {
+	descriptor := new(PdfTk).Descriptor()

 	actual := reflect.TypeOf(descriptor.New())
-	expect := reflect.TypeOf(new(PDFtk))
+	expect := reflect.TypeOf(new(PdfTk))

 	if actual != expect {
 		t.Errorf("expected '%s' but got '%s'", expect, actual)
 	}
 }

-func TestPDFtk_Provision(t *testing.T) {
-	mod := new(PDFtk)
+func TestPdfTk_Provision(t *testing.T) {
+	engine := new(PdfTk)
 	ctx := gotenberg.NewContext(gotenberg.ParsedFlags{}, nil)

-	err := mod.Provision(ctx)
+	err := engine.Provision(ctx)
 	if err != nil {
 		t.Errorf("expected no error but got: %v", err)
 	}
 }

-func TestPDFtk_Validate(t *testing.T) {
-	for i, tc := range []struct {
-		binPath   string
-		expectErr bool
+func TestPdfTk_Validate(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		binPath     string
+		expectError bool
 	}{
 		{
-			expectErr: true,
+			scenario:    "empty bin path",
+			binPath:     "",
+			expectError: true,
 		},
 		{
-			binPath:   "/foo",
-			expectErr: true,
+			scenario:    "bin path does not exist",
+			binPath:     "/foo",
+			expectError: true,
 		},
 		{
-			binPath: os.Getenv("PDFTK_BIN_PATH"),
+			scenario:    "validate success",
+			binPath:     os.Getenv("PDFTK_BIN_PATH"),
+			expectError: false,
 		},
 	} {
-		mod := new(PDFtk)
-		mod.binPath = tc.binPath
-		err := mod.Validate()
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(PdfTk)
+			engine.binPath = tc.binPath
+			err := engine.Validate()

-		if tc.expectErr && err == nil {
-			t.Errorf("test %d: expected error but got: %v", i, err)
-		}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-		if !tc.expectErr && err != nil {
-			t.Errorf("test %d: expected no error but got: %v", i, err)
-		}
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
 	}
 }

-func TestPDFtk_Merge(t *testing.T) {
-	for i, tc := range []struct {
-		ctx        context.Context
-		inputPaths []string
-		expectErr  bool
+func TestPdfTk_Merge(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         context.Context
+		inputPaths  []string
+		expectError bool
 	}{
 		{
-			ctx: context.TODO(),
+			scenario:    "invalid context",
+			ctx:         nil,
+			expectError: true,
+		},
+		{
+			scenario: "invalid input path",
+			ctx:      context.TODO(),
+			inputPaths: []string{
+				"foo",
+			},
+			expectError: true,
+		},
+		{
+			scenario: "single file success",
+			ctx:      context.TODO(),
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 			},
 		},
 		{
-			ctx: context.TODO(),
+			scenario: "many files success",
+			ctx:      context.TODO(),
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 				"/tests/test/testdata/pdfengines/sample2.pdf",
 			},
 		},
-		{
-			ctx:       nil,
-			expectErr: true,
-		},
-		{
-			ctx: context.TODO(),
-			inputPaths: []string{
-				"foo",
-			},
-			expectErr: true,
-		},
 	} {
-		func() {
-			mod := new(PDFtk)
-
-			err := mod.Provision(nil)
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(PdfTk)
+			err := engine.Provision(nil)
 			if err != nil {
-				t.Fatalf("test %d: expected error but got: %v", i, err)
+				t.Fatalf("expected error but got: %v", err)
 			}

-			outputDir, err := gotenberg.MkdirAll()
+			fs := gotenberg.NewFileSystem()
+			outputDir, err := fs.MkdirAll()
 			if err != nil {
-				t.Fatalf("test %d: expected error but got: %v", i, err)
+				t.Fatalf("expected error but got: %v", err)
 			}

 			defer func() {
-				err := os.RemoveAll(outputDir)
+				err = os.RemoveAll(fs.WorkingDirPath())
 				if err != nil {
-					t.Fatalf("test %d: expected no error but got: %v", i, err)
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
 				}
 			}()

-			err = mod.Merge(tc.ctx, zap.NewNop(), tc.inputPaths, outputDir+"/foo.pdf")
+			err = engine.Merge(tc.ctx, zap.NewNop(), tc.inputPaths, outputDir+"/foo.pdf")

-			if tc.expectErr && err == nil {
-				t.Errorf("test %d: expected error but got: %v", i, err)
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
 			}

-			if !tc.expectErr && err != nil {
-				t.Errorf("test %d: expected no error but got: %v", i, err)
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
 			}
-		}()
+		})
 	}
 }

-func TestPDFtk_Convert(t *testing.T) {
-	mod := new(PDFtk)
-	err := mod.Convert(context.TODO(), zap.NewNop(), "", "", "")
+func TestPdfTk_Convert(t *testing.T) {
+	engine := new(PdfTk)
+	err := engine.Convert(context.TODO(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")

-	if !errors.Is(err, gotenberg.ErrPDFEngineMethodNotAvailable) {
-		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPDFEngineMethodNotAvailable, err)
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
 	}
 }
--- a/Show More
+++ b/Show More