chore(deps): update golangci-lint

* Fix auto-restart's initial number of requests
It would need 1 less requests on the first restart
The number of request was technically off by one after the first restart

* Supervisor now eagerly restarts processes
When the maxReqLimit is reached, restart the process in the background

* Update pkg/gotenberg/supervisor.go

Co-authored-by: Julien Neuhart <neuhart.julien@gmail.com>

---------

Co-authored-by: Julien Neuhart <neuhart.julien@gmail.com>

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [gulien]

.github/stale.yml

@@ -1,7 +1,7 @@
 # Number of days of inactivity before an issue becomes stale
-daysUntilStale: 15
+daysUntilStale: 7
 # Number of days of inactivity before a stale issue is closed
-daysUntilClose: 7
+daysUntilClose: 3
 # Issues with these labels will never be considered stale
 exemptLabels:
   - bug

.github/workflows/continuous_delivery.yml

@@ -23,4 +23,4 @@ jobs:
       - 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_REPOSITORY=thecodingmachine
+          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }} DOCKER_REGISTRY=thecodingmachine

.github/workflows/continuous_integration.yml

@@ -17,18 +17,18 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.23'
           cache: false
       - name: Checkout source code
         uses: actions/checkout@v4
       - name: Run linters
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v6
         with:
-          version: v1.54.2
+          version: v1.61.0
 
   tests:
     needs:
-      - Lint
+      - lint
     name: Tests
     # TODO: once arm64 actions are available, also run the tests on this architecture.
     # See: https://github.com/actions/virtual-environments/issues/2552#issuecomment-771478000.
@@ -43,15 +43,39 @@ jobs:
       - name: Build testing environment
         run: make build build-tests
       - name: Run tests
-        run: |
-          make tests-once
-          bash <(curl -s https://codecov.io/bash)
+        run: make tests-once
+      - name: Upload to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          verbose: true
 
-  multiarch_build:
+  snapshot_release:
+    if: github.event_name == 'pull_request'
+    needs:
+      - tests
+    name: Snapshot release
+    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 snapshot Docker image (linux/amd64)
+        run: make release GOTENBERG_VERSION=${{ github.head_ref }} DOCKER_REPOSITORY=snapshot LINUX_AMD64_RELEASE=true
+
+  edge_release:
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     needs:
-      - Tests
-    name: Multi-arch build
+      - tests
+    name: Edge release
     runs-on: ubuntu-latest
     steps:
       - name: Set up QEMU
@@ -68,4 +92,4 @@ jobs:
       - name: Build and push Docker image for main branch
         run: |
           make release GOTENBERG_VERSION=edge
-          make release GOTENBERG_VERSION=edge DOCKER_REPOSITORY=thecodingmachine
+          make release GOTENBERG_VERSION=edge DOCKER_REGISTRY=thecodingmachine

.gitignore

@@ -1,3 +1,5 @@
 /coverage.html
 /coverage.txt
-/TODO.txt
+.idea
+.vscode
+.DS_Store

.golangci.yml

@@ -6,24 +6,49 @@ linters-settings:
       - prefix(github.com/gotenberg/gotenberg/v8)
     skip-generated: true
     custom-order: true
+  # Until https://github.com/securego/gosec/issues/1187 is resolved.
+  gosec:
+    excludes:
+      - G115
 
 linters:
   disable-all: true
   enable:
+    - asasalint
+    - asciicheck
+    - bidichk
     - bodyclose
+    - decorder
+    - dogsled
+    - dupl
+    - dupword
+    - durationcheck
+    - copyloopvar
     - errcheck
+    - errname
+    - exhaustive
     - gci
+    - gofmt
+    - goimports
     - gofumpt
     - gosec
     - gosimple
     - govet
     - ineffassign
+    - importas
     - misspell
     - prealloc
+    - promlinter
+    #- sloglint
     - staticcheck
+    - tenv
+    - testableexamples
+    - tparallel
     - typecheck
     - unconvert
     - unused
+    - wastedassign
+    - whitespace
 
 run:
   timeout: 5m
@@ -31,6 +56,5 @@ run:
   tests: false
 
 output:
-  format: 'colored-line-number'
   print-issued-lines: true
-  print-linter-name: true
+  print-linter-name: true

Makefile

@@ -5,14 +5,16 @@ help: ## Show the help
 .PHONY: it
 it: build build-tests ## Initialize the development environment
 
-GOLANG_VERSION=1.21
+GOLANG_VERSION=1.23
+DOCKER_REGISTRY=gotenberg
 DOCKER_REPOSITORY=gotenberg
 GOTENBERG_VERSION=snapshot
 GOTENBERG_USER_GID=1001
 GOTENBERG_USER_UID=1001
-NOTO_COLOR_EMOJI_VERSION=v2.040 # See https://github.com/googlefonts/noto-emoji/releases.
+NOTO_COLOR_EMOJI_VERSION=v2.047 # 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.54.2 # See https://github.com/golangci/golangci-lint/releases.
+PDFCPU_VERSION=v0.8.1 # See https://github.com/pdfcpu/pdfcpu/releases.
+GOLANGCI_LINT_VERSION=v1.61.0 # See https://github.com/golangci/golangci-lint/releases.
 
 .PHONY: build
 build: ## Build the Gotenberg's Docker image
@@ -23,18 +25,29 @@ build: ## Build the Gotenberg's Docker image
 	--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_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION) \
+	--build-arg PDFCPU_VERSION=$(PDFCPU_VERSION) \
+	-t $(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION) \
 	-f build/Dockerfile .
 
 GOTENBERG_GRACEFUL_SHUTDOWN_DURATION=30s
 API_PORT=3000
 API_PORT_FROM_ENV=
+API_BIND_IP=
 API_START_TIMEOUT=30s
 API_TIMEOUT=30s
+API_BODY_LIMIT=
 API_ROOT_PATH=/
 API_TRACE_HEADER=Gotenberg-Trace
+API_ENABLE_BASIC_AUTH=false
+GOTENBERG_API_BASIC_AUTH_USERNAME=
+GOTENBERG_API_BASIC_AUTH_PASSWORD=
+API-DOWNLOAD-FROM-ALLOW-LIST=
+API-DOWNLOAD-FROM-DENY-LIST=
+API-DOWNLOAD-FROM-FROM-MAX-RETRY=4
+API-DISABLE-DOWNLOAD-FROM=false
 API_DISABLE_HEALTH_CHECK_LOGGING=false
 CHROMIUM_RESTART_AFTER=0
+CHROMIUM_MAX_QUEUE_SIZE=0
 CHROMIUM_AUTO_START=false
 CHROMIUM_START_TIMEOUT=20s
 CHROMIUM_INCOGNITO=false
@@ -45,12 +58,13 @@ CHROMIUM_ALLOW_FILE_ACCESS_FROM_FILES=false
 CHROMIUM_HOST_RESOLVER_RULES=
 CHROMIUM_PROXY_SERVER=
 CHROMIUM_ALLOW_LIST=
-CHROMIUM_DENY_LIST="^file:///[^tmp].*"
+CHROMIUM_DENY_LIST=^file:(?!//\/tmp/).*
 CHROMIUM_CLEAR_CACHE=false
 CHROMIUM_CLEAR_COOKIES=false
 CHROMIUM_DISABLE_JAVASCRIPT=false
 CHROMIUM_DISABLE_ROUTES=false
 LIBREOFFICE_RESTART_AFTER=10
+LIBREOFFICE_MAX_QUEUE_SIZE=0
 LIBREOFFICE_AUTO_START=false
 LIBREOFFICE_START_TIMEOUT=20s
 LIBREOFFICE_DISABLE_ROUTES=false
@@ -58,6 +72,10 @@ LOG_LEVEL=info
 LOG_FORMAT=auto
 LOG_FIELDS_PREFIX=
 PDFENGINES_ENGINES=
+PDFENGINES_MERGE_ENGINES=qpdf,pdfcpu,pdftk
+PDFENGINES_CONVERT_ENGINES=libreoffice-pdfengine
+PDFENGINES_READ_METADATA_ENGINES=exiftool
+PDFENGINES_WRITE_METADATA_ENGINES=exiftool
 PDFENGINES_DISABLE_ROUTES=false
 PROMETHEUS_NAMESPACE=gotenberg
 PROMETHEUS_COLLECT_INTERVAL=1s
@@ -77,18 +95,28 @@ WEBHOOK_DISABLE=false
 run: ## Start a Gotenberg container
 	docker run --rm -it \
 	-p $(API_PORT):$(API_PORT) \
-	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION) \
+	-e GOTENBERG_API_BASIC_AUTH_USERNAME=$(GOTENBERG_API_BASIC_AUTH_USERNAME) \
+	-e GOTENBERG_API_BASIC_AUTH_PASSWORD=$(GOTENBERG_API_BASIC_AUTH_PASSWORD) \
+	$(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION) \
 	gotenberg \
 	--gotenberg-graceful-shutdown-duration=$(GOTENBERG_GRACEFUL_SHUTDOWN_DURATION) \
 	--api-port=$(API_PORT) \
 	--api-port-from-env=$(API_PORT_FROM_ENV) \
+	--api-bind-ip=$(API_BIND_IP) \
 	--api-start-timeout=$(API_START_TIMEOUT) \
 	--api-timeout=$(API_TIMEOUT) \
+	--api-body-limit="$(API_BODY_LIMIT)" \
 	--api-root-path=$(API_ROOT_PATH) \
 	--api-trace-header=$(API_TRACE_HEADER) \
+	--api-enable-basic-auth=$(API_ENABLE_BASIC_AUTH) \
+	--api-download-from-allow-list=$(API-DOWNLOAD-FROM-ALLOW-LIST) \
+	--api-download-from-deny-list=$(API-DOWNLOAD-FROM-DENY-LIST) \
+	--api-download-from-max-retry=$(API-DOWNLOAD-FROM-FROM-MAX-RETRY) \
+	--api-disable-download-from=$(API-DISABLE-DOWNLOAD-FROM) \
 	--api-disable-health-check-logging=$(API_DISABLE_HEALTH_CHECK_LOGGING) \
 	--chromium-restart-after=$(CHROMIUM_RESTART_AFTER) \
 	--chromium-auto-start=$(CHROMIUM_AUTO_START) \
+	--chromium-max-queue-size=$(CHROMIUM_MAX_QUEUE_SIZE) \
 	--chromium-start-timeout=$(CHROMIUM_START_TIMEOUT) \
 	--chromium-incognito=$(CHROMIUM_INCOGNITO) \
 	--chromium-allow-insecure-localhost=$(CHROMIUM_ALLOW_INSECURE_LOCALHOST) \
@@ -97,13 +125,14 @@ run: ## Start a Gotenberg container
 	--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-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-restart-after=$(LIBREOFFICE_RESTART_AFTER) \
+	--libreoffice-max-queue-size=$(LIBREOFFICE_MAX_QUEUE_SIZE) \
 	--libreoffice-auto-start=$(LIBREOFFICE_AUTO_START) \
 	--libreoffice-start-timeout=$(LIBREOFFICE_START_TIMEOUT) \
 	--libreoffice-disable-routes=$(LIBREOFFICE_DISABLE_ROUTES) \
@@ -111,13 +140,17 @@ run: ## Start a Gotenberg container
 	--log-format=$(LOG_FORMAT) \
 	--log-fields-prefix=$(LOG_FIELDS_PREFIX) \
 	--pdfengines-engines=$(PDFENGINES_ENGINES) \
+	--pdfengines-merge-engines=$(PDFENGINES_MERGE_ENGINES) \
+	--pdfengines-convert-engines=$(PDFENGINES_CONVERT_ENGINES) \
+	--pdfengines-read-metadata-engines=$(PDFENGINES_READ_METADATA_ENGINES) \
+	--pdfengines-write-metadata-engines=$(PDFENGINES_WRITE_METADATA_ENGINES) \
 	--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-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) \
@@ -130,24 +163,25 @@ run: ## Start a Gotenberg container
 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_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	-t $(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION)-tests \
 	-f test/Dockerfile .
 
 .PHONY: tests
 tests: ## Start the testing environment
 	docker run --rm -it \
 	-v $(PWD):/tests \
-	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	$(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(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_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	$(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION)-tests \
 	gotest
 
 # go install mvdan.cc/gofumpt@latest
@@ -164,8 +198,10 @@ godoc: ## Run a webserver with Gotenberg godoc
 	$(info http://localhost:6060/pkg/github.com/gotenberg/gotenberg/v8)
 	godoc -http=:6060
 
+LINUX_AMD64_RELEASE=false
+
 .PHONY: release
-release: ## Build the Gotenberg's Docker image for many platforms, then push it to a Docker repository
+release: ## Build the Gotenberg's Docker image and push it to a Docker repository
 	./scripts/release.sh \
  	$(GOLANG_VERSION) \
 	$(GOTENBERG_VERSION) \
@@ -173,4 +209,8 @@ release: ## Build the Gotenberg's Docker image for many platforms, then push it
 	$(GOTENBERG_USER_UID) \
 	$(NOTO_COLOR_EMOJI_VERSION) \
 	$(PDFTK_VERSION) \
-	$(DOCKER_REPOSITORY)
+	$(PDFCPU_VERSION) \
+	$(DOCKER_REGISTRY) \
+	$(DOCKER_REPOSITORY) \
+	$(LINUX_AMD64_RELEASE)
+

README.md

@@ -2,12 +2,20 @@
     <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://hub.docker.com/r/gotenberg/gotenberg"><img alt="Total downloads (gotenberg/gotenberg)" src="https://img.shields.io/docker/pulls/gotenberg/gotenberg"></a>
+        <a href="https://hub.docker.com/r/thecodingmachine/gotenberg"><img alt="Total downloads (thecodingmachine/gotenberg)" src="https://img.shields.io/docker/pulls/thecodingmachine/gotenberg"></a>
+        <br>
+        <a href="https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml"><img alt="Continuous Integration" src="https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml/badge.svg"></a>
+        <a href="https://pkg.go.dev/github.com/gotenberg/gotenberg/v8"><img alt="Go Reference" src="https://pkg.go.dev/badge/github.com/gotenberg/gotenberg.svg"></a>
+        <a href="https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg"><img alt="Code coverage" src="https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg"></a>
+    </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 for converting 
+**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
@@ -32,14 +40,11 @@ Head to the [documentation](https://gotenberg.dev/docs/getting-started/introduct
 
 <p align="center">
     <a href="https://thecodingmachine.com">
-        <img src="https://user-images.githubusercontent.com/8983173/130324668-9d6e7b35-53a3-49c7-a574-38190d2bd6b0.png" alt="TheCodingMachine Logo" width="429" height="210" />
+        <img src="https://user-images.githubusercontent.com/8983173/130324668-9d6e7b35-53a3-49c7-a574-38190d2bd6b0.png" alt="TheCodingMachine Logo" width="333" height="163" />
+    </a>
+    <a href="https://zolsec.com?utm_source=gotenberg_github&utm_medium=website" target="_blank">
+        <img src="https://github.com/gotenberg/gotenberg/assets/8983173/707ccc97-a79b-4dcb-8fc8-6827366e5be3" alt="Zolsec Logo" width="333" height="163" />
     </a>
 </p>
 
-## Badges
-
-[![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/v8)
-[![Codecov](https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg)](https://codecov.io/gh/gotenberg/gotenberg)
+Sponsorships help maintaining and improving Gotenberg - [become a sponsor](https://github.com/sponsors/gulien) ❤️

build/Dockerfile

@@ -3,13 +3,38 @@
 # stage that uses them.
 ARG GOLANG_VERSION
 
+# ----------------------------------------------
+# pdfcpu binary build stage
+# ----------------------------------------------
+# Note: this stage is required as pdfcpu does not release an armhf variant by
+# default.
+
+FROM golang:$GOLANG_VERSION AS pdfcpu-binary-stage
+
+ARG PDFCPU_VERSION
+ENV CGO_ENABLED=0
+
+# Define the working directory outside of $GOPATH (we're using go modules).
+WORKDIR /home
+
+RUN curl -Ls "https://github.com/pdfcpu/pdfcpu/archive/refs/tags/$PDFCPU_VERSION.tar.gz" -o pdfcpu.tar.gz &&\
+    tar --strip-components=1 -xvzf pdfcpu.tar.gz
+
+# Install module dependencies.
+RUN go mod download &&\
+    go mod verify
+
+RUN go build -o pdfcpu -ldflags "-s -w -X 'main.version=$PDFCPU_VERSION' -X 'github.com/pdfcpu/pdfcpu/pkg/pdfcpu.VersionStr=$PDFCPU_VERSION' -X main.builtBy=gotenberg" ./cmd/pdfcpu &&\
+    # Verify installation.
+    ./pdfcpu version
+
 # ----------------------------------------------
 # Gotenberg binary build stage
 # ----------------------------------------------
-FROM golang:$GOLANG_VERSION AS binary-stage
+FROM golang:$GOLANG_VERSION AS gotenberg-binary-stage
 
 ARG GOTENBERG_VERSION
-ENV CGO_ENABLED 0
+ENV CGO_ENABLED=0
 
 # Define the working directory outside of $GOPATH (we're using go modules).
 WORKDIR /home
@@ -164,19 +189,20 @@ RUN \
     rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
 RUN \
-    # Install PDFtk & QPDF (PDF engines).
+    # Install PDFtk, QPDF & ExifTool (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 &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends qpdf exiftool &&\
     # See https://github.com/nextcloud/docker/issues/380.
     mkdir -p /usr/share/man/man1 &&\
     # Verify installations.
     pdftk --version &&\
     qpdf --version &&\
+    exiftool --version &&\
     # Cleanup.
     rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
@@ -186,15 +212,20 @@ RUN \
 # 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/
+# Copy the pdfcpu binary from the pdfcpu-binary-stage.
+COPY --from=pdfcpu-binary-stage /home/pdfcpu /usr/bin/
+
+# Copy the Gotenberg binary from the gotenberg-binary-stage.
+COPY --from=gotenberg-binary-stage /home/gotenberg /usr/bin/
 
 # Environment variables required by modules or else.
-ENV CHROMIUM_BIN_PATH /usr/bin/chromium
-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
+ENV CHROMIUM_BIN_PATH=/usr/bin/chromium
+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
+ENV EXIFTOOL_BIN_PATH=/usr/bin/exiftool
+ENV PDFCPU_BIN_PATH=/usr/bin/pdfcpu
 
 USER gotenberg
 WORKDIR /home/gotenberg

build/Dockerfile.cloudrun

@@ -1,7 +1,8 @@
+ARG DOCKER_REGISTRY
 ARG DOCKER_REPOSITORY
 ARG GOTENBERG_VERSION
 
-FROM $DOCKER_REPOSITORY/gotenberg:$GOTENBERG_VERSION
+FROM $DOCKER_REGISTRY/$DOCKER_REPOSITORY:$GOTENBERG_VERSION
 
 USER root
 

cmd/gotenberg.go

@@ -35,6 +35,7 @@ var Version = "snapshot"
 // Run starts the Gotenberg application. Call this in the main of your program.
 func Run() {
 	fmt.Printf(banner, Version)
+	gotenberg.Version = Version
 
 	// Create the root FlagSet and adds the modules flags to it.
 	fs := flag.NewFlagSet("gotenberg", flag.ExitOnError)
@@ -75,7 +76,6 @@ func Run() {
 		go func(app gotenberg.App) {
 			id := app.(gotenberg.Module).Descriptor().ID
 			err = app.Start()
-
 			if err != nil {
 				fmt.Printf("[FATAL] starting %s: %s\n", id, err)
 				os.Exit(1)

go.mod

@@ -1,65 +1,63 @@
 module github.com/gotenberg/gotenberg/v8
 
-go 1.21
+go 1.23.0
 
 require (
 	github.com/alexliesenfeld/health v0.8.0
-	github.com/andybalholm/brotli v1.1.0 // indirect
-	github.com/chromedp/cdproto v0.0.0-20240116100315-4a0ec5e4c400
-	github.com/chromedp/chromedp v0.9.3
+	github.com/andybalholm/brotli v1.1.1 // indirect
+	github.com/barasher/go-exiftool v1.10.0
+	github.com/chromedp/cdproto v0.0.0-20241030022559-23c28aebe8cb
+	github.com/chromedp/chromedp v0.11.1
 	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/uuid v1.5.0
+	github.com/google/uuid v1.6.0
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
-	github.com/hashicorp/go-retryablehttp v0.7.5
-	github.com/klauspost/compress v1.17.4 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.7
+	github.com/klauspost/compress v1.17.11 // indirect
 	github.com/klauspost/pgzip v1.2.6 // indirect
-	github.com/labstack/echo/v4 v4.11.4
+	github.com/labstack/echo/v4 v4.12.0
 	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/microcosm-cc/bluemonday v1.0.27
 	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/prometheus/client_golang v1.20.5
 	github.com/russross/blackfriday/v2 v2.1.0
 	github.com/spf13/pflag v1.0.5
-	github.com/ulikunitz/xz v0.5.11 // indirect
+	github.com/ulikunitz/xz v0.5.12 // 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
+	go.uber.org/zap v1.27.0
+	golang.org/x/crypto v0.28.0 // indirect
+	golang.org/x/net v0.30.0
+	golang.org/x/sync v0.8.0
+	golang.org/x/sys v0.26.0 // indirect
+	golang.org/x/term v0.25.0
+	golang.org/x/text v0.19.0
 )
 
+require github.com/dlclark/regexp2 v1.11.4
+
 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/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/chromedp/sysutil v1.1.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/gobwas/ws v1.4.0 // indirect
+	github.com/golang-jwt/jwt v3.2.2+incompatible // 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.4 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.60.1 // indirect
+	github.com/prometheus/procfs v0.15.1 // 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
+	golang.org/x/time v0.7.0 // indirect
+	google.golang.org/protobuf v1.35.1 // indirect
 )

go.sum

@@ -1,69 +1,70 @@
 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/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
 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/barasher/go-exiftool v1.10.0 h1:f5JY5jc42M7tzR6tbL9508S2IXdIcG9QyieEXNMpIhs=
+github.com/barasher/go-exiftool v1.10.0/go.mod h1:F9s/a3uHSM8YniVfwF+sbQUtP8Gmh9nyzigNF+8vsWo=
 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-20231011050154-1d073bb38998/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
-github.com/chromedp/cdproto v0.0.0-20240116100315-4a0ec5e4c400 h1:mHR3reslmE6J351eW8TgB/BPT+B9OzMxLe7dPa5WYSQ=
-github.com/chromedp/cdproto v0.0.0-20240116100315-4a0ec5e4c400/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
-github.com/chromedp/chromedp v0.9.3 h1:Wq58e0dZOdHsxaj9Owmfcf+ibtpYN1N0FWVbaxa/esg=
-github.com/chromedp/chromedp v0.9.3/go.mod h1:NipeUkUcuzIdFbBP8eNNvl9upcceOfWzoJn6cRe4ksA=
-github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
-github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chromedp/cdproto v0.0.0-20241030022559-23c28aebe8cb h1:yBPpAakATGLWZsVgYRcU9FopbOqzoazzbFaStQ9DCMc=
+github.com/chromedp/cdproto v0.0.0-20241030022559-23c28aebe8cb/go.mod h1:4XqMl3iIW08jtieURWL6Tt5924w21pxirC6th662XUM=
+github.com/chromedp/chromedp v0.11.1 h1:Spca8egFqUlv+JDW+yIs+ijlHlJDPufgrfXPwtq6NMs=
+github.com/chromedp/chromedp v0.11.1/go.mod h1:lr8dFRLKsdTTWb75C/Ttol2vnBKOSnt0BW8R9Xaupi8=
+github.com/chromedp/sysutil v1.1.0 h1:PUFNv5EcprjqXZD9nJb9b/c9ibAbxiYo4exNWZyipwM=
+github.com/chromedp/sysutil v1.1.0/go.mod h1:WiThHUdltqCNKGc4gaU50XgYjwjYIhKWoHGPTUfWTJ8=
+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/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
+github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 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/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
 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.3.0/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
-github.com/gobwas/ws v1.3.2 h1:zlnbNHxumkRvfPWgfXu8RBwyNR1x8wh9cf5PTOCqs9Q=
-github.com/gobwas/ws v1.3.2/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
+github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
+github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
+github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=
+github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
 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/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.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
-github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/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.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/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k=
+github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M=
+github.com/hashicorp/go-retryablehttp v0.7.7 h1:C8hUCYzor8PIfXHa4UrZkU4VvK8o9ISHxT2Q8+VepXU=
+github.com/hashicorp/go-retryablehttp v0.7.7/go.mod h1:pkQpWZeYWskR+D1tR2O5OcBFOxfA7DoAO6xtkuQnHTk=
 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.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.17.4 h1:Ej5ixsIri7BrIjBkRZLTo6ghwrEtHFk7ijlczPW4fZ4=
-github.com/klauspost/compress v1.17.4/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
 github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
 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/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/labstack/echo/v4 v4.12.0 h1:IKpw49IMryVB2p1a4dzwlhP1O2Tf2E0Ir/450lH+kI0=
+github.com/labstack/echo/v4 v4.12.0/go.mod h1:UP9Cr2DJXbOK3Kr9ONYzNowSh7HP0aG0ShAyycHSJvM=
 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=
@@ -75,87 +76,76 @@ github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovk
 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/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
+github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/nwaples/rardecode v1.1.0/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
 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.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/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/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=
+github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/common v0.60.1 h1:FUas6GcOw66yB/73KC+BOZoFJmbo/1pojoILArPAaSc=
+github.com/prometheus/common v0.60.1/go.mod h1:h0LYf1R1deLSKtD4Vdg8gy4RuOvENW2J/h19V5NADQw=
+github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
+github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
 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/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.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 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/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
+github.com/ulikunitz/xz v0.5.12/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.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=
-go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk=
-go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 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=
+go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
+golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
+golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
+golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.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/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.25.0 h1:WtHI/ltw4NvSUig5KARz9h521QvRC8RmF/cuYqifU24=
+golang.org/x/term v0.25.0/go.mod h1:RPyXicDX+6vLxogjjRxjgD2TKtmAO6NZBsBRfrOLu7M=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/time v0.7.0 h1:ntUhktv3OPE6TgYxXWv9vKvUSJyIFJlyohwbkEwPrKQ=
+golang.org/x/time v0.7.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 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-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=
+google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
+google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

pkg/gotenberg/cmd.go

@@ -156,7 +156,7 @@ func (cmd *Cmd) pipeOutput() error {
 		r := bufio.NewReader(reader)
 		defer func(reader io.ReadCloser) {
 			err := reader.Close()
-			if err != nil {
+			if err != nil && !strings.Contains(err.Error(), "file already closed") {
 				logger.Error(fmt.Sprintf("close reader: %s", err))
 			}
 		}(reader)

pkg/gotenberg/cmd_test.go

@@ -104,19 +104,8 @@ func TestCmd_Wait(t *testing.T) {
 			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
-			}(),
+			scenario:        "wait error",
+			cmd:             Command(zap.NewNop(), "echo", "Hello", "World"),
 			expectWaitError: true,
 		},
 	}

pkg/gotenberg/env.go

@@ -0,0 +1,35 @@
+package gotenberg
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+)
+
+// StringEnv retrieves the value of the environment variable named by the key.
+// If the variable is present in the environment and not empty, the value is
+// returned.
+func StringEnv(key string) (string, error) {
+	val, ok := os.LookupEnv(key)
+	if !ok {
+		return "", fmt.Errorf("environment variable '%s' does not exist", key)
+	}
+	if val == "" {
+		return "", fmt.Errorf("environment variable '%s' is empty", key)
+	}
+	return val, nil
+}
+
+// IntEnv relies on [StringEnv] and converts the values if it exists and is not
+// empty.
+func IntEnv(key string) (int, error) {
+	val, err := StringEnv(key)
+	if err != nil {
+		return 0, err
+	}
+	intVal, err := strconv.Atoi(val)
+	if err != nil {
+		return 0, fmt.Errorf("get int value of environment variable '%s': %w", key, err)
+	}
+	return intVal, nil
+}

pkg/gotenberg/env_test.go

@@ -0,0 +1,134 @@
+package gotenberg
+
+import (
+	"os"
+	"testing"
+)
+
+func TestStringEnv(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		key         string
+		setEnv      func()
+		expectVal   string
+		expectError bool
+	}{
+		{
+			scenario:    "non-existing environment variable",
+			key:         "NON_EXISTING",
+			expectVal:   "",
+			expectError: true,
+		},
+		{
+			scenario: "empty environment variable",
+			key:      "EMPTY_STRING",
+			setEnv: func() {
+				err := os.Setenv("EMPTY_STRING", "")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   "",
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			key:      "EXISTING_STRING_VALUE",
+			setEnv: func() {
+				err := os.Setenv("EXISTING_STRING_VALUE", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   "foo",
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.setEnv != nil {
+				tc.setEnv()
+			}
+
+			val, err := StringEnv(tc.key)
+
+			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.expectVal != val {
+				t.Errorf("expected value '%s' but got '%s'", tc.expectVal, val)
+			}
+		})
+	}
+}
+
+func TestIntEnv(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		key         string
+		setEnv      func()
+		expectVal   int
+		expectError bool
+	}{
+		{
+			scenario: "empty environment variable",
+			key:      "EMPTY_INT",
+			setEnv: func() {
+				err := os.Setenv("EMPTY_INT", "")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   0,
+			expectError: true,
+		},
+		{
+			scenario: "non-integer value",
+			key:      "NON_INTEGER",
+			setEnv: func() {
+				err := os.Setenv("NON_INTEGER", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   0,
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			key:      "EXISTING_INT_VALUE",
+			setEnv: func() {
+				err := os.Setenv("EXISTING_INT_VALUE", "123")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   123,
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.setEnv != nil {
+				tc.setEnv()
+			}
+
+			val, err := IntEnv(tc.key)
+
+			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.expectVal != val {
+				t.Errorf("expected value %d but got %d", tc.expectVal, val)
+			}
+		})
+	}
+}

pkg/gotenberg/filter.go

@@ -0,0 +1,53 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/dlclark/regexp2"
+)
+
+// ErrFiltered happens if a value is filtered by the [FilterDeadline] function.
+var ErrFiltered = errors.New("value filtered")
+
+// FilterDeadline checks if given value is allowed and not denied according to
+// regex patterns. It returns a [context.DeadlineExceeded] if it takes too long
+// to process.
+func FilterDeadline(allowed, denied *regexp2.Regexp, s string, deadline time.Time) error {
+	// FIXME: not ideal to compile everytime, but is there another way to create a clone?
+	if allowed.String() != "" {
+		allow := regexp2.MustCompile(allowed.String(), 0)
+		allow.MatchTimeout = time.Until(deadline)
+
+		ok, err := allow.MatchString(s)
+		if err != nil {
+			if time.Now().After(deadline) {
+				return context.DeadlineExceeded
+			}
+			return fmt.Errorf("'%s' cannot handle '%s': %w", allow.String(), s, err)
+		}
+		if !ok {
+			return fmt.Errorf("'%s' does not match the expression from the allowed list: %w", s, ErrFiltered)
+		}
+	}
+
+	if denied.String() != "" {
+		deny := regexp2.MustCompile(denied.String(), 0)
+		deny.MatchTimeout = time.Until(deadline)
+
+		ok, err := deny.MatchString(s)
+		if err != nil {
+			if time.Now().After(deadline) {
+				return context.DeadlineExceeded
+			}
+			return fmt.Errorf("'%s' cannot handle '%s': %w", deny.String(), s, err)
+		}
+		if ok {
+			return fmt.Errorf("'%s' matches the expression from the denied list: %w", s, ErrFiltered)
+		}
+	}
+
+	return nil
+}

pkg/gotenberg/filter_test.go

@@ -0,0 +1,83 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/dlclark/regexp2"
+)
+
+func TestFilterDeadline(t *testing.T) {
+	for _, tc := range []struct {
+		scenario      string
+		allowed       *regexp2.Regexp
+		denied        *regexp2.Regexp
+		s             string
+		deadline      time.Time
+		expectError   bool
+		expectedError error
+	}{
+		{
+			scenario:      "DeadlineExceeded (allowed)",
+			allowed:       regexp2.MustCompile("foo", 0),
+			denied:        regexp2.MustCompile("", 0),
+			s:             "foo",
+			deadline:      time.Now().Add(time.Duration(-1) * time.Hour),
+			expectError:   true,
+			expectedError: context.DeadlineExceeded,
+		},
+		{
+			scenario:      "ErrFiltered (allowed)",
+			allowed:       regexp2.MustCompile("foo", 0),
+			denied:        regexp2.MustCompile("", 0),
+			s:             "bar",
+			deadline:      time.Now().Add(time.Duration(5) * time.Second),
+			expectError:   true,
+			expectedError: ErrFiltered,
+		},
+		{
+			scenario:      "DeadlineExceeded (denied)",
+			allowed:       regexp2.MustCompile("", 0),
+			denied:        regexp2.MustCompile("foo", 0),
+			s:             "foo",
+			deadline:      time.Now().Add(time.Duration(-1) * time.Hour),
+			expectError:   true,
+			expectedError: context.DeadlineExceeded,
+		},
+		{
+			scenario:      "ErrFiltered (denied)",
+			allowed:       regexp2.MustCompile("", 0),
+			denied:        regexp2.MustCompile("foo", 0),
+			s:             "foo",
+			deadline:      time.Now().Add(time.Duration(5) * time.Second),
+			expectError:   true,
+			expectedError: ErrFiltered,
+		},
+		{
+			scenario:    "success",
+			allowed:     regexp2.MustCompile("", 0),
+			denied:      regexp2.MustCompile("", 0),
+			s:           "foo",
+			deadline:    time.Now().Add(time.Duration(5) * time.Second),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := FilterDeadline(tc.allowed, tc.denied, tc.s, tc.deadline)
+
+			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.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+		})
+	}
+}

pkg/gotenberg/flags.go

@@ -1,9 +1,9 @@
 package gotenberg
 
 import (
-	"regexp"
 	"time"
 
+	"github.com/dlclark/regexp2"
 	"github.com/labstack/gommon/bytes"
 	flag "github.com/spf13/pflag"
 )
@@ -168,50 +168,54 @@ func (f *ParsedFlags) MustDeprecatedDuration(deprecated string, newName string)
 	return f.MustDuration(newName)
 }
 
-// MustHumanReadableBytesString returns the human-readable bytes string of a
-// flag given by name.
+// MustHumanReadableBytes returns the human-readable bytes string of a flag
+// given by name.
 // It panics if an error occurs.
-func (f *ParsedFlags) MustHumanReadableBytesString(name string) string {
+func (f *ParsedFlags) MustHumanReadableBytes(name string) int64 {
 	val, err := f.GetString(name)
 	if err != nil {
 		panic(err)
 	}
 
-	_, err = bytes.Parse(val)
+	if val == "" {
+		return 0
+	}
+
+	b, err := bytes.Parse(val)
 	if err != nil {
 		panic(err)
 	}
 
-	return val
+	return b
 }
 
-// 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.
+// MustDeprecatedHumanReadableBytes returns the human-readable bytes 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 {
+func (f *ParsedFlags) MustDeprecatedHumanReadableBytes(deprecated string, newName string) int64 {
 	if f.Changed(deprecated) {
-		return f.MustHumanReadableBytesString(deprecated)
+		return f.MustHumanReadableBytes(deprecated)
 	}
 
-	return f.MustHumanReadableBytesString(newName)
+	return f.MustHumanReadableBytes(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 {
+func (f *ParsedFlags) MustRegexp(name string) *regexp2.Regexp {
 	val, err := f.GetString(name)
 	if err != nil {
 		panic(err)
 	}
 
-	return regexp.MustCompile(val)
+	return regexp2.MustCompile(val, 0)
 }
 
 // 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 {
+func (f *ParsedFlags) MustDeprecatedRegexp(deprecated string, newName string) *regexp2.Regexp {
 	if f.Changed(deprecated) {
 		return f.MustRegexp(deprecated)
 	}

pkg/gotenberg/flags_test.go

@@ -644,10 +644,11 @@ func TestParsedFlags_MustDeprecatedDuration(t *testing.T) {
 	}
 }
 
-func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
+func TestParsedFlags_MustHumanReadableBytes(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.String("foo", "1MB", "")
 	fs.String("bar", "1MB", "")
+	fs.String("qux", "", "")
 
 	err := fs.Parse([]string{"--foo=1GB", "--bar=foo"})
 	if err != nil {
@@ -671,6 +672,11 @@ func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
 			name:        "bar",
 			expectPanic: true,
 		},
+		{
+			scenario:    "success: empty value",
+			name:        "qux",
+			expectPanic: false,
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
@@ -689,31 +695,31 @@ func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
 				}()
 			}
 
-			parsedFlags.MustHumanReadableBytesString(tc.name)
+			parsedFlags.MustHumanReadableBytes(tc.name)
 		})
 	}
 }
 
-func TestParsedFlags_MustDeprecatedHumanReadableBytesString(t *testing.T) {
+func TestParsedFlags_MustDeprecatedHumanReadableBytes(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
 		rawFlags    []string
-		expectValue string
+		expectValue int64
 	}{
 		{
 			scenario:    "deprecated flag value",
 			rawFlags:    []string{"--foo=1MB"},
-			expectValue: "1MB",
+			expectValue: 1000000,
 		},
 		{
 			scenario:    "non-deprecated flag value",
 			rawFlags:    []string{"--bar=2MB"},
-			expectValue: "2MB",
+			expectValue: 2000000,
 		},
 		{
 			scenario:    "deprecated flag value > non-deprecated flag value",
 			rawFlags:    []string{"--foo=1MB", "--bar=2MB"},
-			expectValue: "1MB",
+			expectValue: 1000000,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
@@ -728,9 +734,9 @@ func TestParsedFlags_MustDeprecatedHumanReadableBytesString(t *testing.T) {
 				t.Fatalf("expected no error but got: %v", err)
 			}
 
-			actual := parsedFlags.MustDeprecatedHumanReadableBytesString("foo", "bar")
+			actual := parsedFlags.MustDeprecatedHumanReadableBytes("foo", "bar")
 			if actual != tc.expectValue {
-				t.Errorf("expected '%s' but got '%s'", tc.expectValue, actual)
+				t.Errorf("expected %d but got %d", tc.expectValue, actual)
 			}
 		})
 	}

pkg/gotenberg/fs.go

@@ -51,3 +51,11 @@ func (fs *FileSystem) MkdirAll() (string, error) {
 
 	return path, nil
 }
+
+// PathRename defines the method signature for renaming files. Implement this
+// interface if you don't want to rely on [os.Rename], notably for testing
+// purpose.
+type PathRename interface {
+	// Rename uses the same signature as [os.Rename].
+	Rename(oldpath, newpath string) error
+}

pkg/gotenberg/logging.go

@@ -1,6 +1,11 @@
 package gotenberg
 
-import "go.uber.org/zap"
+import (
+	"fmt"
+
+	"github.com/hashicorp/go-retryablehttp"
+	"go.uber.org/zap"
+)
 
 // LoggerProvider is an interface for a module that supplies a method for
 // creating a [zap.Logger] instance for use by other modules.
@@ -12,3 +17,41 @@ import "go.uber.org/zap"
 type LoggerProvider interface {
 	Logger(mod Module) (*zap.Logger, error)
 }
+
+// LeveledLogger is wrapper around a [zap.Logger] so that it may be used by a
+// [retryablehttp.Client].
+type LeveledLogger struct {
+	logger *zap.Logger
+}
+
+// NewLeveledLogger instantiates a [LeveledLogger].
+func NewLeveledLogger(logger *zap.Logger) *LeveledLogger {
+	return &LeveledLogger{
+		logger: logger,
+	}
+}
+
+// Error logs a message at error level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Error(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Error(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Warn logs a message at warning level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Warn(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Warn(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Info logs a message at info level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Info(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Info(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Debug logs a message at debug level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Debug(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Debug(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Interface guards.
+var (
+	_ retryablehttp.LeveledLogger = (*LeveledLogger)(nil)
+)

pkg/gotenberg/logging_test.go

@@ -1,4 +1,4 @@
-package webhook
+package gotenberg
 
 import (
 	"testing"
@@ -7,17 +7,17 @@ import (
 )
 
 func TestLeveledLogger_Error(t *testing.T) {
-	leveledLogger{logger: zap.NewNop()}.Error("foo")
+	NewLeveledLogger(zap.NewNop()).Error("foo")
 }
 
 func TestLeveledLogger_Warn(t *testing.T) {
-	leveledLogger{logger: zap.NewNop()}.Warn("foo")
+	NewLeveledLogger(zap.NewNop()).Warn("foo")
 }
 
 func TestLeveledLogger_Info(t *testing.T) {
-	leveledLogger{logger: zap.NewNop()}.Info("foo")
+	NewLeveledLogger(zap.NewNop()).Info("foo")
 }
 
 func TestLeveledLogger_Debug(t *testing.T) {
-	leveledLogger{logger: zap.NewNop()}.Debug("foo")
+	NewLeveledLogger(zap.NewNop()).Debug("foo")
 }

pkg/gotenberg/mocks.go

@@ -35,8 +35,10 @@ func (mod *ValidatorMock) Validate() error {
 
 // 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
+	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
+	ReadMetadataMock  func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error)
+	WriteMetadataMock func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error
 }
 
 func (engine *PdfEngineMock) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
@@ -47,6 +49,14 @@ func (engine *PdfEngineMock) Convert(ctx context.Context, logger *zap.Logger, fo
 	return engine.ConvertMock(ctx, logger, formats, inputPath, outputPath)
 }
 
+func (engine *PdfEngineMock) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+	return engine.ReadMetadataMock(ctx, logger, inputPath)
+}
+
+func (engine *PdfEngineMock) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+	return engine.WriteMetadataMock(ctx, logger, metadata, inputPath)
+}
+
 // PdfEngineProviderMock is a mock for the [PdfEngineProvider] interface.
 type PdfEngineProviderMock struct {
 	PdfEngineMock func() (PdfEngine, error)
@@ -127,6 +137,15 @@ func (provider *MetricsProviderMock) Metrics() ([]Metric, error) {
 	return provider.MetricsMock()
 }
 
+// PathRenameMock is a mock for the [PathRename] interface.
+type PathRenameMock struct {
+	RenameMock func(oldpath, newpath string) error
+}
+
+func (rename *PathRenameMock) Rename(oldpath, newpath string) error {
+	return rename.RenameMock(oldpath, newpath)
+}
+
 // Interface guards.
 var (
 	_ Module            = (*ModuleMock)(nil)

pkg/gotenberg/mocks_test.go

@@ -55,6 +55,12 @@ func TestPDFEngineMock(t *testing.T) {
 		ConvertMock: func(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error {
 			return nil
 		},
+		ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+			return nil, nil
+		},
+		WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+			return nil
+		},
 	}
 
 	err := mock.Merge(context.Background(), zap.NewNop(), nil, "")
@@ -66,6 +72,16 @@ func TestPDFEngineMock(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected no error from PdfEngineMock.Convert, but got: %v", err)
 	}
+
+	_, err = mock.ReadMetadata(context.Background(), zap.NewNop(), "")
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineMock.ReadMetadata, but got: %v", err)
+	}
+
+	err = mock.WriteMetadata(context.Background(), zap.NewNop(), map[string]interface{}{}, "")
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineMock.WriteMetadata but got: %v", err)
+	}
 }
 
 func TestPDFEngineProviderMock(t *testing.T) {
@@ -188,3 +204,16 @@ func TestMetricsProviderMock(t *testing.T) {
 		t.Errorf("expected no error from MetricsProviderMock.Metrics, but got: %v", err)
 	}
 }
+
+func TestPathRenameMock(t *testing.T) {
+	mock := &PathRenameMock{
+		RenameMock: func(oldpath, newpath string) error {
+			return nil
+		},
+	}
+
+	err := mock.Rename("", "")
+	if err != nil {
+		t.Errorf("expected no error from PathRenameMock.Rename, but got: %v", err)
+	}
+}

pkg/gotenberg/pdfengine.go

@@ -15,6 +15,10 @@ var (
 	// 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")
+
+	// ErrPdfEngineMetadataValueNotSupported is returned when a metadata value
+	// is not supported.
+	ErrPdfEngineMetadataValueNotSupported = errors.New("metadata value not supported")
 )
 
 const (
@@ -64,6 +68,12 @@ type PdfEngine interface {
 	// 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
+
+	// ReadMetadata extracts the metadata of a given PDF file.
+	ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error)
+
+	// WriteMetadata writes the metadata into a given PDF file.
+	WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error
 }
 
 // PdfEngineProvider offers an interface to instantiate a [PdfEngine].

pkg/gotenberg/sort.go

@@ -0,0 +1,69 @@
+package gotenberg
+
+import (
+	"regexp"
+	"sort"
+	"strconv"
+)
+
+// AlphanumericSort implements sort.Interface and helps to sort strings
+// alphanumerically.
+//
+// See: https://github.com/gotenberg/gotenberg/issues/805.
+type AlphanumericSort []string
+
+func (s AlphanumericSort) Len() int {
+	return len(s)
+}
+
+func (s AlphanumericSort) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s AlphanumericSort) Less(i, j int) bool {
+	numI, restI := extractPrefix(s[i])
+	numJ, restJ := extractPrefix(s[j])
+
+	// Compares numerical prefixes if they exist.
+	if numI != -1 && numJ != -1 {
+		if numI != numJ {
+			return numI < numJ
+		}
+		// If numbers are equal, falls back to string comparison of the rest.
+		return restI < restJ
+	}
+
+	// If one has a numerical prefix and the other doesn't, the one with the
+	// number comes first.
+	if numI != -1 {
+		return true
+	}
+	if numJ != -1 {
+		return false
+	}
+
+	// If neither has a numerical prefix, compare as strings
+	return s[i] < s[j]
+}
+
+// extractPrefix attempts to extract a numerical prefix and the rest of the filename
+func extractPrefix(filename string) (int, string) {
+	matches := numPrefixRegexp.FindStringSubmatch(filename)
+	if len(matches) > 2 {
+		prefix, err := strconv.Atoi(matches[1])
+		if err == nil {
+			return prefix, matches[2]
+		}
+	}
+
+	// Returns -1 if no numerical prefix is found, indicating to just compare
+	// as strings.
+	return -1, filename
+}
+
+var numPrefixRegexp = regexp.MustCompile(`^(\d+)(.*)$`)
+
+// Interface guard.
+var (
+	_ sort.Interface = (*AlphanumericSort)(nil)
+)

pkg/gotenberg/sort_test.go

@@ -0,0 +1,34 @@
+package gotenberg
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func TestAlphanumericSort(t *testing.T) {
+	for _, tc := range []struct {
+		scenario     string
+		values       []string
+		expectedSort []string
+	}{
+		{
+			scenario:     "numeric and letters",
+			values:       []string{"10qux.pdf", "2_baz.txt", "2_aza.txt", "1bar.pdf", "Afoo.txt", "Bbar.docx", "25zeta.txt", "3.pdf", "4_foo.pdf"},
+			expectedSort: []string{"1bar.pdf", "2_aza.txt", "2_baz.txt", "3.pdf", "4_foo.pdf", "10qux.pdf", "25zeta.txt", "Afoo.txt", "Bbar.docx"},
+		},
+		{
+			scenario:     "hrtime (PHP library)",
+			values:       []string{"245654773395259", "245654773395039", "245654773395149", "245654773394919", "245654773394369"},
+			expectedSort: []string{"245654773394369", "245654773394919", "245654773395039", "245654773395149", "245654773395259"},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			sort.Sort(AlphanumericSort(tc.values))
+
+			if !reflect.DeepEqual(tc.values, tc.expectedSort) {
+				t.Fatalf("expected %+v but got: %+v", tc.expectedSort, tc.values)
+			}
+		})
+	}
+}

pkg/gotenberg/supervisor.go

@@ -13,6 +13,10 @@ import (
 // to restart an already restarting [Process].
 var ErrProcessAlreadyRestarting = errors.New("process already restarting")
 
+// ErrMaximumQueueSizeExceeded happens if Run() is called but the maximum queue
+// size is already used.
+var ErrMaximumQueueSizeExceeded = errors.New("maximum queue size exceeded")
+
 // Process is an interface that represents an abstract process
 // and provides methods for starting, stopping, and checking the health of the
 // process.
@@ -74,6 +78,7 @@ type processSupervisor struct {
 	logger          *zap.Logger
 	process         Process
 	maxReqLimit     int64
+	maxQueueSize    int64
 	mutexChan       chan struct{}
 	firstStart      atomic.Bool
 	reqCounter      atomic.Int64
@@ -83,12 +88,13 @@ type processSupervisor struct {
 }
 
 // NewProcessSupervisor initializes a new [ProcessSupervisor].
-func NewProcessSupervisor(logger *zap.Logger, process Process, maxReqLimit int64) ProcessSupervisor {
+func NewProcessSupervisor(logger *zap.Logger, process Process, maxReqLimit, maxQueueSize int64) ProcessSupervisor {
 	b := &processSupervisor{
-		logger:      logger,
-		process:     process,
-		mutexChan:   make(chan struct{}, 1),
-		maxReqLimit: maxReqLimit,
+		logger:       logger,
+		process:      process,
+		mutexChan:    make(chan struct{}, 1),
+		maxReqLimit:  maxReqLimit,
+		maxQueueSize: maxQueueSize,
 	}
 	b.reqCounter.Store(0)
 	b.reqQueueSize.Store(0)
@@ -167,6 +173,25 @@ func (s *processSupervisor) Healthy() bool {
 }
 
 func (s *processSupervisor) Run(ctx context.Context, logger *zap.Logger, task func() error) error {
+	// A user reported a potential issue:
+	//
+	// "Although the counting operation is atomic, nothing prevent 2 concurrent
+	// goroutines to retrieve the same 'currentQueueSize' and to compare its
+	// value against the max limit. Then, resulting queue size would be 1 above
+	// the allowed limit."
+	//
+	// However, he was unable to actually trigger this issue, even when sending
+	// a lot of requests.
+	//
+	// For now, the best option is to consider this issue to be unlikely to
+	// happen, and keep the code as it is because it is more readable this way.
+	//
+	// See https://github.com/gotenberg/gotenberg/issues/951.
+	currentQueueSize := s.reqQueueSize.Load()
+	if s.maxQueueSize > 0 && currentQueueSize >= s.maxQueueSize {
+		return ErrMaximumQueueSizeExceeded
+	}
+
 	s.reqQueueSize.Add(1)
 
 	for {
@@ -176,10 +201,13 @@ func (s *processSupervisor) Run(ctx context.Context, logger *zap.Logger, task fu
 				logger.Debug("process lock acquired")
 				s.reqQueueSize.Add(-1)
 				s.reqCounter.Add(1)
+				releaseMutexChan := true
 
 				defer func() {
-					logger.Debug("process lock released")
-					<-s.mutexChan
+					if releaseMutexChan {
+						logger.Debug("process lock released")
+						<-s.mutexChan
+					}
 				}()
 
 				if !s.firstStart.Load() {
@@ -201,18 +229,26 @@ func (s *processSupervisor) Run(ctx context.Context, logger *zap.Logger, task fu
 					}
 				}
 
+				err := s.runWithDeadline(ctx, task)
+
 				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)
-					}
+					s.logger.Debug("max request limit reached, restarting eagerly...")
+					releaseMutexChan = false
+
+					go func() {
+						err := s.runWithDeadline(context.Background(), func() error {
+							return s.restart()
+						})
+						if err != nil {
+							s.logger.Error(fmt.Sprintf("process restart after task: %v", err))
+						}
+						logger.Debug("process lock released")
+						<-s.mutexChan
+					}()
 				}
 
 				// Note: no error wrapping because it leaks on Chromium console exceptions output.
-				return s.runWithDeadline(ctx, task)
+				return err
 			case <-ctx.Done():
 				logger.Debug("failed to acquire process lock before deadline")
 				s.reqQueueSize.Add(-1)

pkg/gotenberg/supervisor_test.go

@@ -46,7 +46,7 @@ func TestProcessSupervisor_Launch(t *testing.T) {
 				},
 			}
 
-			ps := NewProcessSupervisor(logger, process, 5).(*processSupervisor)
+			ps := NewProcessSupervisor(logger, process, 5, 0).(*processSupervisor)
 			if tc.firstStartSet {
 				ps.firstStart.Store(true)
 			}
@@ -94,7 +94,7 @@ func TestProcessSupervisor_Shutdown(t *testing.T) {
 				},
 			}
 
-			ps := NewProcessSupervisor(logger, process, 5)
+			ps := NewProcessSupervisor(logger, process, 5, 0)
 			err := ps.Shutdown()
 
 			if !tc.expectError && err != nil {
@@ -154,7 +154,7 @@ func TestProcessSupervisor_restart(t *testing.T) {
 				},
 			}
 
-			ps := NewProcessSupervisor(logger, process, 5).(*processSupervisor)
+			ps := NewProcessSupervisor(logger, process, 5, 0).(*processSupervisor)
 			if tc.initiallyRestarting {
 				ps.isRestarting.Store(true)
 			}
@@ -217,7 +217,7 @@ func TestProcessSupervisor_Healthy(t *testing.T) {
 				},
 			}
 
-			ps := NewProcessSupervisor(logger, process, 5).(*processSupervisor)
+			ps := NewProcessSupervisor(logger, process, 5, 0).(*processSupervisor)
 			if tc.initiallyStarted {
 				ps.firstStart.Store(true)
 			}
@@ -249,6 +249,8 @@ func TestProcessSupervisor_Run(t *testing.T) {
 		expectedStartCalls   int64
 		expectedHealthyCalls int64
 		expectedStopCalls    int64
+		currentQueueSize     int64
+		maxQueueSize         int64
 	}{
 		{
 			scenario:             "successfully run task on non-started process",
@@ -323,7 +325,7 @@ func TestProcessSupervisor_Run(t *testing.T) {
 			expectedStopCalls:    1,
 		},
 		{
-			scenario:             "cannot restart after reaching max request limit",
+			scenario:             "auto-restart after reaching max request limit",
 			startError:           errors.New("start error"),
 			initiallyStarted:     true,
 			isRestarting:         false,
@@ -348,6 +350,34 @@ func TestProcessSupervisor_Run(t *testing.T) {
 			expectedHealthyCalls: 1,
 			expectedStopCalls:    0,
 		},
+		{
+			scenario:             "queue size exceeded",
+			initiallyStarted:     false,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          true,
+			expectedStartCalls:   0,
+			expectedHealthyCalls: 0,
+			expectedStopCalls:    0,
+			currentQueueSize:     1,
+			maxQueueSize:         1,
+		},
+		{
+			scenario:             "queue size not exceeded",
+			initiallyStarted:     false,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          true,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    0,
+			currentQueueSize:     1,
+			maxQueueSize:         2,
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			logger := zap.NewNop()
@@ -372,13 +402,16 @@ func TestProcessSupervisor_Run(t *testing.T) {
 				},
 			}
 
-			ps := NewProcessSupervisor(logger, process, tc.maxReqLimit).(*processSupervisor)
+			ps := NewProcessSupervisor(logger, process, tc.maxReqLimit, tc.maxQueueSize).(*processSupervisor)
 			if tc.initiallyStarted {
 				ps.firstStart.Store(true)
 			}
 			if tc.isRestarting {
 				ps.isRestarting.Store(true)
 			}
+			if tc.currentQueueSize > 0 {
+				ps.reqQueueSize.Store(tc.currentQueueSize)
+			}
 
 			task := func() error {
 				return tc.taskError
@@ -418,6 +451,10 @@ func TestProcessSupervisor_Run(t *testing.T) {
 				return
 			}
 
+			// Making sure restarts are finished.
+			ps.mutexChan <- struct{}{}
+			<-ps.mutexChan
+
 			if startCalls.Load() != tc.expectedStartCalls {
 				t.Errorf("expected %d process.Start calls, got %d", tc.expectedStartCalls, startCalls.Load())
 			}
@@ -451,13 +488,13 @@ func TestProcessSupervisor_runWithDeadline(t *testing.T) {
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
-			ps := NewProcessSupervisor(zap.NewNop(), new(ProcessMock), 0).(*processSupervisor)
+			ps := NewProcessSupervisor(zap.NewNop(), new(ProcessMock), 0, 0).(*processSupervisor)
 
 			ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-			defer cancel()
-
 			if tc.ctxDone {
 				cancel()
+			} else {
+				defer cancel()
 			}
 
 			err := ps.runWithDeadline(ctx, func() error {
@@ -485,7 +522,7 @@ func TestProcessSupervisor_ReqQueueSize(t *testing.T) {
 			return true
 		},
 	}
-	ps := NewProcessSupervisor(logger, process, 0).(*processSupervisor)
+	ps := NewProcessSupervisor(logger, process, 0, 0).(*processSupervisor)
 
 	// Simulating a lock.
 	ps.mutexChan <- struct{}{}
@@ -586,7 +623,7 @@ func TestProcessSupervisor_RestartsCount(t *testing.T) {
 				},
 			}
 
-			ps := NewProcessSupervisor(logger, process, 0).(*processSupervisor)
+			ps := NewProcessSupervisor(logger, process, 0, 0).(*processSupervisor)
 			ps.restartsCounter.Store(tc.initialRestartsCount)
 
 			for i := 0; i < tc.restartAttempts; i++ {

pkg/gotenberg/version.go

@@ -0,0 +1,4 @@
+package gotenberg
+
+// Version is the... version of the Gotenberg application.
+var Version = "snapshot"

pkg/modules/api/api.go

@@ -4,14 +4,14 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"net"
 	"net/http"
-	"os"
 	"sort"
-	"strconv"
 	"strings"
 	"time"
 
 	"github.com/alexliesenfeld/health"
+	"github.com/dlclark/regexp2"
 	"github.com/labstack/echo/v4"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/multierr"
@@ -30,10 +30,17 @@ func init() {
 // middlewares or health checks.
 type Api struct {
 	port                      int
+	bindIp                    string
+	tlsCertFile               string
+	tlsKeyFile                string
 	startTimeout              time.Duration
+	bodyLimit                 int64
 	timeout                   time.Duration
 	rootPath                  string
 	traceHeader               string
+	basicAuthUsername         string
+	basicAuthPassword         string
+	downloadFromCfg           downloadFromConfig
 	disableHealthCheckLogging bool
 
 	routes              []Route
@@ -45,6 +52,13 @@ type Api struct {
 	srv                 *echo.Echo
 }
 
+type downloadFromConfig struct {
+	allowList *regexp2.Regexp
+	denyList  *regexp2.Regexp
+	maxRetry  int
+	disable   bool
+}
+
 // Router is a module interface which adds routes to the [Api].
 type Router interface {
 	Routes() ([]Route, error)
@@ -159,12 +173,20 @@ func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
 			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.String("api-bind-ip", "", "Set the IP address the API should bind to for incoming connections")
+			fs.String("api-tls-cert-file", "", "Path to the TLS/SSL certificate file - for HTTPS support")
+			fs.String("api-tls-key-file", "", "Path to the TLS/SSL key file - for HTTPS support")
 			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-body-limit", "", "Set the body limit for multipart/form-data requests - it accepts values like 5MB, 1GB, etc")
 			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-enable-basic-auth", false, "Enable basic authentication - will look for the GOTENBERG_API_BASIC_AUTH_USERNAME and GOTENBERG_API_BASIC_AUTH_PASSWORD environment variables")
+			fs.String("api-download-from-allow-list", "", "Set the allowed URLs for the download from feature using a regular expression")
+			fs.String("api-download-from-deny-list", "", "Set the denied URLs for the download from feature using a regular expression")
+			fs.Int("api-download-from-max-retry", 4, "Set the maximum number of retries for the download from feature")
+			fs.Bool("api-disable-download-from", false, "Disable the download from feature")
 			fs.Bool("api-disable-health-check-logging", false, "Disable health check logging")
-
 			return fs
 		}(),
 		New: func() gotenberg.Module { return new(Api) },
@@ -175,33 +197,47 @@ func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
 func (a *Api) Provision(ctx *gotenberg.Context) error {
 	flags := ctx.ParsedFlags()
 	a.port = flags.MustInt("api-port")
+	a.bindIp = flags.MustString("api-bind-ip")
+	a.tlsCertFile = flags.MustString("api-tls-cert-file")
+	a.tlsKeyFile = flags.MustString("api-tls-key-file")
 	a.startTimeout = flags.MustDuration("api-start-timeout")
 	a.timeout = flags.MustDuration("api-timeout")
+	a.bodyLimit = flags.MustHumanReadableBytes("api-body-limit")
 	a.rootPath = flags.MustString("api-root-path")
 	a.traceHeader = flags.MustString("api-trace-header")
+	a.downloadFromCfg = downloadFromConfig{
+		allowList: flags.MustRegexp("api-download-from-allow-list"),
+		denyList:  flags.MustRegexp("api-download-from-deny-list"),
+		maxRetry:  flags.MustInt("api-download-from-max-retry"),
+		disable:   flags.MustBool("api-disable-download-from"),
+	}
 	a.disableHealthCheckLogging = flags.MustBool("api-disable-health-check-logging")
 
 	// Port from env?
 	portEnvVar := flags.MustString("api-port-from-env")
 	if portEnvVar != "" {
-		val, ok := os.LookupEnv(portEnvVar)
-
-		if !ok {
-			return fmt.Errorf("environment variable '%s' does not exist", portEnvVar)
-		}
-
-		if val == "" {
-			return fmt.Errorf("environment variable '%s' is empty", portEnvVar)
-		}
-
-		port, err := strconv.Atoi(val)
+		port, err := gotenberg.IntEnv(portEnvVar)
 		if err != nil {
-			return fmt.Errorf("get int value of environment variable '%s': %w", portEnvVar, err)
+			return fmt.Errorf("get API port from env: %w", err)
 		}
-
 		a.port = port
 	}
 
+	// Enable basic auth?
+	enableBasicAuth := flags.MustBool("api-enable-basic-auth")
+	if enableBasicAuth {
+		basicAuthUsername, err := gotenberg.StringEnv("GOTENBERG_API_BASIC_AUTH_USERNAME")
+		if err != nil {
+			return fmt.Errorf("get basic auth username from env: %w", err)
+		}
+		basicAuthPassword, err := gotenberg.StringEnv("GOTENBERG_API_BASIC_AUTH_PASSWORD")
+		if err != nil {
+			return fmt.Errorf("get basic auth password from env: %w", err)
+		}
+		a.basicAuthUsername = basicAuthUsername
+		a.basicAuthPassword = basicAuthPassword
+	}
+
 	// Get routes from modules.
 	mods, err := ctx.Modules(new(Router))
 	if err != nil {
@@ -297,6 +333,16 @@ func (a *Api) Validate() error {
 		)
 	}
 
+	if a.bindIp != "" && net.ParseIP(a.bindIp) == nil {
+		err = multierr.Append(err, errors.New("IP must be a valid IP address"))
+	}
+
+	if (a.tlsCertFile != "" && a.tlsKeyFile == "") || (a.tlsCertFile == "" && a.tlsKeyFile != "") {
+		err = multierr.Append(err,
+			errors.New("both TLS certificate and key files must be set"),
+		)
+	}
+
 	if !strings.HasPrefix(a.rootPath, "/") {
 		err = multierr.Append(err,
 			errors.New("root path must start with /"),
@@ -319,8 +365,9 @@ func (a *Api) Validate() error {
 		return err
 	}
 
-	routesMap := make(map[string]string, len(a.routes)+1)
+	routesMap := make(map[string]string, len(a.routes)+2)
 	routesMap["/health"] = "/health"
+	routesMap["/version"] = "/version"
 
 	for _, route := range a.routes {
 		if route.Path == "" {
@@ -402,7 +449,7 @@ func (a *Api) Start() error {
 			a.srv.Pre(externalMiddleware.Handler)
 		case MultipartStack:
 			externalMultipartMiddlewares = append(externalMultipartMiddlewares, externalMiddleware)
-		default:
+		case DefaultStack:
 			a.srv.Use(externalMiddleware.Handler)
 		}
 	}
@@ -413,8 +460,13 @@ func (a *Api) Start() error {
 	for _, route := range a.routes {
 		var middlewares []echo.MiddlewareFunc
 
+		// Basic auth?
+		if a.basicAuthUsername != "" {
+			middlewares = append(middlewares, basicAuthMiddleware(a.basicAuthUsername, a.basicAuthPassword))
+		}
+
 		if route.IsMultipart {
-			middlewares = append(middlewares, contextMiddleware(a.fs, a.timeout))
+			middlewares = append(middlewares, contextMiddleware(a.fs, a.timeout, a.bodyLimit, a.downloadFromCfg))
 
 			for _, externalMultipartMiddleware := range externalMultipartMiddlewares {
 				middlewares = append(middlewares, externalMultipartMiddleware.Handler)
@@ -431,16 +483,33 @@ func (a *Api) Start() error {
 		)
 	}
 
-	// Let's not forget the health check route.
+	// Let's not forget the health check routes...
+	checks := append(a.healthChecks, health.WithTimeout(a.timeout))
+	checker := health.NewChecker(checks...)
+	healthCheckHandler := health.NewHandler(checker)
+
 	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))
+			return echo.WrapHandler(healthCheckHandler)
 		}(),
 		hardTimeoutMiddleware(hardTimeout),
 	)
+	a.srv.HEAD(
+		fmt.Sprintf("%s%s", a.rootPath, "health"),
+		func() echo.HandlerFunc {
+			return echo.WrapHandler(healthCheckHandler)
+		}(),
+		hardTimeoutMiddleware(hardTimeout),
+	)
+
+	// ...and the version route.
+	a.srv.GET(
+		fmt.Sprintf("%s%s", a.rootPath, "version"),
+		func(c echo.Context) error {
+			return c.String(http.StatusOK, gotenberg.Version)
+		},
+	)
 
 	// Wait for all modules to be ready.
 	ctx, cancel := context.WithTimeout(context.Background(), a.startTimeout)
@@ -458,8 +527,15 @@ func (a *Api) Start() error {
 
 	// As the following code is blocking, run it in a goroutine.
 	go func() {
-		server := &http2.Server{}
-		err := a.srv.StartH2CServer(fmt.Sprintf(":%d", a.port), server)
+		var err error
+		if a.tlsCertFile != "" && a.tlsKeyFile != "" {
+			// Start an HTTPS server (supports HTTP/2).
+			err = a.srv.StartTLS(fmt.Sprintf("%s:%d", a.bindIp, a.port), a.tlsCertFile, a.tlsKeyFile)
+		} else {
+			// Start an HTTP/2 Cleartext (non-HTTPS) server.
+			server := &http2.Server{}
+			err = a.srv.StartH2CServer(fmt.Sprintf("%s:%d", a.bindIp, a.port), server)
+		}
 		if !errors.Is(err, http.ErrServerClosed) {
 			a.logger.Fatal(err.Error())
 		}
@@ -470,7 +546,11 @@ func (a *Api) Start() error {
 
 // StartupMessage returns a custom startup message.
 func (a *Api) StartupMessage() string {
-	return fmt.Sprintf("server listening on port %d", a.port)
+	ip := a.bindIp
+	if a.bindIp == "" {
+		ip = "[::]"
+	}
+	return fmt.Sprintf("server started on %s:%d", ip, a.port)
 }
 
 // Stop stops the HTTP server.

pkg/modules/api/api_test.go

@@ -57,30 +57,6 @@ func TestApi_Provision(t *testing.T) {
 			}(),
 			expectError: true,
 		},
-		{
-			scenario: "port from env: empty environment variable",
-			ctx: func() *gotenberg.Context {
-				fs := new(Api).Descriptor().FlagSet
-				err := fs.Parse([]string{"--api-port-from-env=PORT"})
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				return gotenberg.NewContext(
-					gotenberg.ParsedFlags{
-						FlagSet: fs,
-					},
-					nil,
-				)
-			}(),
-			setEnv: func() {
-				err := os.Setenv("PORT", "")
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-			},
-			expectError: true,
-		},
 		{
 			scenario: "port from env: invalid environment variable value",
 			ctx: func() *gotenberg.Context {
@@ -105,6 +81,48 @@ func TestApi_Provision(t *testing.T) {
 			},
 			expectError: true,
 		},
+		{
+			scenario: "basic auth: non-existing GOTENBERG_API_BASIC_AUTH_USERNAME environment variable",
+			ctx: func() *gotenberg.Context {
+				fs := new(Api).Descriptor().FlagSet
+				err := fs.Parse([]string{"--api-enable-basic-auth=true"})
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "basic auth: non-existing GOTENBERG_API_BASIC_AUTH_PASSWORD environment variable",
+			ctx: func() *gotenberg.Context {
+				fs := new(Api).Descriptor().FlagSet
+				err := fs.Parse([]string{"--api-enable-basic-auth=true"})
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			setEnv: func() {
+				err := os.Setenv("GOTENBERG_API_BASIC_AUTH_USERNAME", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectError: true,
+		},
 		{
 			scenario: "no valid routers",
 			ctx: func() *gotenberg.Context {
@@ -361,7 +379,7 @@ func TestApi_Provision(t *testing.T) {
 				}
 
 				fs := new(Api).Descriptor().FlagSet
-				err := fs.Parse([]string{"--api-port-from-env=PORT"})
+				err := fs.Parse([]string{"--api-port-from-env=PORT", "--api-enable-basic-auth=true"})
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -383,6 +401,14 @@ func TestApi_Provision(t *testing.T) {
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
+				err = os.Setenv("GOTENBERG_API_BASIC_AUTH_USERNAME", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				err = os.Setenv("GOTENBERG_API_BASIC_AUTH_PASSWORD", "bar")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
 			},
 			expectPort: 1337,
 			expectMiddlewares: []Middleware{
@@ -436,6 +462,9 @@ func TestApi_Validate(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
 		port        int
+		bindIp      string
+		tlsCertFile string
+		tlsKeyFile  string
 		rootPath    string
 		traceHeader string
 		routes      []Route
@@ -445,6 +474,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid port (< 1)",
 			port:        0,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes:      nil,
@@ -454,6 +484,39 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid port (> 65535)",
 			port:        65536,
+			bindIp:      "127.0.0.1",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid IP",
+			port:        10,
+			bindIp:      "foo",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid TLS files: only cert file provided",
+			port:        10,
+			bindIp:      "127.0.0.1",
+			tlsCertFile: "cert.pem",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid TLS files: only key file provided",
+			port:        10,
+			bindIp:      "127.0.0.1",
+			tlsKeyFile:  "key.pem",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes:      nil,
@@ -463,6 +526,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid root path: missing / prefix",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "foo/",
 			traceHeader: "foo",
 			routes:      nil,
@@ -472,6 +536,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid root path: missing / suffix",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo",
 			traceHeader: "foo",
 			routes:      nil,
@@ -481,6 +546,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid trace header",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "",
 			routes:      nil,
@@ -490,6 +556,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: empty path",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -503,6 +570,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: missing / prefix in path",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -516,6 +584,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid multipart route: no /forms prefix in path",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -530,6 +599,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: no method",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -544,6 +614,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: nil handler",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -559,6 +630,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: path already existing",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -579,6 +651,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid middleware: nil handler",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes:      nil,
@@ -593,6 +666,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "success",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -621,10 +695,34 @@ func TestApi_Validate(t *testing.T) {
 				},
 			},
 		},
+		{
+			scenario:    "success with TLS",
+			port:        10,
+			tlsCertFile: "cert.pem",
+			tlsKeyFile:  "key.pem",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Method:  http.MethodGet,
+					Path:    "/foo",
+					Handler: func(_ echo.Context) error { return nil },
+				},
+				{
+					Method:      http.MethodGet,
+					Path:        "/forms/foo",
+					Handler:     func(_ echo.Context) error { return nil },
+					IsMultipart: true,
+				},
+			},
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			mod := Api{
 				port:                tc.port,
+				bindIp:              tc.bindIp,
+				tlsCertFile:         tc.tlsCertFile,
+				tlsKeyFile:          tc.tlsKeyFile,
 				rootPath:            tc.rootPath,
 				traceHeader:         tc.traceHeader,
 				routes:              tc.routes,
@@ -647,6 +745,8 @@ func TestApi_Start(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
 		readyFn     []func() error
+		tlsCertFile string
+		tlsKeyFile  string
 		expectError bool
 	}{
 		{
@@ -665,12 +765,26 @@ func TestApi_Start(t *testing.T) {
 			},
 			expectError: false,
 		},
+		{
+			scenario: "success with TLS",
+			readyFn: []func() error{
+				func() error { return nil },
+				func() error { return nil },
+			},
+			tlsCertFile: "/tests/test/testdata/api/cert.pem",
+			tlsKeyFile:  "/tests/test/testdata/api/key.pem",
+			expectError: false,
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			mod := new(Api)
 			mod.port = 3000
+			mod.tlsCertFile = tc.tlsCertFile
+			mod.tlsKeyFile = tc.tlsKeyFile
 			mod.startTimeout = time.Duration(30) * time.Second
 			mod.rootPath = "/"
+			mod.basicAuthUsername = "foo"
+			mod.basicAuthPassword = "bar"
 			mod.disableHealthCheckLogging = true
 			mod.routes = []Route{
 				{
@@ -752,11 +866,24 @@ func TestApi_Start(t *testing.T) {
 				return
 			}
 
-			// health request.
+			// health requests.
 			recorder := httptest.NewRecorder()
-			healthRequest := httptest.NewRequest(http.MethodGet, "/health", nil)
 
-			mod.srv.ServeHTTP(recorder, healthRequest)
+			healthGetRequest := httptest.NewRequest(http.MethodGet, "/health", nil)
+			mod.srv.ServeHTTP(recorder, healthGetRequest)
+			if recorder.Code != http.StatusOK {
+				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
+			}
+
+			healthHeadRequest := httptest.NewRequest(http.MethodHead, "/health", nil)
+			mod.srv.ServeHTTP(recorder, healthHeadRequest)
+			if recorder.Code != http.StatusOK {
+				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
+			}
+
+			// version request.
+			versionRequest := httptest.NewRequest(http.MethodGet, "/version", nil)
+			mod.srv.ServeHTTP(recorder, versionRequest)
 			if recorder.Code != http.StatusOK {
 				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
 			}
@@ -764,7 +891,6 @@ func TestApi_Start(t *testing.T) {
 			// "multipart/form-data" request.
 			multipartRequest := func(url string) *http.Request {
 				body := &bytes.Buffer{}
-
 				writer := multipart.NewWriter(body)
 
 				defer func() {
@@ -791,6 +917,7 @@ func TestApi_Start(t *testing.T) {
 
 				req := httptest.NewRequest(http.MethodPost, url, body)
 				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				req.SetBasicAuth(mod.basicAuthUsername, mod.basicAuthPassword)
 
 				return req
 			}
@@ -818,15 +945,36 @@ func TestApi_Start(t *testing.T) {
 }
 
 func TestApi_StartupMessage(t *testing.T) {
-	mod := Api{
-		port: 3000,
-	}
+	for _, tc := range []struct {
+		scenario      string
+		port          int
+		bindIp        string
+		expectMessage string
+	}{
+		{
+			scenario:      "no custom IP",
+			port:          3000,
+			bindIp:        "",
+			expectMessage: "server started on [::]:3000",
+		},
+		{
+			scenario:      "custom IP",
+			port:          3000,
+			bindIp:        "127.0.0.1",
+			expectMessage: "server started on 127.0.0.1:3000",
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := Api{
+				port:   tc.port,
+				bindIp: tc.bindIp,
+			}
 
-	actual := mod.StartupMessage()
-	expect := "server listening on port 3000"
-
-	if actual != expect {
-		t.Errorf("expected '%s' but got '%s'", expect, actual)
+			actual := mod.StartupMessage()
+			if actual != tc.expectMessage {
+				t.Errorf("expected '%s' but got '%s'", tc.expectMessage, actual)
+			}
+		})
 	}
 }
 

pkg/modules/api/context.go

@@ -3,20 +3,25 @@ package api
 import (
 	"compress/flate"
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
+	"mime"
 	"mime/multipart"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync/atomic"
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
 	"github.com/mholt/archiver/v3"
 	"go.uber.org/zap"
+	"golang.org/x/sync/errgroup"
 	"golang.org/x/text/unicode/norm"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
@@ -34,27 +39,80 @@ var (
 
 // Context is the request context for a "multipart/form-data" requests.
 type Context struct {
-	dirPath string
-	values  map[string][]string
-	files   map[string]string
-
+	dirPath     string
+	values      map[string][]string
+	files       map[string]string
 	outputPaths []string
+	cancelled   bool
 
-	cancelled bool
-	logger    *zap.Logger
-	echoCtx   echo.Context
+	logger     *zap.Logger
+	echoCtx    echo.Context
+	pathRename gotenberg.PathRename
 	context.Context
 }
 
+type trackingReader struct {
+	R            io.Reader
+	AddReadBytes func(n int64) error
+}
+
+func (t *trackingReader) Read(p []byte) (int, error) {
+	n, err := t.R.Read(p)
+	if n > 0 {
+		errAddRead := t.AddReadBytes(int64(n))
+		if errAddRead != nil {
+			return n, fmt.Errorf("add read bytes: %w", errAddRead)
+		}
+	}
+	if err != nil {
+		// It's a common practice in Go to return io.EOF unwrapped to signal
+		// the end of a data stream. Wrapping it can lead to unexpected
+		// behavior in standard library functions.
+		return n, err
+	}
+	return n, nil
+}
+
+type downloadFrom struct {
+	// Url is the URL to download a file from.
+	Url string `json:"url"`
+
+	// ExtraHttpHeaders are the HTTP headers to send alongside.
+	ExtraHttpHeaders map[string]string `json:"extraHttpHeaders"`
+}
+
+type osPathRename struct{}
+
+func (o *osPathRename) Rename(oldpath, newpath string) error {
+	return os.Rename(oldpath, newpath)
+}
+
 // 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) {
+func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSystem, timeout time.Duration, bodyLimit int64, downloadFromCfg downloadFromConfig, traceHeader, trace string) (*Context, context.CancelFunc, error) {
 	processCtx, processCancel := context.WithTimeout(context.Background(), timeout)
 
+	// We want to make sure the multipart/form-data does not exceed a given
+	// limit. We consider: form fields (keys, values, files) and files
+	// downloaded remotely ("download from" feature).
+	var totalBytesRead atomic.Int64
+
+	addReadBytes := func(n int64) error {
+		newTotal := totalBytesRead.Add(n)
+		if bodyLimit != 0 && newTotal > bodyLimit {
+			return WrapError(
+				fmt.Errorf("body limit reached (> %d)", bodyLimit),
+				NewSentinelHttpError(http.StatusRequestEntityTooLarge, http.StatusText(http.StatusRequestEntityTooLarge)),
+			)
+		}
+		return nil
+	}
+
 	ctx := &Context{
 		outputPaths: make([]string, 0),
 		cancelled:   false,
 		logger:      logger,
 		echoCtx:     echoCtx,
+		pathRename:  new(osPathRename),
 		Context:     processCtx,
 	}
 
@@ -86,7 +144,6 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 
 	form, err := echoCtx.MultipartForm()
 	if err != nil {
-
 		if errors.Is(err, http.ErrNotMultipart) {
 			return nil, cancel, WrapError(
 				fmt.Errorf("get multipart form: %w", err),
@@ -111,6 +168,19 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		return nil, cancel, fmt.Errorf("get multipart form: %w", err)
 	}
 
+	// This will ensure we do not exceed the body limit.
+	var formValuesSize int64
+	for key, valArray := range form.Value {
+		formValuesSize += int64(len(key))
+		for _, val := range valArray {
+			formValuesSize += int64(len(val))
+		}
+	}
+	err = addReadBytes(formValuesSize)
+	if err != nil {
+		return nil, cancel, fmt.Errorf("add read bytes: %w", err)
+	}
+
 	dirPath, err := fs.MkdirAll()
 	if err != nil {
 		return nil, cancel, fmt.Errorf("create working directory: %w", err)
@@ -120,6 +190,150 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 	ctx.values = form.Value
 	ctx.files = make(map[string]string)
 
+	// First, try to download files listed in the "downloadFrom" form field, if
+	// any.
+	raw, ok := ctx.values["downloadFrom"]
+	if !downloadFromCfg.disable && ok {
+		var dls []downloadFrom
+		err = json.Unmarshal([]byte(raw[0]), &dls)
+		if err != nil {
+			return nil, cancel, WrapError(
+				fmt.Errorf("unmarshal json: %w", err),
+				NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'downloadFrom' form field value: %s", err)),
+			)
+		}
+
+		eg, _ := errgroup.WithContext(ctx)
+		for i, dl := range dls {
+			eg.Go(func() error {
+				deadline, ok := ctx.Deadline()
+				if !ok {
+					// Should not happen, as context is created with a timeout.
+					return errors.New("context has no deadline")
+				}
+
+				if strings.TrimSpace(dl.Url) == "" {
+					return WrapError(
+						errors.New("empty download from URL"),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'downloadFrom' form field entry %d: URL must be set", i)),
+					)
+				}
+
+				err := gotenberg.FilterDeadline(downloadFromCfg.allowList, downloadFromCfg.denyList, dl.Url, deadline)
+				if err != nil {
+					return fmt.Errorf("filter URL: %w", err)
+				}
+
+				logger.Debug(fmt.Sprintf("download file from '%s'", dl.Url))
+
+				req, err := retryablehttp.NewRequest(http.MethodGet, dl.Url, nil)
+				if err != nil {
+					return fmt.Errorf("create request to '%s': %w", dl.Url, err)
+				}
+
+				req.Header.Set("User-Agent", "Gotenberg")
+				for key, value := range dl.ExtraHttpHeaders {
+					req.Header.Set(key, value)
+				}
+				req.Header.Set(traceHeader, trace)
+
+				client := &retryablehttp.Client{
+					HTTPClient: &http.Client{
+						Timeout: time.Until(deadline),
+					},
+					RetryMax:     downloadFromCfg.maxRetry,
+					RetryWaitMin: time.Duration(1) * time.Second,
+					RetryWaitMax: time.Until(deadline),
+					Logger:       gotenberg.NewLeveledLogger(logger),
+					CheckRetry:   retryablehttp.DefaultRetryPolicy,
+					Backoff:      retryablehttp.DefaultBackoff,
+				}
+
+				resp, err := client.Do(req)
+				if err != nil {
+					return WrapError(
+						fmt.Errorf("download file from to '%s': %w", dl.Url, err),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Unable to download file from '%s': %s", dl.Url, err)),
+					)
+				}
+				defer func() {
+					err := resp.Body.Close()
+					if err != nil {
+						logger.Error(fmt.Sprintf("close response body from '%s': %s", dl.Url, err))
+					}
+				}()
+
+				if resp.StatusCode != http.StatusOK {
+					return WrapError(
+						fmt.Errorf("download file from to '%s': got status: '%s'", dl.Url, resp.Status),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Unable to download file from '%s': got status: '%s'", dl.Url, resp.Status)),
+					)
+				}
+
+				contentDisposition := resp.Header.Get("Content-Disposition")
+				if contentDisposition == "" {
+					return WrapError(
+						fmt.Errorf("no 'Content-Disposition' header from '%s'", dl.Url),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("No 'Content-Disposition' header from '%s'", dl.Url)),
+					)
+				}
+
+				// FIXME: the implementation of this method might not be
+				//  complete, as it fails to parse an empty mediatype.
+				//  See: https://github.com/golang/go/issues/69551.
+				_, params, err := mime.ParseMediaType(contentDisposition)
+				if err != nil {
+					return WrapError(
+						fmt.Errorf("parse 'Content-Disposition' header '%s' from '%s': %w", contentDisposition, dl.Url, err),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Content-Disposition' header '%s' from '%s': %s", contentDisposition, dl.Url, err)),
+					)
+				}
+
+				filename, ok := params["filename"]
+				if !ok {
+					return WrapError(
+						fmt.Errorf("get filename from 'Content-Disposition' header '%s' from '%s'", contentDisposition, dl.Url),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Content-Disposition' header '%s' from '%s': no filename", contentDisposition, dl.Url)),
+					)
+				}
+
+				// Avoid directory traversal and make sure filename characters are
+				// normalized.
+				// See: https://github.com/gotenberg/gotenberg/issues/662.
+				filename = norm.NFC.String(filepath.Base(filename))
+				path := fmt.Sprintf("%s/%s", ctx.dirPath, filename)
+
+				out, err := os.Create(path)
+				if err != nil {
+					return fmt.Errorf("create local file: %w", err)
+				}
+				defer func() {
+					err := out.Close()
+					if err != nil {
+						logger.Error(fmt.Sprintf("close local file: %s", err))
+					}
+				}()
+
+				// This will ensure we do not exceed the body limit.
+				reader := &trackingReader{R: resp.Body, AddReadBytes: addReadBytes}
+
+				_, err = io.Copy(out, reader)
+				if err != nil {
+					return fmt.Errorf("copy downloaded file from '%s' to local file: %w", dl.Url, err)
+				}
+
+				ctx.files[filename] = path
+
+				return nil
+			})
+		}
+
+		err = eg.Wait()
+		if err != nil {
+			return ctx, cancel, err
+		}
+	}
+
 	copyToDisk := func(fh *multipart.FileHeader) error {
 		in, err := fh.Open()
 		if err != nil {
@@ -133,6 +347,9 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 			}
 		}()
 
+		// This will ensure we do not exceed the body limit.
+		reader := &trackingReader{R: in, AddReadBytes: addReadBytes}
+
 		// Avoid directory traversal and make sure filename characters are
 		// normalized.
 		// See: https://github.com/gotenberg/gotenberg/issues/662.
@@ -143,7 +360,6 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		if err != nil {
 			return fmt.Errorf("create local file: %w", err)
 		}
-
 		defer func() {
 			err := out.Close()
 			if err != nil {
@@ -151,7 +367,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 			}
 		}()
 
-		_, err = io.Copy(out, in)
+		_, err = io.Copy(out, reader)
 		if err != nil {
 			return fmt.Errorf("copy multipart file to local file: %w", err)
 		}
@@ -161,10 +377,10 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		return nil
 	}
 
+	// Then, copy the form files, if any.
 	for _, files := range form.File {
 		for _, fh := range files {
 			err = copyToDisk(fh)
-
 			if err != nil {
 				return ctx, cancel, fmt.Errorf("copy to disk: %w", err)
 			}
@@ -173,6 +389,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 
 	ctx.Log().Debug(fmt.Sprintf("form fields: %+v", ctx.values))
 	ctx.Log().Debug(fmt.Sprintf("form files: %+v", ctx.files))
+	ctx.Log().Debug(fmt.Sprintf("total bytes: %d", totalBytesRead.Load()))
 
 	return ctx, cancel, err
 }
@@ -191,10 +408,20 @@ func (ctx *Context) FormData() *FormData {
 	}
 }
 
-// GeneratePath generates a path within the context's working directory. It
-// does not create a file.
+// GeneratePath generates a path within the context's working directory.
+// It generates a new UUID-based filename. It does not create a file.
 func (ctx *Context) GeneratePath(extension string) string {
-	return fmt.Sprintf("%s/%s%s", ctx.dirPath, uuid.New(), extension)
+	return fmt.Sprintf("%s/%s%s", ctx.dirPath, uuid.New().String(), extension)
+}
+
+// Rename is just a wrapper around [os.Rename], as we need to mock this
+// behavior in our tests.
+func (ctx *Context) Rename(oldpath, newpath string) error {
+	err := ctx.pathRename.Rename(oldpath, newpath)
+	if err != nil {
+		return fmt.Errorf("rename path: %w", err)
+	}
+	return nil
 }
 
 // AddOutputPaths adds the given paths. Those paths will be used later to build
@@ -269,3 +496,8 @@ func (ctx *Context) OutputFilename(outputPath string) string {
 
 	return fmt.Sprintf("%s%s", filename, filepath.Ext(outputPath))
 }
+
+// Interface guard.
+var (
+	_ gotenberg.PathRename = (*osPathRename)(nil)
+)

pkg/modules/api/context_test.go

@@ -2,26 +2,103 @@ package api
 
 import (
 	"bytes"
+	"context"
 	"errors"
+	"fmt"
+	"io"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
 	"os"
+	"path/filepath"
 	"reflect"
 	"strings"
 	"testing"
 	"time"
 
+	"github.com/dlclark/regexp2"
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
+func TestOsPathRename_Rename(t *testing.T) {
+	dirPath, err := gotenberg.NewFileSystem().MkdirAll()
+	if err != nil {
+		t.Fatalf("create working directory: %v", err)
+	}
+
+	path := "/tests/test/testdata/api/sample1.txt"
+	copyPath := filepath.Join(dirPath, fmt.Sprintf("%s.txt", uuid.NewString()))
+
+	in, err := os.Open(path)
+	if err != nil {
+		t.Fatalf("open file: %v", err)
+	}
+
+	defer func() {
+		err := in.Close()
+		if err != nil {
+			t.Fatalf("close file: %v", err)
+		}
+	}()
+
+	out, err := os.Create(copyPath)
+	if err != nil {
+		t.Fatalf("create new file: %v", err)
+	}
+
+	defer func() {
+		err := out.Close()
+		if err != nil {
+			t.Fatalf("close new file: %v", err)
+		}
+	}()
+
+	_, err = io.Copy(out, in)
+	if err != nil {
+		t.Fatalf("copy file to new file: %v", err)
+	}
+
+	rename := new(osPathRename)
+	newPath := filepath.Join(dirPath, fmt.Sprintf("%s.txt", uuid.NewString()))
+
+	err = rename.Rename(copyPath, newPath)
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+
+	err = os.RemoveAll(dirPath)
+	if err != nil {
+		t.Fatalf("remove working directory: %v", err)
+	}
+}
+
 func TestNewContext(t *testing.T) {
+	defaultAllowList, err := regexp2.Compile("", 0)
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+	defaultDenyList, err := regexp2.Compile("", 0)
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+	defaultDownloadFromCfg := downloadFromConfig{
+		allowList: defaultAllowList,
+		denyList:  defaultDenyList,
+		maxRetry:  1,
+		disable:   false,
+	}
+
 	for _, tc := range []struct {
 		scenario         string
 		request          *http.Request
+		bodyLimit        int64
+		downloadFromCfg  downloadFromConfig
+		downloadFromSrv  *echo.Echo
+		expectContext    *Context
 		expectError      bool
 		expectHttpError  bool
 		expectHttpStatus int
@@ -67,6 +144,325 @@ func TestNewContext(t *testing.T) {
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
 		},
+		{
+			scenario: "request entity too large: form values",
+			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("key", "value")
+				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
+			}(),
+			bodyLimit:        1,
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusRequestEntityTooLarge,
+		},
+		{
+			scenario: "request entity too large: downloadFrom",
+			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("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				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
+			}(),
+			bodyLimit: 45, // form values = 44 bytes.
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					c.Response().Header().Set(echo.HeaderContentDisposition, `attachment; filename="bar.txt"`)
+					c.Response().Header().Set(echo.HeaderContentType, "text/plain")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusRequestEntityTooLarge,
+		},
+		{
+			scenario: "request entity too large: form files",
+			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)
+					}
+				}()
+				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
+			}(),
+			bodyLimit:        1,
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusRequestEntityTooLarge,
+		},
+		{
+			scenario: "invalid downloadFrom form field: cannot unmarshal",
+			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("downloadFrom", "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
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: no URL",
+			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("downloadFrom", `[{}]`)
+				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
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: filtered URL",
+			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("downloadFrom", `[{"url":"https://foo.bar"}]`)
+				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
+			}(),
+			downloadFromCfg: func() downloadFromConfig {
+				denyList, err := regexp2.Compile("https://foo.bar", 0)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return downloadFromConfig{allowList: defaultAllowList, denyList: denyList, maxRetry: 1, disable: false}
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "invalid downloadFrom form field: unreachable URL",
+			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("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				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
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: invalid status code",
+			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("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				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
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					return c.String(http.StatusNotFound, http.StatusText(http.StatusNotFound))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: no 'Content-Disposition' header",
+			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("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				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
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: malformed 'Content-Disposition' header",
+			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("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				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
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					c.Response().Header().Set(echo.HeaderContentDisposition, ";;")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: no filename parameter in 'Content-Disposition' header",
+			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("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				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
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					c.Response().Header().Set(echo.HeaderContentDisposition, "inline;")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
 		{
 			scenario: "success",
 			request: func() *http.Request {
@@ -90,17 +486,69 @@ func TestNewContext(t *testing.T) {
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
+				err = writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/","extraHttpHeaders":{"X-Foo":"Bar"}}]`)
+				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
 			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					if c.Request().Header.Get("User-Agent") != "Gotenberg" {
+						t.Fatalf("expected 'Gotenberg' from header 'User-Agent', but got '%s'", c.Request().Header.Get("User-Agent"))
+					}
+					if c.Request().Header.Get("X-Foo") != "Bar" {
+						t.Fatalf("expected 'Bar' from header 'X-Foo', but got '%s'", c.Request().Header.Get("X-Foo"))
+					}
+					if c.Request().Header.Get("Gotenberg-Trace") != "123" {
+						t.Fatalf("expected '123' from header 'Gotenberg-Trace', but got '%s'", c.Request().Header.Get("Gotenberg-Trace"))
+					}
+					c.Response().Header().Set(echo.HeaderContentDisposition, `attachment; filename="bar.txt"`)
+					c.Response().Header().Set(echo.HeaderContentType, "text/plain")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg: defaultDownloadFromCfg,
+			expectContext: &Context{
+				values: map[string][]string{
+					"foo": {"foo"},
+					"downloadFrom": {
+						`[{"url":"http://localhost:80/","extraHttpHeaders":{"X-Foo":"Bar"}}]`,
+					},
+				},
+				files: map[string]string{
+					"foo.txt": "foo.txt",
+					"bar.txt": "bar.txt", // downloadFrom.
+				},
+			},
 			expectError:     false,
 			expectHttpError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.downloadFromSrv != nil {
+				go func() {
+					err := tc.downloadFromSrv.Start(":80")
+					if !errors.Is(err, http.ErrServerClosed) {
+						t.Error(err)
+						return
+					}
+				}()
+				defer func() {
+					err := tc.downloadFromSrv.Shutdown(context.TODO())
+					if err != nil {
+						t.Error(err)
+					}
+				}()
+			}
+
 			handler := func(c echo.Context) error {
-				_, cancel, err := newContext(c, zap.NewNop(), gotenberg.NewFileSystem(), time.Duration(10)*time.Second)
+				ctx, cancel, err := newContext(c, zap.NewNop(), gotenberg.NewFileSystem(), time.Duration(10)*time.Second, tc.bodyLimit, tc.downloadFromCfg, "Gotenberg-Trace", "123")
 				defer cancel()
 				// Context already cancelled.
 				defer cancel()
@@ -109,6 +557,20 @@ func TestNewContext(t *testing.T) {
 					return err
 				}
 
+				if tc.expectContext != nil {
+					if !reflect.DeepEqual(tc.expectContext.values, ctx.values) {
+						t.Fatalf("expected context.values to be %v but got %v", tc.expectContext.values, ctx.values)
+					}
+					if len(tc.expectContext.files) != len(ctx.files) {
+						t.Fatalf("expected context.files to contain %d items but got %d", len(tc.expectContext.files), len(ctx.files))
+					}
+					for key, value := range tc.expectContext.files {
+						if !strings.HasSuffix(ctx.files[key], value) {
+							t.Fatalf("expected context.files to contain '%s' but got '%s'", value, ctx.files[key])
+						}
+					}
+				}
+
 				return nil
 			}
 
@@ -191,12 +653,46 @@ func TestContext_GeneratePath(t *testing.T) {
 	}
 
 	path := ctx.GeneratePath(".pdf")
-
 	if !strings.HasPrefix(path, ctx.dirPath) {
 		t.Errorf("expected '%s' to start with '%s'", path, ctx.dirPath)
 	}
 }
 
+func TestContext_Rename(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *Context
+		expectError bool
+	}{
+		{
+			scenario: "failure",
+			ctx: &Context{pathRename: &gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+				return errors.New("cannot rename")
+			}}},
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			ctx: &Context{pathRename: &gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+				return nil
+			}}},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.ctx.Rename("", "")
+
+			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)
+			}
+		})
+	}
+}
+
 func TestContext_AddOutputPaths(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string

pkg/modules/api/formdata.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"fmt"
+	"math"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -11,6 +12,8 @@ import (
 	"time"
 
 	"go.uber.org/multierr"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
 // FormData is a helper for validating and hydrating values from a
@@ -143,6 +146,91 @@ func (form *FormData) MandatoryDuration(key string, target *time.Duration) *Form
 	return form.mustMandatoryField(key, target)
 }
 
+// Inches binds a form field to a float64 variable. It populates an error
+// if the value cannot be computed back to inches.
+//
+//	var foo float64
+//
+//	ctx.FormData().Inches("foo", &foo, 2.0)
+func (form *FormData) Inches(key string, target *float64, defaultValue float64) *FormData {
+	form.inches(key, target)
+	if *target == -math.MaxFloat64 {
+		*target = defaultValue
+	}
+	return form
+}
+
+// MandatoryInches binds a form field to a float64 variable. It populates
+// an error if the value cannot be computed back to inches, is empty, or the
+// "key" does not exist.
+//
+//	var foo float64
+//
+//	ctx.FormData().MandatoryInches("foo", &foo)
+func (form *FormData) MandatoryInches(key string, target *float64) *FormData {
+	val, ok := form.values[key]
+	if !ok || val[0] == "" {
+		form.append(
+			fmt.Errorf("form field '%s' is required", key),
+		)
+		return form
+	}
+	return form.inches(key, target)
+}
+
+// inches tries to compute a string value to inches.
+func (form *FormData) inches(key string, target *float64) *FormData {
+	var value string
+	form.mustValue(key, &value, "")
+
+	if value == "" {
+		*target = -math.MaxFloat64
+		return form
+	}
+
+	for _, unit := range []string{"pt", "px", "in", "mm", "cm", "pc"} {
+		if !strings.HasSuffix(value, unit) {
+			continue
+		}
+
+		val, err := strconv.ParseFloat(strings.TrimSuffix(value, unit), 64)
+		if err != nil {
+			form.append(
+				fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+			)
+			return form
+		}
+
+		switch unit {
+		case "pt":
+			*target = val * (1.0 / 72.0)
+		case "px":
+			*target = val * (1.0 / 96.0)
+		case "in":
+			*target = val
+		case "mm":
+			*target = val * (1.0 / 25.4)
+		case "cm":
+			*target = val * (1.0 / 2.54)
+		case "pc":
+			*target = val * (1.0 / 6.0)
+		}
+
+		return form
+	}
+
+	val, err := strconv.ParseFloat(value, 64)
+	if err != nil {
+		form.append(
+			fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+		)
+		return form
+	}
+
+	*target = val
+	return form
+}
+
 // Custom helps to define a custom binding function for a form field.
 //
 //	var foo map[string]string
@@ -304,7 +392,7 @@ func (form *FormData) paths(extensions []string, target *[]string) *FormData {
 	}
 
 	// See https://github.com/gotenberg/gotenberg/issues/139.
-	sort.Strings(*target)
+	sort.Sort(gotenberg.AlphanumericSort(*target))
 
 	return form
 }

pkg/modules/api/formdata_test.go

@@ -3,6 +3,7 @@ package api
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"reflect"
 	"testing"
 	"time"
@@ -768,6 +769,333 @@ func TestFormData_MandatoryDuration(t *testing.T) {
 	}
 }
 
+func TestFormData_Inches(t *testing.T) {
+	for _, tc := range []struct {
+		scenario     string
+		form         *FormData
+		defaultValue float64
+		expect       float64
+		expectError  bool
+	}{
+		{
+			scenario:     "key does not exist, fallback to default zero value",
+			form:         &FormData{},
+			defaultValue: 0.0,
+			expect:       0.0,
+			expectError:  false,
+		},
+		{
+			scenario:     "key does not exist, fallback to default value",
+			form:         &FormData{},
+			defaultValue: 2.5,
+			expect:       2.5,
+			expectError:  false,
+		},
+		{
+			scenario: "key does exist, but empty value, fallback to default value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       0.0,
+			expectError:  false,
+		},
+		{
+			scenario: "key does exist, value has a unit, but the rest is not float64 compatible",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"foomm",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       0.0,
+			expectError:  true,
+		},
+		{
+			scenario: "key does exist, but value has no unit and is invalid",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"foo",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       0.0,
+			expectError:  true,
+		},
+		{
+			scenario: "key does exist with a pt value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"72pt",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       1.0,
+			expectError:  false,
+		},
+		{
+			scenario: "key does exist with a px value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"96px",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       1.0,
+			expectError:  false,
+		},
+		{
+			scenario: "key does exist with an in value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"1in",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       1.0,
+			expectError:  false,
+		},
+		{
+			scenario: "key does exist with a mm value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"25.4mm",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       1.0,
+			expectError:  false,
+		},
+		{
+			scenario: "key does exist with a cm value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"2.54cm",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       1.0,
+			expectError:  false,
+		},
+		{
+			scenario: "key does exist with a pc value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"6pc",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       1.0,
+			expectError:  false,
+		},
+		{
+			scenario: "key does exist with no unit in the value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"100",
+					},
+				},
+			},
+			defaultValue: 0.0,
+			expect:       100,
+			expectError:  false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			var actual float64
+
+			tc.form.Inches("foo", &actual, tc.defaultValue)
+
+			if fmt.Sprintf("%.1f", actual) != fmt.Sprintf("%.1f", tc.expect) {
+				t.Errorf("expected %.1f but got %.1f", tc.expect, actual)
+			}
+
+			if tc.expectError && tc.form.errors == nil {
+				t.Fatal("expected error but got none", tc.form.errors)
+			}
+
+			if !tc.expectError && tc.form.errors != nil {
+				t.Fatalf("expected no error but got: %v", tc.form.errors)
+			}
+		})
+	}
+}
+
+func TestFormData_MandatoryInches(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		form        *FormData
+		expect      float64
+		expectError bool
+	}{
+		{
+			scenario:    "missing mandatory key",
+			form:        &FormData{},
+			expect:      0.0,
+			expectError: true,
+		},
+		{
+			scenario: "mandatory value is empty",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"",
+					},
+				},
+			},
+			expect:      0.0,
+			expectError: true,
+		},
+		{
+			scenario: "mandatory value has a unit, but the rest is not float64 compatible",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"foomm",
+					},
+				},
+			},
+			expect:      0.0,
+			expectError: true,
+		},
+		{
+			scenario: "mandatory value has no unit and is invalid",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"foo",
+					},
+				},
+			},
+			expect:      0.0,
+			expectError: true,
+		},
+		{
+			scenario: "a pt mandatory value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"72pt",
+					},
+				},
+			},
+			expect:      1.0,
+			expectError: false,
+		},
+		{
+			scenario: "a px mandatory value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"96px",
+					},
+				},
+			},
+			expect:      1.0,
+			expectError: false,
+		},
+		{
+			scenario: "an in mandatory value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"1in",
+					},
+				},
+			},
+			expect:      1.0,
+			expectError: false,
+		},
+		{
+			scenario: "a mm mandatory value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"25.4mm",
+					},
+				},
+			},
+			expect:      1.0,
+			expectError: false,
+		},
+		{
+			scenario: "a cm mandatory value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"2.54cm",
+					},
+				},
+			},
+			expect:      1.0,
+			expectError: false,
+		},
+		{
+			scenario: "a pc mandatory value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"6pc",
+					},
+				},
+			},
+			expect:      1.0,
+			expectError: false,
+		},
+		{
+			scenario: "no unit in the mandatory value",
+			form: &FormData{
+				values: map[string][]string{
+					"foo": {
+						"100",
+					},
+				},
+			},
+			expect:      100,
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			var actual float64
+
+			tc.form.MandatoryInches("foo", &actual)
+
+			if fmt.Sprintf("%.1f", actual) != fmt.Sprintf("%.1f", tc.expect) {
+				t.Errorf("expected %.1f but got %.1f", tc.expect, actual)
+			}
+
+			if tc.expectError && tc.form.errors == nil {
+				t.Fatal("expected error but got none", tc.form.errors)
+			}
+
+			if !tc.expectError && tc.form.errors != nil {
+				t.Fatalf("expected no error but got: %v", tc.form.errors)
+			}
+		})
+	}
+}
+
 func TestFormData_Custom(t *testing.T) {
 	for _, tc := range []struct {
 		scenario     string

pkg/modules/api/middlewares.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"context"
+	"crypto/subtle"
 	"errors"
 	"fmt"
 	"net/http"
@@ -10,14 +11,21 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
 	"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")
+var (
+	// ErrAsyncProcess happens when a handler or middleware handles a request
+	// in an asynchronous fashion.
+	ErrAsyncProcess = errors.New("async process")
+
+	// ErrNoOutputFile happens when a handler or middleware handles a request
+	// without sending any output file.
+	ErrNoOutputFile = errors.New("no output file")
+)
 
 // ParseError parses an error and returns the corresponding HTTP status and
 // HTTP message.
@@ -32,6 +40,22 @@ func ParseError(err error) (int, string) {
 		return http.StatusServiceUnavailable, http.StatusText(http.StatusServiceUnavailable)
 	}
 
+	if errors.Is(err, gotenberg.ErrFiltered) {
+		return http.StatusForbidden, http.StatusText(http.StatusForbidden)
+	}
+
+	if errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) {
+		return http.StatusTooManyRequests, http.StatusText(http.StatusTooManyRequests)
+	}
+
+	if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
+		return http.StatusBadRequest, "At least one PDF engine cannot process the requested PDF format, while others may have failed to convert due to different issues"
+	}
+
+	if errors.Is(err, gotenberg.ErrPdfEngineMetadataValueNotSupported) {
+		return http.StatusBadRequest, "At least one PDF engine cannot process the requested metadata, while others may have failed to convert due to different issues"
+	}
+
 	var httpErr HttpError
 	if errors.As(err, &httpErr) {
 		return httpErr.HttpError()
@@ -90,7 +114,6 @@ func rootPathMiddleware(rootPath string) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			c.Set("rootPath", rootPath)
-
 			// Call the next middleware in the chain.
 			return next(c)
 		}
@@ -195,6 +218,17 @@ func loggerMiddleware(logger *zap.Logger, disableLoggingForPaths []string) echo.
 	}
 }
 
+// basicAuthMiddleware manages basic authentication.
+func basicAuthMiddleware(username, password string) echo.MiddlewareFunc {
+	return middleware.BasicAuth(func(u string, p string, e echo.Context) (bool, error) {
+		if subtle.ConstantTimeCompare([]byte(u), []byte(username)) == 1 &&
+			subtle.ConstantTimeCompare([]byte(p), []byte(password)) == 1 {
+			return true, nil
+		}
+		return false, nil
+	})
+}
+
 // 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
@@ -202,14 +236,16 @@ func loggerMiddleware(logger *zap.Logger, disableLoggingForPaths []string) echo.
 //
 //	ctx := c.Get("context").(*api.Context)
 //	cancel := c.Get("cancel").(context.CancelFunc)
-func contextMiddleware(fs *gotenberg.FileSystem, timeout time.Duration) echo.MiddlewareFunc {
+func contextMiddleware(fs *gotenberg.FileSystem, timeout time.Duration, bodyLimit int64, downloadFromCfg downloadFromConfig) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			logger := c.Get("logger").(*zap.Logger)
+			traceHeader := c.Get("traceHeader").(string)
+			trace := c.Get("trace").(string)
 
 			// 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, fs, timeout)
+			ctx, cancel, err := newContext(c, logger, fs, timeout, bodyLimit, downloadFromCfg, traceHeader, trace)
 			if err != nil {
 				cancel()
 
@@ -230,6 +266,13 @@ func contextMiddleware(fs *gotenberg.FileSystem, timeout time.Duration) echo.Mid
 
 			defer cancel()
 
+			if errors.Is(err, ErrNoOutputFile) {
+				// 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 nil
+			}
+
 			if err != nil {
 				return err
 			}

pkg/modules/api/middlewares_test.go

@@ -29,9 +29,24 @@ func TestParseError(t *testing.T) {
 			expectMessage: http.StatusText(http.StatusInternalServerError),
 		},
 		{
-			err:           context.DeadlineExceeded,
-			expectStatus:  http.StatusServiceUnavailable,
-			expectMessage: http.StatusText(http.StatusServiceUnavailable),
+			err:           gotenberg.ErrFiltered,
+			expectStatus:  http.StatusForbidden,
+			expectMessage: http.StatusText(http.StatusForbidden),
+		},
+		{
+			err:           gotenberg.ErrMaximumQueueSizeExceeded,
+			expectStatus:  http.StatusTooManyRequests,
+			expectMessage: http.StatusText(http.StatusTooManyRequests),
+		},
+		{
+			err:           gotenberg.ErrPdfFormatNotSupported,
+			expectStatus:  http.StatusBadRequest,
+			expectMessage: "At least one PDF engine cannot process the requested PDF format, while others may have failed to convert due to different issues",
+		},
+		{
+			err:           gotenberg.ErrPdfEngineMetadataValueNotSupported,
+			expectStatus:  http.StatusBadRequest,
+			expectMessage: "At least one PDF engine cannot process the requested metadata, while others may have failed to convert due to different issues",
 		},
 		{
 			err: WrapError(
@@ -221,6 +236,56 @@ func TestTraceMiddleware(t *testing.T) {
 	}
 }
 
+func TestBasicAuthMiddleware(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		request     *http.Request
+		username    string
+		password    string
+		expectError bool
+	}{
+		{
+			scenario: "invalid basic auth",
+			request: func() *http.Request {
+				req := httptest.NewRequest(http.MethodGet, "/", nil)
+				req.SetBasicAuth("invalid", "invalid")
+				return req
+			}(),
+			username:    "foo",
+			password:    "bar",
+			expectError: true,
+		},
+		{
+			scenario: "valid basic auth",
+			request: func() *http.Request {
+				req := httptest.NewRequest(http.MethodGet, "/", nil)
+				req.SetBasicAuth("foo", "bar")
+				return req
+			}(),
+			username:    "foo",
+			password:    "bar",
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			recorder := httptest.NewRecorder()
+			srv := echo.New()
+			srv.HideBanner = true
+			srv.HidePort = true
+			c := srv.NewContext(tc.request, recorder)
+			err := basicAuthMiddleware(tc.username, tc.password)(func(c echo.Context) error {
+				return nil
+			})(c)
+			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 TestLoggerMiddleware(t *testing.T) {
 	for i, tc := range []struct {
 		request     *http.Request
@@ -320,6 +385,15 @@ func TestContextMiddleware(t *testing.T) {
 			}(),
 			expectStatus: http.StatusNoContent,
 		},
+		{
+			request: buildMultipartFormDataRequest(),
+			next: func() echo.HandlerFunc {
+				return func(c echo.Context) error {
+					return ErrNoOutputFile
+				}
+			}(),
+			expectStatus: http.StatusOK,
+		},
 		{
 			request: buildMultipartFormDataRequest(),
 			next: func() echo.HandlerFunc {
@@ -384,10 +458,11 @@ func TestContextMiddleware(t *testing.T) {
 
 		c := srv.NewContext(tc.request, recorder)
 		c.Set("logger", zap.NewNop())
+		c.Set("traceHeader", "Gotenberg-Trace")
 		c.Set("trace", "foo")
 		c.Set("startTime", time.Now())
 
-		err := contextMiddleware(gotenberg.NewFileSystem(), time.Duration(10)*time.Second)(tc.next)(c)
+		err := contextMiddleware(gotenberg.NewFileSystem(), time.Duration(10)*time.Second, 0, downloadFromConfig{})(tc.next)(c)
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)

pkg/modules/api/mocks.go

@@ -4,6 +4,8 @@ import (
 	"github.com/alexliesenfeld/health"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
 // ContextMock is a helper for tests.
@@ -76,7 +78,7 @@ func (ctx *ContextMock) SetLogger(logger *zap.Logger) {
 	ctx.logger = logger
 }
 
-// SetEchoContext sets the echo.Context.
+// SetEchoContext sets the [echo.Context].
 //
 //	ctx := &api.ContextMock{Context: &api.Context{}}
 //	ctx.setEchoContext(c)
@@ -84,6 +86,14 @@ func (ctx *ContextMock) SetEchoContext(c echo.Context) {
 	ctx.Context.echoCtx = c
 }
 
+// SetPathRename sets the [gotenberg.PathRename].
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	ctx.setPathRename(rename)
+func (ctx *ContextMock) SetPathRename(rename gotenberg.PathRename) {
+	ctx.Context.pathRename = rename
+}
+
 // RouterMock is a mock for the [Router] interface.
 type RouterMock struct {
 	RoutesMock func() ([]Route, error)

pkg/modules/api/mocks_test.go

@@ -117,6 +117,19 @@ func TestContextMock_SetEchoContext(t *testing.T) {
 	}
 }
 
+func TestContextMock_SetPathRename(t *testing.T) {
+	mock := ContextMock{&Context{}}
+
+	expect := new(osPathRename)
+	mock.SetPathRename(expect)
+
+	actual := mock.pathRename
+
+	if actual != expect {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
 func TestRouterMock(t *testing.T) {
 	mock := &RouterMock{
 		RoutesMock: func() ([]Route, error) {

pkg/modules/chromium/browser.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"os"
-	"regexp"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -15,6 +14,7 @@ import (
 	"github.com/chromedp/cdproto/network"
 	"github.com/chromedp/cdproto/runtime"
 	"github.com/chromedp/chromedp"
+	"github.com/dlclark/regexp2"
 	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
@@ -39,8 +39,8 @@ type browserArguments struct {
 	wsUrlReadTimeout         time.Duration
 
 	// Tasks specific.
-	allowList         *regexp.Regexp
-	denyList          *regexp.Regexp
+	allowList         *regexp2.Regexp
+	denyList          *regexp2.Regexp
 	clearCache        bool
 	clearCookies      bool
 	disableJavaScript bool
@@ -90,6 +90,8 @@ func (b *chromiumBrowser) Start(logger *zap.Logger) error {
 		// https://github.com/puppeteer/puppeteer/issues/2410
 		chromedp.Flag("font-render-hinting", "none"),
 		chromedp.UserDataDir(b.userProfileDirPath),
+		// See https://github.com/gotenberg/gotenberg/issues/831.
+		chromedp.Flag("disable-pdf-tagging", true),
 	)
 
 	if b.arguments.incognito {
@@ -164,7 +166,7 @@ func (b *chromiumBrowser) Stop(logger *zap.Logger) error {
 		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.
+			//  of time before deleting it.
 			<-time.After(10 * time.Second)
 
 			err := os.RemoveAll(userProfileDirPath)
@@ -224,7 +226,8 @@ func (b *chromiumBrowser) pdf(ctx context.Context, logger *zap.Logger, url, outp
 		clearCacheActionFunc(logger, b.arguments.clearCache),
 		clearCookiesActionFunc(logger, b.arguments.clearCookies),
 		disableJavaScriptActionFunc(logger, b.arguments.disableJavaScript),
-		extraHttpHeadersActionFunc(logger, options.ExtraHttpHeaders),
+		setCookiesActionFunc(logger, options.Cookies),
+		userAgentOverride(logger, options.UserAgent),
 		navigateActionFunc(logger, url, options.SkipNetworkIdleEvent),
 		hideDefaultWhiteBackgroundActionFunc(logger, options.OmitBackground, options.PrintBackground),
 		forceExactColorsActionFunc(),
@@ -246,7 +249,8 @@ func (b *chromiumBrowser) screenshot(ctx context.Context, logger *zap.Logger, ur
 		clearCacheActionFunc(logger, b.arguments.clearCache),
 		clearCookiesActionFunc(logger, b.arguments.clearCookies),
 		disableJavaScriptActionFunc(logger, b.arguments.disableJavaScript),
-		extraHttpHeadersActionFunc(logger, options.ExtraHttpHeaders),
+		setCookiesActionFunc(logger, options.Cookies),
+		userAgentOverride(logger, options.UserAgent),
 		navigateActionFunc(logger, url, options.SkipNetworkIdleEvent),
 		hideDefaultWhiteBackgroundActionFunc(logger, options.OmitBackground, true),
 		forceExactColorsActionFunc(),
@@ -254,6 +258,7 @@ func (b *chromiumBrowser) screenshot(ctx context.Context, logger *zap.Logger, ur
 		waitDelayBeforePrintActionFunc(logger, b.arguments.disableJavaScript, options.WaitDelay),
 		waitForExpressionBeforePrintActionFunc(logger, b.arguments.disableJavaScript, options.WaitForExpression),
 		// Screenshot specific.
+		setDeviceMetricsOverride(logger, options.Width, options.Height),
 		captureScreenshotActionFunc(logger, outputPath, options),
 	})
 }
@@ -263,20 +268,17 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 		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")
 	}
 
+	// We validate the "main" URL against our allow / deny lists.
+	err := gotenberg.FilterDeadline(b.arguments.allowList, b.arguments.denyList, url, deadline)
+	if err != nil {
+		return fmt.Errorf("filter URL: %w", err)
+	}
+
 	b.ctxMu.RLock()
 	defer b.ctxMu.RUnlock()
 
@@ -287,17 +289,35 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 	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)
+	// If a request does not pass the validation, we make it fail. It also set
+	// the extra HTTP headers, if any.
+	// See https://github.com/gotenberg/gotenberg/issues/1011.
+	listenForEventRequestPaused(taskCtx, logger, eventRequestPausedOptions{
+		allowList:        b.arguments.allowList,
+		denyList:         b.arguments.denyList,
+		extraHttpHeaders: options.ExtraHttpHeaders,
+	})
 
 	var (
-		invalidHttpStatusCode   error
-		invalidHttpStatusCodeMu sync.RWMutex
+		invalidHttpStatusCode           error
+		invalidHttpStatusCodeMu         sync.RWMutex
+		invalidResourceHttpStatusCode   error
+		invalidResourceHttpStatusCodeMu sync.RWMutex
 	)
 
-	// See https://github.com/gotenberg/gotenberg/issues/613.
-	if len(options.FailOnHttpStatusCodes) != 0 {
-		listenForEventResponseReceived(taskCtx, logger, url, options.FailOnHttpStatusCodes, &invalidHttpStatusCode, &invalidHttpStatusCodeMu)
+	// See:
+	// https://github.com/gotenberg/gotenberg/issues/613.
+	// https://github.com/gotenberg/gotenberg/issues/1021.
+	if len(options.FailOnHttpStatusCodes) != 0 || len(options.FailOnResourceHttpStatusCodes) != 0 {
+		listenForEventResponseReceived(taskCtx, logger, eventResponseReceivedOptions{
+			mainPageUrl:                     url,
+			failOnHttpStatusCodes:           options.FailOnHttpStatusCodes,
+			invalidHttpStatusCode:           &invalidHttpStatusCode,
+			invalidHttpStatusCodeMu:         &invalidHttpStatusCodeMu,
+			failOnResourceOnHttpStatusCode:  options.FailOnResourceHttpStatusCodes,
+			invalidResourceHttpStatusCode:   &invalidResourceHttpStatusCode,
+			invalidResourceHttpStatusCodeMu: &invalidResourceHttpStatusCodeMu,
+		})
 	}
 
 	var (
@@ -310,7 +330,25 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 		listenForEventExceptionThrown(taskCtx, logger, &consoleExceptions, &consoleExceptionsMu)
 	}
 
-	err := chromedp.Run(taskCtx, tasks...)
+	var (
+		loadingFailed           error
+		loadingFailedMu         sync.RWMutex
+		resourceLoadingFailed   error
+		resourceLoadingFailedMu sync.RWMutex
+	)
+
+	// See:
+	// https://github.com/gotenberg/gotenberg/issues/913.
+	// https://github.com/gotenberg/gotenberg/issues/959.
+	// https://github.com/gotenberg/gotenberg/issues/1021.
+	listenForEventLoadingFailed(taskCtx, logger, eventLoadingFailedOptions{
+		loadingFailed:           &loadingFailed,
+		loadingFailedMu:         &loadingFailedMu,
+		resourceLoadingFailed:   &resourceLoadingFailed,
+		resourceLoadingFailedMu: &resourceLoadingFailedMu,
+	})
+
+	err = chromedp.Run(taskCtx, tasks...)
 	if err != nil {
 		errMessage := err.Error()
 
@@ -337,6 +375,14 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 		return fmt.Errorf("%v: %w", invalidHttpStatusCode, ErrInvalidHttpStatusCode)
 	}
 
+	// See https://github.com/gotenberg/gotenberg/issues/1021.
+	invalidResourceHttpStatusCodeMu.RLock()
+	defer invalidResourceHttpStatusCodeMu.RUnlock()
+
+	if invalidResourceHttpStatusCode != nil {
+		return fmt.Errorf("%v: %w", invalidResourceHttpStatusCode, ErrInvalidResourceHttpStatusCode)
+	}
+
 	// See https://github.com/gotenberg/gotenberg/issues/262.
 	consoleExceptionsMu.RLock()
 	defer consoleExceptionsMu.RUnlock()
@@ -345,6 +391,23 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 		return fmt.Errorf("%v: %w", consoleExceptions, ErrConsoleExceptions)
 	}
 
+	// See:
+	// https://github.com/gotenberg/gotenberg/issues/913.
+	// https://github.com/gotenberg/gotenberg/issues/959.
+	loadingFailedMu.RLock()
+	defer loadingFailedMu.RUnlock()
+
+	if loadingFailed != nil {
+		return fmt.Errorf("%v: %w", loadingFailed, ErrLoadingFailed)
+	}
+
+	// See https://github.com/gotenberg/gotenberg/issues/1021.
+	if options.FailOnResourceLoadingFailed {
+		if resourceLoadingFailed != nil {
+			return fmt.Errorf("%v: %w", resourceLoadingFailed, ErrResourceLoadingFailed)
+		}
+	}
+
 	return nil
 }
 

pkg/modules/chromium/chromium.go

@@ -8,6 +8,8 @@ import (
 	"time"
 
 	"github.com/alexliesenfeld/health"
+	"github.com/chromedp/cdproto/network"
+	"github.com/dlclark/regexp2"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/zap"
 
@@ -20,10 +22,6 @@ func init() {
 }
 
 var (
-	// ErrUrlNotAuthorized happens if a URL is not acceptable according to the
-	// allowed/denied lists.
-	ErrUrlNotAuthorized = errors.New("URL not authorized")
-
 	// ErrInvalidEmulatedMediaType happens if the emulated media type is not
 	// "screen" nor "print". Empty value are allowed though.
 	ErrInvalidEmulatedMediaType = errors.New("invalid emulated media type")
@@ -40,11 +38,22 @@ var (
 	// matches with one of the entry in [Options.FailOnHttpStatusCodes].
 	ErrInvalidHttpStatusCode = errors.New("invalid HTTP status code")
 
+	// ErrInvalidResourceHttpStatusCode happens when the status code from one
+	// or more resources matches with one of the entry in
+	// [Options.FailOnResourceHttpStatusCodes].
+	ErrInvalidResourceHttpStatusCode = errors.New("invalid resource 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")
 
+	// ErrLoadingFailed happens when the main page failed to load.
+	ErrLoadingFailed = errors.New("loading failed")
+
+	// ErrResourceLoadingFailed happens when one or more resources failed to load.
+	ErrResourceLoadingFailed = errors.New("resource loading failed")
+
 	// PDF specific.
 
 	// ErrOmitBackgroundWithoutPrintBackground happens if
@@ -79,62 +88,71 @@ type Options struct {
 	// "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
 
+	// FailOnResourceHttpStatusCodes sets if the conversion should fail if the
+	// status code from at least one resource matches with one if its entries.
+	FailOnResourceHttpStatusCodes []int64
+
+	// FailOnResourceLoadingFailed sets if the conversion should fail like the
+	// main page if Chromium fails to load at least one resource.
+	FailOnResourceLoadingFailed bool
+
 	// 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.
-	// Optional.
 	WaitDelay time.Duration
 
 	// WaitWindowStatus is the window.status value to wait for before
 	// converting an HTML document.
-	// Optional.
 	WaitWindowStatus string
 
 	// 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
+	// Cookies are the cookies to put in the Chromium cookies' jar.
+	Cookies []Cookie
+
+	// UserAgent overrides the default 'User-Agent' HTTP header.
+	UserAgent string
+
+	// ExtraHttpHeaders are extra HTTP headers to send by Chromium while
+	// loading he HTML document.
+	ExtraHttpHeaders []ExtraHttpHeader
 
 	// 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,
+		SkipNetworkIdleEvent:          true,
+		FailOnHttpStatusCodes:         []int64{499, 599},
+		FailOnResourceHttpStatusCodes: nil,
+		FailOnResourceLoadingFailed:   false,
+		FailOnConsoleExceptions:       false,
+		WaitDelay:                     0,
+		WaitWindowStatus:              "",
+		WaitForExpression:             "",
+		Cookies:                       nil,
+		UserAgent:                     "",
+		ExtraHttpHeaders:              nil,
+		EmulatedMediaType:             "",
+		OmitBackground:                false,
 	}
 }
 
@@ -143,43 +161,37 @@ type PdfOptions struct {
 	Options
 
 	// Landscape sets the paper orientation.
-	// Optional.
 	Landscape bool
 
 	// PrintBackground prints the background graphics.
-	// Optional.
 	PrintBackground bool
 
 	// Scale is the scale of the page rendering.
-	// Optional.
 	Scale float64
 
+	// SinglePage defines whether to print the entire content in one single
+	// page.
+	SinglePage bool
+
 	// PaperWidth is the paper width, in inches.
-	// Optional.
 	PaperWidth float64
 
 	// PaperHeight is the paper height, in inches.
-	// Optional.
 	PaperHeight float64
 
 	// MarginTop is the top margin, in inches.
-	// Optional.
 	MarginTop float64
 
 	// MarginBottom is the bottom margin, in inches.
-	// Optional.
 	MarginBottom float64
 
 	// MarginLeft is the left margin, in inches.
-	// Optional.
 	MarginLeft float64
 
 	// MarginRight is the right margin, in inches.
-	// Optional.
 	MarginRight float64
 
 	// Page ranges to print, e.g., '1-5, 8, 11-13'. Empty means all pages.
-	// Optional.
 	PageRanges string
 
 	// HeaderTemplate is the HTML template of the header. It should be valid
@@ -192,17 +204,14 @@ type PdfOptions struct {
 	// - totalPages: total pages in the document
 	// For example, <span class=title></span> would generate span containing
 	// the title.
-	// Optional.
 	HeaderTemplate string
 
 	// FooterTemplate is the HTML template of the footer. It should use the
 	// same format as the HeaderTemplate.
-	// Optional.
 	FooterTemplate string
 
 	// 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
 }
 
@@ -213,6 +222,7 @@ func DefaultPdfOptions() PdfOptions {
 		Landscape:         false,
 		PrintBackground:   false,
 		Scale:             1.0,
+		SinglePage:        false,
 		PaperWidth:        8.5,
 		PaperHeight:       11,
 		MarginTop:         0.39,
@@ -231,18 +241,25 @@ func DefaultPdfOptions() PdfOptions {
 type ScreenshotOptions struct {
 	Options
 
+	// Width is the device screen width in pixels.
+	Width int
+
+	// Height is the device screen height in pixels.
+	Height int
+
+	// Clip defines whether to clip the screenshot according to the device
+	// dimensions.
+	Clip bool
+
 	// 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
 }
 
@@ -250,12 +267,63 @@ type ScreenshotOptions struct {
 func DefaultScreenshotOptions() ScreenshotOptions {
 	return ScreenshotOptions{
 		Options:          DefaultOptions(),
+		Width:            800,
+		Height:           600,
+		Clip:             false,
 		Format:           "png",
 		Quality:          100,
 		OptimizeForSpeed: false,
 	}
 }
 
+// Cookie gathers the available entries for setting a cookie in the Chromium
+// cookies' jar.
+type Cookie struct {
+	// Name is the cookie name.
+	// Required.
+	Name string `json:"name"`
+
+	// Value is the cookie value.
+	// Required.
+	Value string `json:"value"`
+
+	// Domain is the cookie domain.
+	// Required.
+	Domain string `json:"domain"`
+
+	// Path is the cookie path.
+	// Optional.
+	Path string `json:"path,omitempty"`
+
+	// Secure sets the cookie secure if true.
+	// Optional.
+	Secure bool `json:"secure,omitempty"`
+
+	// HttpOnly sets the cookie as HTTP-only if true.
+	// Optional.
+	HttpOnly bool `json:"httpOnly,omitempty"`
+
+	// SameSite is cookie 'Same-Site' status.
+	// Optional.
+	SameSite network.CookieSameSite `json:"sameSite,omitempty"`
+}
+
+// ExtraHttpHeader are extra HTTP headers to send by Chromium.
+type ExtraHttpHeader struct {
+	// Name is the header name.
+	// Required.
+	Name string
+
+	// Value is the header value.
+	// Required.
+	Value string
+
+	// Scope is the header scope. If nil, the header will be applied to ALL
+	// requests from the page.
+	// Optional.
+	Scope *regexp2.Regexp
+}
+
 // 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
@@ -280,6 +348,7 @@ func (mod *Chromium) Descriptor() gotenberg.ModuleDescriptor {
 		FlagSet: func() *flag.FlagSet {
 			fs := flag.NewFlagSet("chromium", flag.ExitOnError)
 			fs.Int64("chromium-restart-after", 0, "Number of conversions after which Chromium will automatically restart. Set to 0 to disable this feature")
+			fs.Int64("chromium-max-queue-size", 0, "Maximum request queue size for Chromium. 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")
@@ -290,7 +359,7 @@ func (mod *Chromium) Descriptor() gotenberg.ModuleDescriptor {
 			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.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")
@@ -344,7 +413,7 @@ func (mod *Chromium) Provision(ctx *gotenberg.Context) error {
 
 	// Process.
 	mod.browser = newChromiumBrowser(mod.args)
-	mod.supervisor = gotenberg.NewProcessSupervisor(mod.logger, mod.browser, flags.MustInt64("chromium-restart-after"))
+	mod.supervisor = gotenberg.NewProcessSupervisor(mod.logger, mod.browser, flags.MustInt64("chromium-restart-after"), flags.MustInt64("chromium-max-queue-size"))
 
 	// PDF Engine.
 	provider, err := ctx.Module(new(gotenberg.PdfEngineProvider))

pkg/modules/chromium/chromium_test.go

@@ -15,6 +15,15 @@ import (
 )
 
 func TestDefaultOptions(t *testing.T) {
+	actual := DefaultOptions()
+	notExpect := Options{}
+
+	if reflect.DeepEqual(actual, notExpect) {
+		t.Errorf("expected %v and got identical %v", actual, notExpect)
+	}
+}
+
+func TestDefaultPdfOptions(t *testing.T) {
 	actual := DefaultPdfOptions()
 	notExpect := PdfOptions{}
 
@@ -23,6 +32,15 @@ func TestDefaultOptions(t *testing.T) {
 	}
 }
 
+func TestDefaultScreenshotOptions(t *testing.T) {
+	actual := DefaultScreenshotOptions()
+	notExpect := ScreenshotOptions{}
+
+	if reflect.DeepEqual(actual, notExpect) {
+		t.Errorf("expected %v and got identical %v", actual, notExpect)
+	}
+}
+
 func TestChromium_Descriptor(t *testing.T) {
 	descriptor := new(Chromium).Descriptor()
 

pkg/modules/chromium/events.go

@@ -3,7 +3,7 @@ package chromium
 import (
 	"context"
 	"fmt"
-	"regexp"
+	"net/http"
 	"slices"
 	"sync"
 
@@ -13,14 +13,30 @@ import (
 	"github.com/chromedp/cdproto/page"
 	"github.com/chromedp/cdproto/runtime"
 	"github.com/chromedp/chromedp"
+	"github.com/dlclark/regexp2"
 	"go.uber.org/multierr"
 	"go.uber.org/zap"
 	"golang.org/x/sync/errgroup"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
+type eventRequestPausedOptions struct {
+	allowList, denyList *regexp2.Regexp
+	extraHttpHeaders    []ExtraHttpHeader
+}
+
 // listenForEventRequestPaused listens for requests to check if they are
-// allowed or not.
-func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowList *regexp.Regexp, denyList *regexp.Regexp) {
+// allowed or not.  It also set the extra HTTP headers, if any.
+// See https://github.com/gotenberg/gotenberg/issues/1011.
+// TODO: https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setBlockedURLs (experimental for now).
+func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, options eventRequestPausedOptions) {
+	if len(options.extraHttpHeaders) == 0 {
+		logger.Debug("no extra HTTP headers")
+	} else {
+		logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", options.extraHttpHeaders))
+	}
+
 	chromedp.ListenTarget(ctx, func(ev interface{}) {
 		switch e := ev.(type) {
 		case *fetch.EventRequestPaused:
@@ -28,47 +44,129 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowL
 				logger.Debug(fmt.Sprintf("event EventRequestPaused fired for '%s'", e.Request.URL))
 				allow := true
 
-				if !allowList.MatchString(e.Request.URL) {
-					logger.Warn(fmt.Sprintf("'%s' does not match the expression from the allowed list", e.Request.URL))
-					allow = false
+				deadline, ok := ctx.Deadline()
+				if !ok {
+					logger.Error("context has no deadline, cannot filter URL")
+					return
 				}
 
-				if denyList.String() != "" && denyList.MatchString(e.Request.URL) {
-					logger.Warn(fmt.Sprintf("'%s' matches the expression from the denied list", e.Request.URL))
+				err := gotenberg.FilterDeadline(options.allowList, options.denyList, e.Request.URL, deadline)
+				if err != nil {
+					logger.Warn(err.Error())
 					allow = false
 				}
 
 				cctx := chromedp.FromContext(ctx)
 				executorCtx := cdp.WithExecutor(ctx, cctx.Target)
 
-				if allow {
-					req := fetch.ContinueRequest(e.RequestID)
-					err := req.Do(executorCtx)
+				if !allow {
+					req := fetch.FailRequest(e.RequestID, network.ErrorReasonAccessDenied)
+					err = req.Do(executorCtx)
 					if err != nil {
-						logger.Error(fmt.Sprintf("continue request: %s", err))
+						logger.Error(fmt.Sprintf("fail request: %s", err))
 					}
-
 					return
 				}
 
-				req := fetch.FailRequest(e.RequestID, network.ErrorReasonAccessDenied)
-				err := req.Do(executorCtx)
+				req := fetch.ContinueRequest(e.RequestID)
+
+				var extraHttpHeadersToSet []ExtraHttpHeader
+				if len(options.extraHttpHeaders) > 0 {
+					// The user want to set extra HTTP headers.
+
+					// First, we have to check if at least one header has to be
+					// set for current request.
+					for _, header := range options.extraHttpHeaders {
+						if header.Scope == nil {
+							// Non-scoped header.
+							logger.Debug(fmt.Sprintf("extra HTTP header '%s' will be set for request URL '%s'", header.Name, e.Request.URL))
+							extraHttpHeadersToSet = append(extraHttpHeadersToSet, header)
+							continue
+						}
+
+						ok, err := header.Scope.MatchString(e.Request.URL)
+						if err != nil {
+							logger.Error(fmt.Sprintf("fail to match extra HTTP header '%s' scope with URL '%s': %s", header.Name, e.Request.URL, err))
+						} else if ok {
+							logger.Debug(fmt.Sprintf("extra HTTP header '%s' (scoped) will be set for request URL '%s'", header.Name, e.Request.URL))
+							extraHttpHeadersToSet = append(extraHttpHeadersToSet, header)
+						} else {
+							logger.Debug(fmt.Sprintf("scoped extra HTTP header '%s' (scoped) will not be set for request URL '%s'", header.Name, e.Request.URL))
+						}
+					}
+				}
+
+				if len(extraHttpHeadersToSet) > 0 {
+					logger.Debug(fmt.Sprintf("setting extra HTTP headers for request URL '%s': %+v", e.Request.URL, extraHttpHeadersToSet))
+
+					originalHeaders := e.Request.Headers
+					headers := make(map[string]string)
+
+					for key, value := range originalHeaders {
+						strValue, ok := value.(string)
+						if ok {
+							headers[key] = strValue
+						} else {
+							logger.Error(fmt.Sprintf("ignoring header '%s' for URL '%s' since it cannot be cast to a string", key, e.Request.URL))
+						}
+					}
+
+					var headersEntries []*fetch.HeaderEntry
+					for key, value := range headers {
+						headersEntries = append(headersEntries, &fetch.HeaderEntry{
+							Name:  key,
+							Value: value,
+						})
+					}
+					for _, header := range extraHttpHeadersToSet {
+						headersEntries = append(headersEntries, &fetch.HeaderEntry{
+							Name:  header.Name,
+							Value: header.Value,
+						})
+					}
+
+					req.Headers = headersEntries
+				}
+
+				err = req.Do(executorCtx)
 				if err != nil {
-					logger.Error(fmt.Sprintf("fail request: %s", err))
+					logger.Error(fmt.Sprintf("continue request: %s", err))
 				}
 			}()
 		}
 	})
 }
 
-// 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) {
+type eventResponseReceivedOptions struct {
+	mainPageUrl                     string
+	failOnHttpStatusCodes           []int64
+	invalidHttpStatusCode           *error
+	invalidHttpStatusCodeMu         *sync.RWMutex
+	failOnResourceOnHttpStatusCode  []int64
+	invalidResourceHttpStatusCode   *error
+	invalidResourceHttpStatusCodeMu *sync.RWMutex
+}
+
+// listenForEventResponseReceived listens for an invalid HTTP status code that
+// is returned by the main page or by one or more resources.
+// See:
+// https://github.com/gotenberg/gotenberg/issues/613.
+// https://github.com/gotenberg/gotenberg/issues/1021.
+func listenForEventResponseReceived(
+	ctx context.Context,
+	logger *zap.Logger,
+	options eventResponseReceivedOptions,
+) {
 	for _, code := range []int64{199, 299, 399, 499, 599} {
-		if slices.Contains(failOnHttpStatusCodes, code) {
+		if slices.Contains(options.failOnHttpStatusCodes, code) {
 			for i := code - 99; i <= code; i++ {
-				failOnHttpStatusCodes = append(failOnHttpStatusCodes, i)
+				options.failOnHttpStatusCodes = append(options.failOnHttpStatusCodes, i)
+			}
+		}
+
+		if slices.Contains(options.failOnResourceOnHttpStatusCode, code) {
+			for i := code - 99; i <= code; i++ {
+				options.failOnResourceOnHttpStatusCode = append(options.failOnResourceOnHttpStatusCode, i)
 			}
 		}
 	}
@@ -76,22 +174,99 @@ func listenForEventResponseReceived(ctx context.Context, logger *zap.Logger, url
 	chromedp.ListenTarget(ctx, func(ev interface{}) {
 		switch ev := ev.(type) {
 		case *network.EventResponseReceived:
-			if ev.Response.URL != url {
+			if ev.Response.URL == options.mainPageUrl {
+				logger.Debug(fmt.Sprintf("event EventResponseReceived fired for main page: %+v", ev.Response))
+
+				if slices.Contains(options.failOnHttpStatusCodes, ev.Response.Status) {
+					options.invalidHttpStatusCodeMu.Lock()
+					defer options.invalidHttpStatusCodeMu.Unlock()
+
+					*options.invalidHttpStatusCode = fmt.Errorf("%d: %s", ev.Response.Status, ev.Response.StatusText)
+				}
+
 				return
 			}
 
-			logger.Debug(fmt.Sprintf("event EventResponseReceived fired for main page: %+v", ev.Response))
+			logger.Debug(fmt.Sprintf("event EventResponseReceived fired for a resource: %+v", ev.Response))
 
-			if slices.Contains(failOnHttpStatusCodes, ev.Response.Status) {
-				invalidHttpStatusCodeMu.Lock()
-				defer invalidHttpStatusCodeMu.Unlock()
+			if slices.Contains(options.failOnResourceOnHttpStatusCode, ev.Response.Status) {
+				options.invalidResourceHttpStatusCodeMu.Lock()
+				defer options.invalidResourceHttpStatusCodeMu.Unlock()
 
-				*invalidHttpStatusCode = fmt.Errorf("%d: %s", ev.Response.Status, ev.Response.StatusText)
+				*options.invalidResourceHttpStatusCode = multierr.Append(
+					*options.invalidResourceHttpStatusCode,
+					fmt.Errorf("%s - %d: %s", ev.Response.URL, ev.Response.Status, http.StatusText(int(ev.Response.Status))),
+				)
 			}
 		}
 	})
 }
 
+type eventLoadingFailedOptions struct {
+	loadingFailed           *error
+	loadingFailedMu         *sync.RWMutex
+	resourceLoadingFailed   *error
+	resourceLoadingFailedMu *sync.RWMutex
+}
+
+// listenForEventLoadingFailed listens for an event indicating that the main
+// page or one or more resources failed to load.
+// See:
+// https://github.com/gotenberg/gotenberg/issues/913.
+// https://github.com/gotenberg/gotenberg/issues/959.
+// https://github.com/gotenberg/gotenberg/issues/1021.
+func listenForEventLoadingFailed(ctx context.Context, logger *zap.Logger, options eventLoadingFailedOptions) {
+	chromedp.ListenTarget(ctx, func(ev interface{}) {
+		switch ev := ev.(type) {
+		case *network.EventLoadingFailed:
+			logger.Debug(fmt.Sprintf("event EventLoadingFailed fired: %+v", ev.ErrorText))
+
+			// We are looking for common errors.
+			// TODO: sufficient?
+			errors := []string{
+				"net::ERR_CONNECTION_CLOSED",
+				"net::ERR_CONNECTION_RESET",
+				"net::ERR_CONNECTION_REFUSED",
+				"net::ERR_CONNECTION_ABORTED",
+				"net::ERR_CONNECTION_FAILED",
+				"net::ERR_NAME_NOT_RESOLVED",
+				"net::ERR_INTERNET_DISCONNECTED",
+				"net::ERR_ADDRESS_UNREACHABLE",
+				"net::ERR_BLOCKED_BY_CLIENT",
+				"net::ERR_BLOCKED_BY_RESPONSE",
+				"net::ERR_FILE_NOT_FOUND",
+			}
+			if !slices.Contains(errors, ev.ErrorText) {
+				logger.Debug(fmt.Sprintf("skip EventLoadingFailed: '%s' is not part of %+v", ev.ErrorText, errors))
+				return
+			}
+
+			if ev.Type == network.ResourceTypeDocument {
+				// Supposition: except iframe, an event loading failed with a
+				// resource type Document is about the main page.
+				logger.Debug("event EventLoadingFailed fired for main page")
+
+				options.loadingFailedMu.Lock()
+				defer options.loadingFailedMu.Unlock()
+
+				*options.loadingFailed = fmt.Errorf("%s", ev.ErrorText)
+
+				return
+			}
+
+			logger.Debug("event EventLoadingFailed fired for a resource")
+
+			options.resourceLoadingFailedMu.Lock()
+			defer options.resourceLoadingFailedMu.Unlock()
+
+			*options.resourceLoadingFailed = multierr.Append(
+				*options.resourceLoadingFailed,
+				fmt.Errorf("resource %s: %s", ev.Type, ev.ErrorText),
+			)
+		}
+	})
+}
+
 // listenForEventExceptionThrown listens for exceptions in the console and
 // appends those exceptions to the given error pointer.
 // See https://github.com/gotenberg/gotenberg/issues/262.

pkg/modules/chromium/routes.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/dlclark/regexp2"
 	"github.com/labstack/echo/v4"
 	"github.com/microcosm-cc/bluemonday"
 	"github.com/russross/blackfriday/v2"
@@ -28,15 +29,19 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 	defaultOptions := DefaultOptions()
 
 	var (
-		skipNetworkIdleEvent    bool
-		failOnHttpStatusCodes   []int64
-		failOnConsoleExceptions bool
-		waitDelay               time.Duration
-		waitWindowStatus        string
-		waitForExpression       string
-		extraHttpHeaders        map[string]string
-		emulatedMediaType       string
-		omitBackground          bool
+		skipNetworkIdleEvent          bool
+		failOnHttpStatusCodes         []int64
+		failOnResourceHttpStatusCodes []int64
+		failOnResourceLoadingFailed   bool
+		failOnConsoleExceptions       bool
+		waitDelay                     time.Duration
+		waitWindowStatus              string
+		waitForExpression             string
+		cookies                       []Cookie
+		userAgent                     string
+		extraHttpHeaders              []ExtraHttpHeader
+		emulatedMediaType             string
+		omitBackground                bool
 	)
 
 	form := ctx.FormData().
@@ -54,22 +59,103 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 
 			return nil
 		}).
+		Custom("failOnResourceHttpStatusCodes", func(value string) error {
+			if value == "" {
+				failOnResourceHttpStatusCodes = defaultOptions.FailOnResourceHttpStatusCodes
+				return nil
+			}
+
+			err := json.Unmarshal([]byte(value), &failOnResourceHttpStatusCodes)
+			if err != nil {
+				return fmt.Errorf("unmarshal failOnResourceHttpStatusCodes: %w", err)
+			}
+
+			return nil
+		}).
+		Bool("failOnResourceLoadingFailed", &failOnResourceLoadingFailed, defaultOptions.FailOnResourceLoadingFailed).
 		Bool("failOnConsoleExceptions", &failOnConsoleExceptions, defaultOptions.FailOnConsoleExceptions).
 		Duration("waitDelay", &waitDelay, defaultOptions.WaitDelay).
 		String("waitWindowStatus", &waitWindowStatus, defaultOptions.WaitWindowStatus).
 		String("waitForExpression", &waitForExpression, defaultOptions.WaitForExpression).
+		Custom("cookies", func(value string) error {
+			if value == "" {
+				cookies = defaultOptions.Cookies
+				return nil
+			}
+
+			err := json.Unmarshal([]byte(value), &cookies)
+			if err != nil {
+				return fmt.Errorf("unmarshal cookies: %w", err)
+			}
+
+			for i, cookie := range cookies {
+				if strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" || strings.TrimSpace(cookie.Domain) == "" {
+					err = multierr.Append(err, fmt.Errorf("cookie %d must have its name, value and domain set", i))
+				}
+			}
+
+			return err
+		}).
+		String("userAgent", &userAgent, defaultOptions.UserAgent).
 		Custom("extraHttpHeaders", func(value string) error {
 			if value == "" {
 				extraHttpHeaders = defaultOptions.ExtraHttpHeaders
 				return nil
 			}
 
-			err := json.Unmarshal([]byte(value), &extraHttpHeaders)
+			var headers map[string]string
+			err := json.Unmarshal([]byte(value), &headers)
 			if err != nil {
 				return fmt.Errorf("unmarshal extraHttpHeaders: %w", err)
 			}
 
-			return nil
+			for k, v := range headers {
+				var scope string
+				var valueTokens []string
+				var invalidScopeToken bool
+
+				tokens := strings.Split(v, ";")
+				for _, token := range tokens {
+					if strings.HasPrefix(strings.ToLower(strings.TrimSpace(token)), "scope") {
+						tokenNoSpaces := strings.Join(strings.Fields(token), "")
+						parts := strings.SplitN(tokenNoSpaces, "=", 2)
+
+						if len(parts) == 2 && strings.ToLower(parts[0]) == "scope" && parts[1] != "" {
+							scope = parts[1]
+						} else {
+							err = multierr.Append(err, fmt.Errorf("invalid scope '%s' for header '%s'", scope, k))
+							invalidScopeToken = true
+							break
+						}
+					} else {
+						if token != "" {
+							valueTokens = append(valueTokens, token)
+						}
+					}
+				}
+
+				if invalidScopeToken {
+					continue
+				}
+
+				var scopeRegexp *regexp2.Regexp
+				if len(scope) > 0 {
+					p, errCompile := regexp2.Compile(scope, 0)
+					if errCompile != nil {
+						err = multierr.Append(err, fmt.Errorf("invalid scope regex pattern for header '%s': %w", k, errCompile))
+						continue
+					}
+					scopeRegexp = p
+				}
+
+				extraHttpHeaders = append(extraHttpHeaders, ExtraHttpHeader{
+					Name:  k,
+					Value: strings.Join(valueTokens, "; "),
+					Scope: scopeRegexp,
+				})
+			}
+
+			return err
 		}).
 		Custom("emulatedMediaType", func(value string) error {
 			if value == "" {
@@ -78,7 +164,7 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 			}
 
 			if value != "screen" && value != "print" {
-				return fmt.Errorf("wrong value, expected either 'screen', 'print' or empty")
+				return errors.New("wrong value, expected either 'screen', 'print' or empty")
 			}
 
 			emulatedMediaType = value
@@ -88,15 +174,19 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 		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,
+		SkipNetworkIdleEvent:          skipNetworkIdleEvent,
+		FailOnHttpStatusCodes:         failOnHttpStatusCodes,
+		FailOnResourceHttpStatusCodes: failOnResourceHttpStatusCodes,
+		FailOnResourceLoadingFailed:   failOnResourceLoadingFailed,
+		FailOnConsoleExceptions:       failOnConsoleExceptions,
+		WaitDelay:                     waitDelay,
+		WaitWindowStatus:              waitWindowStatus,
+		WaitForExpression:             waitForExpression,
+		Cookies:                       cookies,
+		UserAgent:                     userAgent,
+		ExtraHttpHeaders:              extraHttpHeaders,
+		EmulatedMediaType:             emulatedMediaType,
+		OmitBackground:                omitBackground,
 	}
 
 	return form, options
@@ -109,7 +199,7 @@ func FormDataChromiumPdfOptions(ctx *api.Context) (*api.FormData, PdfOptions) {
 	defaultPdfOptions := DefaultPdfOptions()
 
 	var (
-		landscape, printBackground                       bool
+		landscape, printBackground, singlePage           bool
 		scale, paperWidth, paperHeight                   float64
 		marginTop, marginBottom, marginLeft, marginRight float64
 		pageRanges                                       string
@@ -121,12 +211,13 @@ func FormDataChromiumPdfOptions(ctx *api.Context) (*api.FormData, PdfOptions) {
 		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).
+		Bool("singlePage", &singlePage, defaultPdfOptions.SinglePage).
+		Inches("paperWidth", &paperWidth, defaultPdfOptions.PaperWidth).
+		Inches("paperHeight", &paperHeight, defaultPdfOptions.PaperHeight).
+		Inches("marginTop", &marginTop, defaultPdfOptions.MarginTop).
+		Inches("marginBottom", &marginBottom, defaultPdfOptions.MarginBottom).
+		Inches("marginLeft", &marginLeft, defaultPdfOptions.MarginLeft).
+		Inches("marginRight", &marginRight, defaultPdfOptions.MarginRight).
 		String("nativePageRanges", &pageRanges, defaultPdfOptions.PageRanges).
 		Content("header.html", &headerTemplate, defaultPdfOptions.HeaderTemplate).
 		Content("footer.html", &footerTemplate, defaultPdfOptions.FooterTemplate).
@@ -137,6 +228,7 @@ func FormDataChromiumPdfOptions(ctx *api.Context) (*api.FormData, PdfOptions) {
 		Landscape:         landscape,
 		PrintBackground:   printBackground,
 		Scale:             scale,
+		SinglePage:        singlePage,
 		PaperWidth:        paperWidth,
 		PaperHeight:       paperHeight,
 		MarginTop:         marginTop,
@@ -159,12 +251,17 @@ func FormDataChromiumScreenshotOptions(ctx *api.Context) (*api.FormData, Screens
 	defaultScreenshotOptions := DefaultScreenshotOptions()
 
 	var (
+		width, height    int
+		clip             bool
 		format           string
 		quality          int
 		optimizeForSpeed bool
 	)
 
 	form.
+		Int("width", &width, defaultScreenshotOptions.Width).
+		Int("height", &height, defaultScreenshotOptions.Height).
+		Bool("clip", &clip, defaultScreenshotOptions.Clip).
 		Custom("format", func(value string) error {
 			if value == "" {
 				format = defaultScreenshotOptions.Format
@@ -205,6 +302,9 @@ func FormDataChromiumScreenshotOptions(ctx *api.Context) (*api.FormData, Screens
 
 	screenshotOptions := ScreenshotOptions{
 		Options:          options,
+		Width:            width,
+		Height:           height,
+		Clip:             clip,
 		Format:           format,
 		Quality:          quality,
 		OptimizeForSpeed: optimizeForSpeed,
@@ -231,6 +331,21 @@ func FormDataChromiumPdfFormats(form *api.FormData) gotenberg.PdfFormats {
 	}
 }
 
+// FormDataPdfMetadata creates metadata object from the form data.
+func FormDataPdfMetadata(form *api.FormData) map[string]interface{} {
+	var metadata map[string]interface{}
+	form.Custom("metadata", func(value string) error {
+		if len(value) > 0 {
+			err := json.Unmarshal([]byte(value), &metadata)
+			if err != nil {
+				return fmt.Errorf("unmarshal metadata: %w", err)
+			}
+		}
+		return nil
+	})
+	return metadata
+}
+
 // convertUrlRoute returns an [api.Route] which can convert a URL to PDF.
 func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 	return api.Route{
@@ -241,6 +356,7 @@ func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPdfOptions(ctx)
 			pdfFormats := FormDataChromiumPdfFormats(form)
+			metadata := FormDataPdfMetadata(form)
 
 			var url string
 			err := form.
@@ -250,7 +366,7 @@ func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("validate form data: %w", err)
 			}
 
-			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options)
+			err = convertUrl(ctx, chromium, engine, url, options, pdfFormats, metadata)
 			if err != nil {
 				return fmt.Errorf("convert URL to PDF: %w", err)
 			}
@@ -300,6 +416,7 @@ func convertHtmlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPdfOptions(ctx)
 			pdfFormats := FormDataChromiumPdfFormats(form)
+			metadata := FormDataPdfMetadata(form)
 
 			var inputPath string
 			err := form.
@@ -310,7 +427,7 @@ func convertHtmlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			}
 
 			url := fmt.Sprintf("file://%s", inputPath)
-			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options)
+			err = convertUrl(ctx, chromium, engine, url, options, pdfFormats, metadata)
 			if err != nil {
 				return fmt.Errorf("convert HTML to PDF: %w", err)
 			}
@@ -361,6 +478,7 @@ func convertMarkdownRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPdfOptions(ctx)
 			pdfFormats := FormDataChromiumPdfFormats(form)
+			metadata := FormDataPdfMetadata(form)
 
 			var (
 				inputPath     string
@@ -380,7 +498,7 @@ func convertMarkdownRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("transform markdown file(s) to HTML: %w", err)
 			}
 
-			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options)
+			err = convertUrl(ctx, chromium, engine, url, options, pdfFormats, metadata)
 			if err != nil {
 				return fmt.Errorf("convert markdown to PDF: %w", err)
 			}
@@ -504,15 +622,15 @@ func markdownToHtml(ctx *api.Context, inputPath string, markdownPaths []string)
 	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 {
+func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url string, options PdfOptions, pdfFormats gotenberg.PdfFormats, metadata map[string]interface{}) error {
 	outputPath := ctx.GeneratePath(".pdf")
 
 	err := chromium.Pdf(ctx, ctx.Log(), url, outputPath, options)
-	err = handleChromiumError(err, url, options.Options)
+	err = handleChromiumError(err, options.Options)
 	if err != nil {
 		if errors.Is(err, ErrOmitBackgroundWithoutPrintBackground) {
 			return api.WrapError(
-				err,
+				fmt.Errorf("convert to PDF: %w", err),
 				api.NewSentinelHttpError(
 					http.StatusBadRequest,
 					"omitBackground requires printBackground set to true",
@@ -552,18 +670,7 @@ func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url
 		convertOutputPath := ctx.GeneratePath(".pdf")
 
 		err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)
-
 		if err != nil {
-			if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
-				return api.WrapError(
-					fmt.Errorf("convert PDF: %w", err),
-					api.NewSentinelHttpError(
-						http.StatusBadRequest,
-						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),
-					),
-				)
-			}
-
 			return fmt.Errorf("convert PDF: %w", err)
 		}
 
@@ -571,6 +678,14 @@ func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url
 		outputPath = convertOutputPath
 	}
 
+	// Writes and potentially overrides metadata entries, if any.
+	if len(metadata) > 0 {
+		err = engine.WriteMetadata(ctx, ctx.Log(), metadata, outputPath)
+		if err != nil {
+			return fmt.Errorf("write metadata: %w", err)
+		}
+	}
+
 	err = ctx.AddOutputPaths(outputPath)
 	if err != nil {
 		return fmt.Errorf("add output path: %w", err)
@@ -584,7 +699,7 @@ func screenshotUrl(ctx *api.Context, chromium Api, url string, options Screensho
 	outputPath := ctx.GeneratePath(ext)
 
 	err := chromium.Screenshot(ctx, ctx.Log(), url, outputPath, options)
-	err = handleChromiumError(err, url, options.Options)
+	err = handleChromiumError(err, options.Options)
 	if err != nil {
 		return fmt.Errorf("screenshot: %w", err)
 	}
@@ -597,21 +712,11 @@ func screenshotUrl(ctx *api.Context, chromium Api, url string, options Screensho
 	return nil
 }
 
-func handleChromiumError(err error, url string, options Options) error {
+func handleChromiumError(err error, 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
@@ -639,12 +744,42 @@ func handleChromiumError(err error, url string, options Options) error {
 		)
 	}
 
+	if errors.Is(err, ErrInvalidResourceHttpStatusCode) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusConflict,
+				fmt.Sprintf("Invalid HTTP status code from resources:\n%s", strings.ReplaceAll(err.Error(), fmt.Sprintf(": %s", ErrInvalidResourceHttpStatusCode.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(), "")),
+				fmt.Sprintf("Chromium console exceptions:\n%s", strings.ReplaceAll(err.Error(), ErrConsoleExceptions.Error(), "")),
+			),
+		)
+	}
+
+	if errors.Is(err, ErrLoadingFailed) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusBadRequest,
+				fmt.Sprintf("Chromium returned %v", err),
+			),
+		)
+	}
+
+	if errors.Is(err, ErrResourceLoadingFailed) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusConflict,
+				fmt.Sprintf("Chromium failed to load resources: %v", strings.ReplaceAll(err.Error(), fmt.Sprintf(": %s", ErrResourceLoadingFailed.Error()), "")),
 			),
 		)
 	}

pkg/modules/chromium/routes_test.go

@@ -7,8 +7,10 @@ import (
 	"net/http"
 	"os"
 	"reflect"
+	"sort"
 	"testing"
 
+	"github.com/dlclark/regexp2"
 	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
@@ -19,14 +21,18 @@ import (
 
 func TestFormDataChromiumOptions(t *testing.T) {
 	for _, tc := range []struct {
-		scenario        string
-		ctx             *api.ContextMock
-		expectedOptions Options
+		scenario                string
+		ctx                     *api.ContextMock
+		expectedOptions         Options
+		compareWithoutDeepEqual bool
+		expectValidationError   bool
 	}{
 		{
-			scenario:        "no custom form fields",
-			ctx:             &api.ContextMock{Context: new(api.Context)},
-			expectedOptions: DefaultOptions(),
+			scenario:                "no custom form fields",
+			ctx:                     &api.ContextMock{Context: new(api.Context)},
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   false,
 		},
 		{
 			scenario: "invalid failOnHttpStatusCodes form field",
@@ -44,6 +50,8 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				options.FailOnHttpStatusCodes = nil
 				return options
 			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
 		},
 		{
 			scenario: "valid failOnHttpStatusCodes form field",
@@ -61,9 +69,108 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				options.FailOnHttpStatusCodes = []int64{399, 499, 599}
 				return options
 			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   false,
 		},
 		{
-			scenario: "invalid extraHttpHeaders form field",
+			scenario: "invalid failOnResourceHttpStatusCodes form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"failOnResourceHttpStatusCodes": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions: func() Options {
+				options := DefaultOptions()
+				options.FailOnResourceHttpStatusCodes = nil
+				return options
+			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
+		},
+		{
+			scenario: "valid failOnResourceHttpStatusCodes form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"failOnResourceHttpStatusCodes": {
+						`[399,499,599]`,
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions: func() Options {
+				options := DefaultOptions()
+				options.FailOnResourceHttpStatusCodes = []int64{399, 499, 599}
+				return options
+			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   false,
+		},
+		{
+			scenario: "invalid cookies form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"cookies": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
+		},
+		{
+			scenario: "invalid cookies form field (missing required values)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"cookies": {
+						"[{}]",
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions: func() Options {
+				options := DefaultOptions()
+				// No validation in this method, so it still instantiates
+				// an empty item.
+				options.Cookies = []Cookie{{}}
+				return options
+			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
+		},
+		{
+			scenario: "valid cookies form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"cookies": {
+						`[{"name":"foo","value":"bar","domain":".foo.bar"}]`,
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions: func() Options {
+				options := DefaultOptions()
+				options.Cookies = []Cookie{{
+					Name:   "foo",
+					Value:  "bar",
+					Domain: ".foo.bar",
+				}}
+				return options
+			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   false,
+		},
+		{
+			scenario: "invalid extraHttpHeaders form field: cannot unmarshall",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetValues(map[string][]string{
@@ -73,7 +180,39 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				})
 				return ctx
 			}(),
-			expectedOptions: DefaultOptions(),
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
+		},
+		{
+			scenario: "invalid extraHttpHeaders form field: invalid scope",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"extraHttpHeaders": {
+						`{"foo":"bar;scope;;"}`,
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
+		},
+		{
+			scenario: "invalid extraHttpHeaders form field: invalid scope regex pattern",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"extraHttpHeaders": {
+						`{"foo":"bar;scope=*."}`,
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
 		},
 		{
 			scenario: "valid extraHttpHeaders form field",
@@ -81,18 +220,28 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetValues(map[string][]string{
 					"extraHttpHeaders": {
-						`{"foo":"bar"}`,
+						`{"foo":"bar","baz":"qux;scope=https?:\\/\\/([a-zA-Z0-9-]+\\.)*qux\\.com\\/.*"}`,
 					},
 				})
 				return ctx
 			}(),
 			expectedOptions: func() Options {
 				options := DefaultOptions()
-				options.ExtraHttpHeaders = map[string]string{
-					"foo": "bar",
+				options.ExtraHttpHeaders = []ExtraHttpHeader{
+					{
+						Name:  "foo",
+						Value: "bar",
+					},
+					{
+						Name:  "baz",
+						Value: "qux",
+						Scope: regexp2.MustCompile(`https?:\/\/([a-zA-Z0-9-]+\.)*qux\.com\/.*`, 0),
+					},
 				}
 				return options
 			}(),
+			compareWithoutDeepEqual: true,
+			expectValidationError:   false,
 		},
 		{
 			scenario: "invalid emulatedMediaType form field",
@@ -105,7 +254,8 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				})
 				return ctx
 			}(),
-			expectedOptions: DefaultOptions(),
+			expectedOptions:       DefaultOptions(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "valid emulatedMediaType form field",
@@ -123,14 +273,61 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				options.EmulatedMediaType = "screen"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			_, actual := FormDataChromiumOptions(tc.ctx.Context)
+			form, actual := FormDataChromiumOptions(tc.ctx.Context)
 
-			if !reflect.DeepEqual(actual, tc.expectedOptions) {
-				t.Fatalf("expected %+v but got: %+v", tc.expectedOptions, actual)
+			if tc.compareWithoutDeepEqual {
+				if len(tc.expectedOptions.ExtraHttpHeaders) != len(actual.ExtraHttpHeaders) {
+					t.Fatalf("expected %d extra HTTP headers, but got %d", len(tc.expectedOptions.ExtraHttpHeaders), len(actual.ExtraHttpHeaders))
+				}
+
+				sort.Slice(tc.expectedOptions.ExtraHttpHeaders, func(i, j int) bool {
+					return tc.expectedOptions.ExtraHttpHeaders[i].Name < tc.expectedOptions.ExtraHttpHeaders[j].Name
+				})
+				sort.Slice(actual.ExtraHttpHeaders, func(i, j int) bool {
+					return actual.ExtraHttpHeaders[i].Name < actual.ExtraHttpHeaders[j].Name
+				})
+
+				for i := range tc.expectedOptions.ExtraHttpHeaders {
+					if tc.expectedOptions.ExtraHttpHeaders[i].Name != actual.ExtraHttpHeaders[i].Name {
+						t.Fatalf("expected '%s' extra HTTP header, but got '%s'", tc.expectedOptions.ExtraHttpHeaders[i].Name, tc.expectedOptions.ExtraHttpHeaders[i].Name)
+					}
+
+					if tc.expectedOptions.ExtraHttpHeaders[i].Value != actual.ExtraHttpHeaders[i].Value {
+						t.Fatalf("expected '%s' as value for extra HTTP header '%s', but got '%s'", tc.expectedOptions.ExtraHttpHeaders[i].Value, tc.expectedOptions.ExtraHttpHeaders[i].Name, actual.ExtraHttpHeaders[i].Value)
+					}
+
+					var expectedScope string
+					if tc.expectedOptions.ExtraHttpHeaders[i].Scope != nil {
+						expectedScope = tc.expectedOptions.ExtraHttpHeaders[i].Scope.String()
+					}
+					var actualScope string
+					if actual.ExtraHttpHeaders[i].Scope != nil {
+						actualScope = actual.ExtraHttpHeaders[i].Scope.String()
+					}
+
+					if expectedScope != actualScope {
+						t.Fatalf("expected '%s' as scope for extra HTTP header '%s', but got '%s'", expectedScope, tc.expectedOptions.ExtraHttpHeaders[i].Name, actualScope)
+					}
+				}
+			} else {
+				if !reflect.DeepEqual(actual, tc.expectedOptions) {
+					t.Fatalf("expected %+v but got: %+v", tc.expectedOptions, actual)
+				}
+			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
 			}
 		})
 	}
@@ -138,14 +335,16 @@ func TestFormDataChromiumOptions(t *testing.T) {
 
 func TestFormDataChromiumPdfOptions(t *testing.T) {
 	for _, tc := range []struct {
-		scenario        string
-		ctx             *api.ContextMock
-		expectedOptions PdfOptions
+		scenario              string
+		ctx                   *api.ContextMock
+		expectedOptions       PdfOptions
+		expectValidationError bool
 	}{
 		{
-			scenario:        "no custom form fields",
-			ctx:             &api.ContextMock{Context: new(api.Context)},
-			expectedOptions: DefaultPdfOptions(),
+			scenario:              "no custom form fields",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			expectedOptions:       DefaultPdfOptions(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "custom form fields (Options & PdfOptions)",
@@ -167,29 +366,42 @@ func TestFormDataChromiumPdfOptions(t *testing.T) {
 				options.EmulatedMediaType = "screen"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			_, actual := FormDataChromiumPdfOptions(tc.ctx.Context)
+			form, actual := FormDataChromiumPdfOptions(tc.ctx.Context)
 
 			if !reflect.DeepEqual(actual, tc.expectedOptions) {
 				t.Fatalf("expected %+v but got: %+v", tc.expectedOptions, actual)
 			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
+			}
 		})
 	}
 }
 
 func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 	for _, tc := range []struct {
-		scenario        string
-		ctx             *api.ContextMock
-		expectedOptions ScreenshotOptions
+		scenario              string
+		ctx                   *api.ContextMock
+		expectedOptions       ScreenshotOptions
+		expectValidationError bool
 	}{
 		{
-			scenario:        "no custom form fields",
-			ctx:             &api.ContextMock{Context: new(api.Context)},
-			expectedOptions: DefaultScreenshotOptions(),
+			scenario:              "no custom form fields",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			expectedOptions:       DefaultScreenshotOptions(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "invalid format form field",
@@ -207,6 +419,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Format = ""
 				return options
 			}(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "valid png format form field",
@@ -224,6 +437,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Format = "png"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "valid jpeg format form field",
@@ -241,6 +455,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Format = "jpeg"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "valid webp format form field",
@@ -258,6 +473,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Format = "webp"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "invalid quality form field (not an integer)",
@@ -275,6 +491,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Quality = 0
 				return options
 			}(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "invalid quality form field (< 0)",
@@ -292,6 +509,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Quality = 0
 				return options
 			}(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "invalid quality form field (> 100)",
@@ -309,6 +527,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Quality = 0
 				return options
 			}(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "valid quality form field",
@@ -326,12 +545,22 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Quality = 50
 				return options
 			}(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "custom form fields (Options & ScreenshotOptions)",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetValues(map[string][]string{
+					"width": {
+						"1280",
+					},
+					"height": {
+						"800",
+					},
+					"clip": {
+						"true",
+					},
 					"optimizeForSpeed": {
 						"true",
 					},
@@ -343,33 +572,49 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 			}(),
 			expectedOptions: func() ScreenshotOptions {
 				options := DefaultScreenshotOptions()
+				options.Width = 1280
+				options.Height = 800
+				options.Clip = true
 				options.OptimizeForSpeed = true
 				options.EmulatedMediaType = "screen"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			_, actual := FormDataChromiumScreenshotOptions(tc.ctx.Context)
+			form, actual := FormDataChromiumScreenshotOptions(tc.ctx.Context)
 
 			if !reflect.DeepEqual(actual, tc.expectedOptions) {
 				t.Fatalf("expected %+v but got: %+v", tc.expectedOptions, actual)
 			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
+			}
 		})
 	}
 }
 
 func TestFormDataChromiumPdfFormats(t *testing.T) {
 	for _, tc := range []struct {
-		scenario           string
-		ctx                *api.ContextMock
-		expectedPdfFormats gotenberg.PdfFormats
+		scenario              string
+		ctx                   *api.ContextMock
+		expectedPdfFormats    gotenberg.PdfFormats
+		expectValidationError bool
 	}{
 		{
-			scenario:           "no custom form fields",
-			ctx:                &api.ContextMock{Context: new(api.Context)},
-			expectedPdfFormats: gotenberg.PdfFormats{},
+			scenario:              "no custom form fields",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			expectedPdfFormats:    gotenberg.PdfFormats{},
+			expectValidationError: false,
 		},
 		{
 			scenario: "pdfa and pdfua form fields",
@@ -385,16 +630,94 @@ func TestFormDataChromiumPdfFormats(t *testing.T) {
 				})
 				return ctx
 			}(),
-			expectedPdfFormats: gotenberg.PdfFormats{PdfA: "foo", PdfUa: true},
+			expectedPdfFormats:    gotenberg.PdfFormats{PdfA: "foo", PdfUa: true},
+			expectValidationError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			actual := FormDataChromiumPdfFormats(tc.ctx.Context.FormData())
+			form := tc.ctx.Context.FormData()
+			actual := FormDataChromiumPdfFormats(form)
 
 			if !reflect.DeepEqual(actual, tc.expectedPdfFormats) {
 				t.Fatalf("expected %+v but got: %+v", tc.expectedPdfFormats, actual)
 			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestFormDataPdfMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario              string
+		ctx                   *api.ContextMock
+		expectedMetadata      map[string]interface{}
+		expectValidationError bool
+	}{
+		{
+			scenario:              "no metadata form field",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			expectedMetadata:      nil,
+			expectValidationError: false,
+		},
+		{
+			scenario: "invalid metadata form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			expectedMetadata:      nil,
+			expectValidationError: true,
+		},
+		{
+			scenario: "valid metadata form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"{\"foo\":\"bar\"}",
+					},
+				})
+				return ctx
+			}(),
+			expectedMetadata: map[string]interface{}{
+				"foo": "bar",
+			},
+			expectValidationError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.SetLogger(zap.NewNop())
+			form := tc.ctx.Context.FormData()
+			actual := FormDataPdfMetadata(form)
+
+			if !reflect.DeepEqual(actual, tc.expectedMetadata) {
+				t.Fatalf("expected %+v but got: %+v", tc.expectedMetadata, actual)
+			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
+			}
 		})
 	}
 }
@@ -1223,25 +1546,14 @@ func TestConvertUrl(t *testing.T) {
 		ctx                    *api.ContextMock
 		api                    Api
 		engine                 gotenberg.PdfEngine
-		pdfFormats             gotenberg.PdfFormats
 		options                PdfOptions
+		pdfFormats             gotenberg.PdfFormats
+		metadata               map[string]interface{}
 		expectError            bool
 		expectHttpError        bool
 		expectHttpStatus       int
 		expectOutputPathsCount int
 	}{
-		{
-			scenario: "ErrUrlNotAuthorized",
-			ctx:      &api.ContextMock{Context: new(api.Context)},
-			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
-				return ErrUrlNotAuthorized
-			}},
-			options:                DefaultPdfOptions(),
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusForbidden,
-			expectOutputPathsCount: 0,
-		},
 		{
 			scenario: "ErrOmitBackgroundWithoutPrintBackground",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1318,6 +1630,18 @@ func TestConvertUrl(t *testing.T) {
 			expectHttpStatus:       http.StatusConflict,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "ErrInvalidResourceHttpStatusCode",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return ErrInvalidResourceHttpStatusCode
+			}},
+			options:                DefaultPdfOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusConflict,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "ErrConsoleExceptions",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1330,6 +1654,30 @@ func TestConvertUrl(t *testing.T) {
 			expectHttpStatus:       http.StatusConflict,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "ErrLoadingFailed",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return ErrLoadingFailed
+			}},
+			options:                DefaultPdfOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "ErrResourceLoadingFailed",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return ErrResourceLoadingFailed
+			}},
+			options:                DefaultPdfOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusConflict,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "error from Chromium",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1342,23 +1690,7 @@ func TestConvertUrl(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "ErrPdfFormatNotSupported",
-			ctx:      &api.ContextMock{Context: new(api.Context)},
-			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
-				return nil
-			}},
-			engine: &gotenberg.PdfEngineMock{ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-				return gotenberg.ErrPdfFormatNotSupported
-			}},
-			pdfFormats:             gotenberg.PdfFormats{PdfA: "foo"},
-			options:                DefaultPdfOptions(),
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusBadRequest,
-			expectOutputPathsCount: 0,
-		},
-		{
-			scenario: "error from PDF engine",
+			scenario: "PDF engine convert error",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
 			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
 				return nil
@@ -1366,14 +1698,14 @@ func TestConvertUrl(t *testing.T) {
 			engine: &gotenberg.PdfEngineMock{ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 				return errors.New("foo")
 			}},
-			pdfFormats:             gotenberg.PdfFormats{PdfA: "foo"},
 			options:                DefaultPdfOptions(),
+			pdfFormats:             gotenberg.PdfFormats{PdfA: "foo"},
 			expectError:            true,
 			expectHttpError:        false,
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "success with pdfa form field",
+			scenario: "success with PDF formats",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
 			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
 				return nil
@@ -1381,12 +1713,29 @@ func TestConvertUrl(t *testing.T) {
 			engine: &gotenberg.PdfEngineMock{ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 				return nil
 			}},
-			pdfFormats:             gotenberg.PdfFormats{PdfA: gotenberg.PdfA1b},
 			options:                DefaultPdfOptions(),
+			pdfFormats:             gotenberg.PdfFormats{PdfA: gotenberg.PdfA1b},
 			expectError:            false,
 			expectHttpError:        false,
 			expectOutputPathsCount: 1,
 		},
+		{
+			scenario: "PDF engine write metadata error",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return nil
+			}},
+			engine: &gotenberg.PdfEngineMock{WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+				return errors.New("foo")
+			}},
+			options: DefaultPdfOptions(),
+			metadata: map[string]interface{}{
+				"Creator":  "foo",
+				"Producer": "bar",
+			},
+			expectError:     true,
+			expectHttpError: false,
+		},
 		{
 			scenario: "cannot add output paths",
 			ctx: func() *api.ContextMock {
@@ -1408,7 +1757,20 @@ func TestConvertUrl(t *testing.T) {
 			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
 				return nil
 			}},
-			options:                DefaultPdfOptions(),
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return nil
+				},
+			},
+			options:    DefaultPdfOptions(),
+			pdfFormats: gotenberg.PdfFormats{PdfA: gotenberg.PdfA1b},
+			metadata: map[string]interface{}{
+				"Creator":  "foo",
+				"Producer": "bar",
+			},
 			expectError:            false,
 			expectHttpError:        false,
 			expectOutputPathsCount: 1,
@@ -1416,7 +1778,7 @@ func TestConvertUrl(t *testing.T) {
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			err := convertUrl(tc.ctx.Context, tc.api, tc.engine, "", tc.pdfFormats, tc.options)
+			err := convertUrl(tc.ctx.Context, tc.api, tc.engine, "", tc.options, tc.pdfFormats, tc.metadata)
 
 			if tc.expectError && err == nil {
 				t.Fatal("expected error but got none", err)
@@ -1462,18 +1824,6 @@ func TestScreenshotUrl(t *testing.T) {
 		expectHttpStatus       int
 		expectOutputPathsCount int
 	}{
-		{
-			scenario: "ErrUrlNotAuthorized",
-			ctx:      &api.ContextMock{Context: new(api.Context)},
-			api: &ApiMock{ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
-				return ErrUrlNotAuthorized
-			}},
-			options:                DefaultScreenshotOptions(),
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusForbidden,
-			expectOutputPathsCount: 0,
-		},
 		{
 			scenario: "ErrInvalidEvaluationExpression (without waitForExpression form field)",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1514,6 +1864,18 @@ func TestScreenshotUrl(t *testing.T) {
 			expectHttpStatus:       http.StatusConflict,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "ErrInvalidResourceHttpStatusCode",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+				return ErrInvalidResourceHttpStatusCode
+			}},
+			options:                DefaultScreenshotOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusConflict,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "ErrConsoleExceptions",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1526,6 +1888,30 @@ func TestScreenshotUrl(t *testing.T) {
 			expectHttpStatus:       http.StatusConflict,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "ErrLoadingFailed",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+				return ErrLoadingFailed
+			}},
+			options:                DefaultScreenshotOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "ErrResourceLoadingFailed",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+				return ErrResourceLoadingFailed
+			}},
+			options:                DefaultScreenshotOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusConflict,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "error from Chromium",
 			ctx:      &api.ContextMock{Context: new(api.Context)},

pkg/modules/chromium/tasks.go

@@ -3,6 +3,7 @@ package chromium
 import (
 	"bufio"
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"time"
@@ -17,19 +18,39 @@ import (
 
 func printToPdfActionFunc(logger *zap.Logger, outputPath string, options PdfOptions) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
+		paperHeight := options.PaperHeight
+		pageRanges := options.PageRanges
+
+		if options.SinglePage {
+			logger.Debug("single page PDF")
+
+			_, _, _, _, _, cssContentSize, err := page.GetLayoutMetrics().Do(ctx)
+			if err != nil {
+				return fmt.Errorf("get layout metrics: %w", err)
+			}
+
+			// There are 96 CSS pixels per inch.
+			// See https://issues.chromium.org/issues/40267771#comment14.
+			paperHeight = cssContentSize.Height / 96
+			pageRanges = "1" // little dirty hack to avoid leftovers.
+		}
+
 		printToPdf := page.PrintToPDF().
 			WithTransferMode(page.PrintToPDFTransferModeReturnAsStream).
 			WithLandscape(options.Landscape).
 			WithPrintBackground(options.PrintBackground).
 			WithScale(options.Scale).
 			WithPaperWidth(options.PaperWidth).
-			WithPaperHeight(options.PaperHeight).
+			WithPaperHeight(paperHeight).
 			WithMarginTop(options.MarginTop).
 			WithMarginBottom(options.MarginBottom).
 			WithMarginLeft(options.MarginLeft).
 			WithMarginRight(options.MarginRight).
-			WithPageRanges(options.PageRanges).
-			WithPreferCSSPageSize(options.PreferCssPageSize)
+			WithPageRanges(pageRanges).
+			WithPreferCSSPageSize(options.PreferCssPageSize).
+			// Does not seem to work.
+			// See https://github.com/gotenberg/gotenberg/issues/831.
+			WithGenerateTaggedPDF(false)
 
 		hasCustomHeaderFooter := options.HeaderTemplate != DefaultPdfOptions().HeaderTemplate ||
 			options.FooterTemplate != DefaultPdfOptions().FooterTemplate
@@ -100,6 +121,14 @@ func captureScreenshotActionFunc(logger *zap.Logger, outputPath string, options
 			WithOptimizeForSpeed(options.OptimizeForSpeed).
 			WithFormat(page.CaptureScreenshotFormat(options.Format))
 
+		if options.Clip {
+			captureScreenshot = captureScreenshot.WithClip(&page.Viewport{
+				Width:  float64(options.Width),
+				Height: float64(options.Height),
+				Scale:  1,
+			})
+		}
+
 		if options.Format == "jpeg" {
 			captureScreenshot = captureScreenshot.
 				WithQuality(int64(options.Quality))
@@ -133,6 +162,19 @@ func captureScreenshotActionFunc(logger *zap.Logger, outputPath string, options
 	}
 }
 
+func setDeviceMetricsOverride(logger *zap.Logger, width, height int) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		logger.Debug("set device metrics override")
+
+		err := emulation.SetDeviceMetricsOverride(int64(width), int64(height), 1.0, false).Do(ctx)
+		if err == nil {
+			return nil
+		}
+
+		return fmt.Errorf("set device metrics override: %w", err)
+	}
+}
+
 func clearCacheActionFunc(logger *zap.Logger, clear bool) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		// See https://github.com/gotenberg/gotenberg/issues/753.
@@ -190,29 +232,100 @@ func disableJavaScriptActionFunc(logger *zap.Logger, disable bool) chromedp.Acti
 	}
 }
 
-func extraHttpHeadersActionFunc(logger *zap.Logger, extraHttpHeaders map[string]string) chromedp.ActionFunc {
+func setCookiesActionFunc(logger *zap.Logger, cookies []Cookie) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
-		if len(extraHttpHeaders) == 0 {
-			logger.Debug("no extra HTTP headers")
+		if len(cookies) == 0 {
+			logger.Debug("no cookies to set")
 			return nil
 		}
 
-		logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", extraHttpHeaders))
+		deadline, ok := ctx.Deadline()
+		if !ok {
+			return errors.New("context has no deadline, cannot set cookies")
+		}
+		epochTime := cdp.TimeSinceEpoch(deadline)
 
-		headers := make(network.Headers, len(extraHttpHeaders))
-		for key, value := range extraHttpHeaders {
-			headers[key] = value
+		cookiePretty := func(c *network.SetCookieParams) string {
+			return fmt.Sprintf(
+				"Name: '%s', Value: '%s', Domain: '%s', Path: '%s', Secure: %t, HTTPOnly: %t, SameSite: '%s', Expires: %s",
+				c.Name,
+				c.Value,
+				c.Domain,
+				c.Path,
+				c.Secure,
+				c.HTTPOnly,
+				c.SameSite.String(),
+				c.Expires.Time().String(),
+			)
 		}
 
-		err := network.SetExtraHTTPHeaders(headers).Do(ctx)
+		for _, cookie := range cookies {
+			cookieParams := network.
+				SetCookie(cookie.Name, cookie.Value).
+				WithDomain(cookie.Domain).
+				WithPath(cookie.Path).
+				WithSecure(cookie.Secure).
+				WithHTTPOnly(cookie.HttpOnly).
+				WithSameSite(cookie.SameSite).
+				WithExpires(&epochTime)
+
+			err := cookieParams.Do(ctx)
+			if err != nil {
+				return fmt.Errorf("set cookie %s: %w", cookiePretty(cookieParams), err)
+			}
+
+			logger.Debug(fmt.Sprintf("set cookie %s", cookiePretty(cookieParams)))
+		}
+
+		return nil
+	}
+}
+
+func userAgentOverride(logger *zap.Logger, userAgent string) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		if len(userAgent) == 0 {
+			logger.Debug("no user agent override")
+			return nil
+		}
+
+		logger.Debug(fmt.Sprintf("user agent override: %s", userAgent))
+		err := emulation.SetUserAgentOverride(userAgent).Do(ctx)
 		if err == nil {
 			return nil
 		}
 
-		return fmt.Errorf("set extra HTTP headers: %w", err)
+		return fmt.Errorf("set user agent override: %w", err)
 	}
 }
 
+// This code has been replaced with the listenForEventRequestPaused function.
+// Indeed, the user may want to scope the headers per domain, but using
+// network.SetExtraHTTPHeaders set the headers for ALL requests from the page.
+// See https://github.com/gotenberg/gotenberg/issues/1011.
+//
+//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))

pkg/modules/exiftool/doc.go

@@ -0,0 +1,11 @@
+// Package exiftool provides an implementation of the gotenberg.PdfEngine
+// interface using the ExifTool command-line tool. This package allows for:
+//
+// 1. The reading of metadata.
+// 2. The writing of metadata.
+//
+// The path to the exiftool binary must be specified using the
+// EXIFTOOL_BIN_PATH environment variable.
+//
+// See: https://exiftool.org.
+package exiftool

pkg/modules/exiftool/exiftool.go

@@ -0,0 +1,143 @@
+package exiftool
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+
+	"github.com/barasher/go-exiftool"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(new(ExifTool))
+}
+
+// ExifTool abstracts the CLI tool ExifTool and implements the
+// [gotenberg.PdfEngine] interface.
+type ExifTool struct {
+	binPath string
+}
+
+// Descriptor returns [ExifTool]'s module descriptor.
+func (engine *ExifTool) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID:  "exiftool",
+		New: func() gotenberg.Module { return new(ExifTool) },
+	}
+}
+
+// Provision sets the module properties.
+func (engine *ExifTool) Provision(ctx *gotenberg.Context) error {
+	binPath, ok := os.LookupEnv("EXIFTOOL_BIN_PATH")
+	if !ok {
+		return errors.New("EXIFTOOL_BIN_PATH environment variable is not set")
+	}
+
+	engine.binPath = binPath
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (engine *ExifTool) Validate() error {
+	_, err := os.Stat(engine.binPath)
+	if os.IsNotExist(err) {
+		return fmt.Errorf("ExifTool binary path does not exist: %w", err)
+	}
+
+	return nil
+}
+
+// Merge is not available in this implementation.
+func (engine *ExifTool) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+	return fmt.Errorf("merge PDFs with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// Convert is not available in this implementation.
+func (engine *ExifTool) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	return fmt.Errorf("convert PDF to '%+v' with ExifTool: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// ReadMetadata extracts the metadata of a given PDF file.
+func (engine *ExifTool) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+	exifTool, err := exiftool.NewExiftool(exiftool.SetExiftoolBinaryPath(engine.binPath))
+	if err != nil {
+		return nil, fmt.Errorf("new ExifTool: %w", err)
+	}
+
+	defer func(exifTool *exiftool.Exiftool) {
+		err := exifTool.Close()
+		if err != nil {
+			logger.Error(fmt.Sprintf("close ExifTool: %v", err))
+		}
+	}(exifTool)
+
+	fileMetadata := exifTool.ExtractMetadata(inputPath)
+	if fileMetadata[0].Err != nil {
+		return nil, fmt.Errorf("read metadata with ExitfTool: %w", fileMetadata[0].Err)
+	}
+
+	return fileMetadata[0].Fields, nil
+}
+
+// WriteMetadata writes the metadata into a given PDF file.
+func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+	exifTool, err := exiftool.NewExiftool(exiftool.SetExiftoolBinaryPath(engine.binPath))
+	if err != nil {
+		return fmt.Errorf("new ExifTool: %w", err)
+	}
+
+	defer func(exifTool *exiftool.Exiftool) {
+		err := exifTool.Close()
+		if err != nil {
+			logger.Error(fmt.Sprintf("close ExifTool: %v", err))
+		}
+	}(exifTool)
+
+	fileMetadata := exifTool.ExtractMetadata(inputPath)
+	if fileMetadata[0].Err != nil {
+		return fmt.Errorf("read metadata with ExitfTool: %w", fileMetadata[0].Err)
+	}
+
+	for key, value := range metadata {
+		switch val := value.(type) {
+		case string:
+			fileMetadata[0].SetString(key, val)
+		case []string:
+			fileMetadata[0].SetStrings(key, val)
+		case bool:
+			fileMetadata[0].SetString(key, fmt.Sprintf("%t", val))
+		case int:
+			fileMetadata[0].SetInt(key, int64(val))
+		case int64:
+			fileMetadata[0].SetInt(key, val)
+		case float32:
+			fileMetadata[0].SetFloat(key, float64(val))
+		case float64:
+			fileMetadata[0].SetFloat(key, val)
+		// TODO: support more complex cases, e.g., arrays and nested objects
+		// 	(limitations in underlying library).
+		default:
+			return fmt.Errorf("write PDF metadata with ExifTool: %w", gotenberg.ErrPdfEngineMetadataValueNotSupported)
+		}
+	}
+
+	exifTool.WriteMetadata(fileMetadata)
+	if fileMetadata[0].Err != nil {
+		return fmt.Errorf("write PDF metadata with ExifTool: %w", fileMetadata[0].Err)
+	}
+
+	return nil
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module      = (*ExifTool)(nil)
+	_ gotenberg.Provisioner = (*ExifTool)(nil)
+	_ gotenberg.Validator   = (*ExifTool)(nil)
+	_ gotenberg.PdfEngine   = (*ExifTool)(nil)
+)

pkg/modules/exiftool/exiftool_test.go

@@ -0,0 +1,322 @@
+package exiftool
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"testing"
+
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+func TestExifTool_Descriptor(t *testing.T) {
+	descriptor := new(ExifTool).Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(ExifTool))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestExifTool_Provision(t *testing.T) {
+	engine := new(ExifTool)
+	ctx := gotenberg.NewContext(gotenberg.ParsedFlags{}, nil)
+
+	err := engine.Provision(ctx)
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestExifTool_Validate(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		binPath     string
+		expectError bool
+	}{
+		{
+			scenario:    "empty bin path",
+			binPath:     "",
+			expectError: true,
+		},
+		{
+			scenario:    "bin path does not exist",
+			binPath:     "/foo",
+			expectError: true,
+		},
+		{
+			scenario:    "validate success",
+			binPath:     os.Getenv("EXIFTOOL_BIN_PATH"),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(ExifTool)
+			engine.binPath = tc.binPath
+			err := engine.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 TestExiftool_Merge(t *testing.T) {
+	engine := new(ExifTool)
+	err := engine.Merge(context.Background(), zap.NewNop(), nil, "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestExiftool_Convert(t *testing.T) {
+	engine := new(ExifTool)
+	err := engine.Convert(context.Background(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestExiftool_ReadMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario       string
+		inputPath      string
+		expectMetadata map[string]interface{}
+		expectError    bool
+	}{
+		{
+			scenario:       "invalid input path",
+			inputPath:      "foo",
+			expectMetadata: nil,
+			expectError:    true,
+		},
+		{
+			scenario:  "success",
+			inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
+			expectMetadata: map[string]interface{}{
+				"FileName":          "sample1.pdf",
+				"FileTypeExtension": "pdf",
+				"MIMEType":          "application/pdf",
+				"PDFVersion":        1.4,
+				"PageCount":         float64(3),
+			},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(ExifTool)
+			err := engine.Provision(nil)
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			metadata, err := engine.ReadMetadata(context.Background(), zap.NewNop(), tc.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.expectMetadata != nil && err == nil {
+				for k, v := range tc.expectMetadata {
+					if v2, ok := metadata[k]; !ok || v != v2 {
+						t.Errorf("expected entry %s with value %v to exists", k, v)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestExiftool_WriteMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario       string
+		createCopy     bool
+		inputPath      string
+		metadata       map[string]interface{}
+		expectMetadata map[string]interface{}
+		expectError    bool
+		expectedError  error
+	}{
+		{
+			scenario:    "invalid input path",
+			createCopy:  false,
+			inputPath:   "foo",
+			expectError: true,
+		},
+		{
+			scenario:   "gotenberg.ErrPdfEngineMetadataValueNotSupported",
+			createCopy: true,
+			inputPath:  "/tests/test/testdata/pdfengines/sample1.pdf",
+			metadata: map[string]interface{}{
+				"Unsupported": map[string]interface{}{},
+			},
+			expectError:   true,
+			expectedError: gotenberg.ErrPdfEngineMetadataValueNotSupported,
+		},
+		{
+			scenario:   "success",
+			createCopy: true,
+			inputPath:  "/tests/test/testdata/pdfengines/sample1.pdf",
+			metadata: map[string]interface{}{
+				"Author":       "Julien Neuhart",
+				"Copyright":    "Julien Neuhart",
+				"CreationDate": "2006-09-18T16:27:50-04:00",
+				"Creator":      "Gotenberg",
+				"Keywords": []string{
+					"first",
+					"second",
+				},
+				"Marked":     true,
+				"ModDate":    "2006-09-18T16:27:50-04:00",
+				"PDFVersion": 1.7,
+				"Producer":   "Gotenberg",
+				"Subject":    "Sample",
+				"Title":      "Sample",
+				"Trapped":    "Unknown",
+				// Those are not valid PDF metadata.
+				"int":     1,
+				"int64":   int64(2),
+				"float32": float32(2.2),
+				"float64": 3.3,
+			},
+			expectMetadata: map[string]interface{}{
+				"Author":       "Julien Neuhart",
+				"Copyright":    "Julien Neuhart",
+				"CreationDate": "2006:09:18 16:27:50-04:00",
+				"Creator":      "Gotenberg",
+				"Keywords": []interface{}{
+					"first",
+					"second",
+				},
+				"Marked":     true,
+				"ModDate":    "2006:09:18 16:27:50-04:00",
+				"PDFVersion": 1.7,
+				"Producer":   "Gotenberg",
+				"Subject":    "Sample",
+				"Title":      "Sample",
+				"Trapped":    "Unknown",
+			},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(ExifTool)
+			err := engine.Provision(nil)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			var destinationPath string
+			if tc.createCopy {
+				fs := gotenberg.NewFileSystem()
+				outputDir, err := fs.MkdirAll()
+				if err != nil {
+					t.Fatalf("expected error no but got: %v", err)
+				}
+
+				defer func() {
+					err = os.RemoveAll(fs.WorkingDirPath())
+					if err != nil {
+						t.Fatalf("expected no error while cleaning up but got: %v", err)
+					}
+				}()
+
+				destinationPath = fmt.Sprintf("%s/copy_temp.pdf", outputDir)
+				source, err := os.Open(tc.inputPath)
+				if err != nil {
+					t.Fatalf("open source file: %v", err)
+				}
+
+				defer func(source *os.File) {
+					err := source.Close()
+					if err != nil {
+						t.Fatalf("close file: %v", err)
+					}
+				}(source)
+
+				destination, err := os.Create(destinationPath)
+				if err != nil {
+					t.Fatalf("create destination file: %v", err)
+				}
+
+				defer func(destination *os.File) {
+					err := destination.Close()
+					if err != nil {
+						t.Fatalf("close file: %v", err)
+					}
+				}(destination)
+
+				_, err = io.Copy(destination, source)
+				if err != nil {
+					t.Fatalf("copy source into destination: %v", err)
+				}
+			} else {
+				destinationPath = tc.inputPath
+			}
+
+			err = engine.WriteMetadata(context.Background(), zap.NewNop(), tc.metadata, destinationPath)
+
+			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)
+			}
+
+			if tc.expectError {
+				return
+			}
+
+			metadata, err := engine.ReadMetadata(context.Background(), zap.NewNop(), destinationPath)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectMetadata != nil && err == nil {
+				for k, v := range tc.expectMetadata {
+					v2, ok := metadata[k]
+					if !ok {
+						t.Errorf("expected entry %s with value %v to exists, but got none", k, v)
+						continue
+					}
+
+					switch v2.(type) {
+					case []interface{}:
+						for i, entry := range v.([]interface{}) {
+							if entry != v2.([]interface{})[i] {
+								t.Errorf("expected entry %s to contain value %v, but got %v", k, entry, v2.([]interface{})[i])
+							}
+						}
+					default:
+						if v != v2 {
+							t.Errorf("expected entry %s with value %v to exists, but got %v", k, v, v2)
+						}
+					}
+				}
+			}
+		})
+	}
+}

pkg/modules/libreoffice/api/api.go

@@ -25,9 +25,16 @@ var (
 	// 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")
+	// ErrUnoException happens when unoconverter returns an exit code 5.
+	ErrUnoException = errors.New("uno exception")
+
+	// ErrRuntimeException happens when unoconverter returns an exit code 6.
+	ErrRuntimeException = errors.New("uno exception")
+
+	// ErrCoreDumped happens randomly; sometime a conversion will work as
+	// expected, and some other time the same conversion will fail.
+	// See https://github.com/gotenberg/gotenberg/issues/639.
+	ErrCoreDumped = errors.New("core dumped")
 )
 
 // Api is a module which provides a [Uno] to interact with LibreOffice.
@@ -41,21 +48,133 @@ type Api struct {
 }
 
 // Options gathers available options when converting a document to PDF.
+// See: https://help.libreoffice.org/latest/en-US/text/shared/guide/pdf_params.html.
 type Options struct {
+	// Password specifies the password for opening the source file.
+	Password string
+
 	// Landscape allows to change the orientation of the resulting PDF.
-	// Optional.
 	Landscape bool
 
 	// PageRanges allows to select the pages to convert.
-	// Optional.
 	PageRanges string
 
+	// ExportFormFields specifies whether form fields are exported as widgets
+	// or only their fixed print representation is exported.
+	ExportFormFields bool
+
+	// AllowDuplicateFieldNames specifies whether multiple form fields exported
+	// are allowed to have the same field name.
+	AllowDuplicateFieldNames bool
+
+	// ExportBookmarks specifies if bookmarks are exported to PDF.
+	ExportBookmarks bool
+
+	// ExportBookmarksToPdfDestination specifies that the bookmarks contained
+	// in the source LibreOffice file should be exported to the PDF file as
+	// Named Destination.
+	ExportBookmarksToPdfDestination bool
+
+	// ExportPlaceholders exports the placeholders fields visual markings only.
+	// The exported placeholder is ineffective.
+	ExportPlaceholders bool
+
+	// ExportNotes specifies if notes are exported to PDF.
+	ExportNotes bool
+
+	// ExportNotesPages specifies if notes pages are exported to PDF.
+	// Notes pages are available in Impress documents only.
+	ExportNotesPages bool
+
+	// ExportOnlyNotesPages specifies, if the property ExportNotesPages is set
+	// to true, if only notes pages are exported to PDF.
+	ExportOnlyNotesPages bool
+
+	// ExportNotesInMargin specifies if notes in margin are exported to PDF.
+	ExportNotesInMargin bool
+
+	// ConvertOooTargetToPdfTarget specifies that the target documents with
+	// .od[tpgs] extension, will have that extension changed to .pdf when the
+	// link is exported to PDF. The source document remains untouched.
+	ConvertOooTargetToPdfTarget bool
+
+	// ExportLinksRelativeFsys specifies that the file system related
+	// hyperlinks (file:// protocol) present in the document will be exported
+	// as relative to the source document location.
+	ExportLinksRelativeFsys bool
+
+	// ExportHiddenSlides exports, for LibreOffice Impress, slides that are not
+	// included in slide shows.
+	ExportHiddenSlides bool
+
+	// SkipEmptyPages specifies that automatically inserted empty pages are
+	// suppressed. This option is active only if storing Writer documents.
+	SkipEmptyPages bool
+
+	// AddOriginalDocumentAsStream specifies that a stream is inserted to the
+	// PDF file which contains the original document for archiving purposes.
+	AddOriginalDocumentAsStream bool
+
+	// SinglePageSheets ignores each sheet’s paper size, print ranges and
+	// shown/hidden status and puts every sheet (even hidden sheets) on exactly
+	// one page.
+	SinglePageSheets bool
+
+	// LosslessImageCompression specifies if images are exported to PDF using
+	// a lossless compression format like PNG or compressed using the JPEG
+	// format.
+	LosslessImageCompression bool
+
+	// Quality specifies the quality of the JPG export. A higher value produces
+	// a higher-quality image and a larger file. Between 1 and 100.
+	Quality int
+
+	// ReduceImageResolution specifies if the resolution of each image is
+	// reduced to the resolution specified by the property MaxImageResolution.
+	ReduceImageResolution bool
+
+	// MaxImageResolution, if the property ReduceImageResolution is set to
+	// true, tells if all images will be reduced to the given value in DPI.
+	// Possible values are: 75, 150, 300, 600 and 1200.
+	MaxImageResolution int
+
 	// PdfFormats allows to convert the resulting PDF to PDF/A-1b, PDF/A-2b,
 	// PDF/A-3b and PDF/UA.
-	// Optional.
 	PdfFormats gotenberg.PdfFormats
 }
 
+// DefaultOptions returns the default values for Options.
+func DefaultOptions() Options {
+	return Options{
+		Password:                        "",
+		Landscape:                       false,
+		PageRanges:                      "",
+		ExportFormFields:                true,
+		AllowDuplicateFieldNames:        false,
+		ExportBookmarks:                 true,
+		ExportBookmarksToPdfDestination: false,
+		ExportPlaceholders:              false,
+		ExportNotes:                     false,
+		ExportNotesPages:                false,
+		ExportOnlyNotesPages:            false,
+		ExportNotesInMargin:             false,
+		ConvertOooTargetToPdfTarget:     false,
+		ExportLinksRelativeFsys:         false,
+		ExportHiddenSlides:              false,
+		SkipEmptyPages:                  false,
+		AddOriginalDocumentAsStream:     false,
+		SinglePageSheets:                false,
+		LosslessImageCompression:        false,
+		Quality:                         90,
+		ReduceImageResolution:           false,
+		MaxImageResolution:              300,
+		PdfFormats: gotenberg.PdfFormats{
+			PdfA:  "",
+			PdfUa: false,
+		},
+	}
+}
+
 // 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
@@ -80,6 +199,7 @@ func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
 		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.Int64("libreoffice-max-queue-size", 0, "Maximum request queue size for LibreOffice. 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")
 
@@ -123,7 +243,7 @@ func (a *Api) Provision(ctx *gotenberg.Context) error {
 
 	// Process.
 	a.libreOffice = newLibreOfficeProcess(a.args)
-	a.supervisor = gotenberg.NewProcessSupervisor(a.logger, a.libreOffice, flags.MustInt64("libreoffice-restart-after"))
+	a.supervisor = gotenberg.NewProcessSupervisor(a.logger, a.libreOffice, flags.MustInt64("libreoffice-restart-after"), flags.MustInt64("libreoffice-max-queue-size"))
 
 	return nil
 }
@@ -256,94 +376,157 @@ func (a *Api) LibreOffice() (Uno, error) {
 
 // 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 {
+	err := a.supervisor.Run(ctx, logger, func() error {
 		return a.libreOffice.pdf(ctx, logger, inputPath, outputPath, options)
 	})
+
+	if err == nil {
+		return nil
+	}
+
+	// See https://github.com/gotenberg/gotenberg/issues/639.
+	if errors.Is(err, ErrCoreDumped) {
+		logger.Debug(fmt.Sprintf("got a '%s' error, retry conversion", err))
+		return a.Pdf(ctx, logger, inputPath, outputPath, options)
+	}
+
+	return fmt.Errorf("supervisor run task: %w", err)
 }
 
 // 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{
+		".123",
+		".602",
+		".abw",
 		".bib",
-		".doc",
-		".xml",
-		".docx",
-		".fodt",
-		".html",
-		".ltx",
-		".txt",
-		".odt",
-		".ott",
-		".pdb",
-		".pdf",
-		".psw",
-		".rtf",
-		".sdw",
-		".stw",
-		".sxw",
-		".uot",
-		".vor",
-		".wps",
-		".epub",
-		".png",
 		".bmp",
+		".cdr",
+		".cgm",
+		".cmx",
+		".csv",
+		".cwk",
+		".dbf",
+		".dif",
+		".doc",
+		".docm",
+		".docx",
+		".dot",
+		".dotm",
+		".dotx",
+		".dxf",
 		".emf",
 		".eps",
+		".epub",
 		".fodg",
+		".fodp",
+		".fods",
+		".fodt",
+		".fopd",
 		".gif",
-		".jpg",
+		".htm",
+		".html",
+		".hwp",
 		".jpeg",
+		".jpg",
+		".key",
+		".ltx",
+		".lwp",
+		".mcw",
 		".met",
+		".mml",
+		".mw",
+		".numbers",
 		".odd",
+		".odg",
+		".odm",
+		".odp",
+		".ods",
+		".odt",
 		".otg",
+		".oth",
+		".otp",
+		".ots",
+		".ott",
+		".pages",
 		".pbm",
+		".pcd",
 		".pct",
+		".pcx",
+		".pdb",
+		".pdf",
 		".pgm",
+		".png",
+		".pot",
+		".potm",
+		".potx",
 		".ppm",
+		".pps",
+		".ppt",
+		".pptm",
+		".pptx",
+		".psd",
+		".psw",
+		".pub",
+		".pwp",
+		".pxl",
 		".ras",
+		".rtf",
+		".sda",
+		".sdc",
+		".sdd",
+		".sdp",
+		".sdw",
+		".sgl",
+		".slk",
+		".smf",
+		".stc",
 		".std",
+		".sti",
+		".stw",
 		".svg",
 		".svm",
 		".swf",
+		".sxc",
 		".sxd",
+		".sxg",
+		".sxi",
+		".sxm",
 		".sxw",
+		".tga",
 		".tif",
 		".tiff",
-		".xhtml",
-		".xpm",
-		".odp",
-		".fodp",
-		".potm",
-		".pot",
-		".pptx",
-		".pps",
-		".ppt",
-		".pwp",
-		".sda",
-		".sdd",
-		".sti",
-		".sxi",
+		".txt",
+		".uof",
 		".uop",
-		".wmf",
-		".csv",
-		".dbf",
-		".dif",
-		".fods",
-		".ods",
-		".ots",
-		".pxl",
-		".sdc",
-		".slk",
-		".stc",
-		".sxc",
 		".uos",
+		".uot",
+		".vdx",
+		".vor",
+		".vsd",
+		".vsdm",
+		".vsdx",
+		".wb2",
+		".wk1",
+		".wks",
+		".wmf",
+		".wpd",
+		".wpg",
+		".wps",
+		".xbm",
+		".xhtml",
 		".xls",
-		".xlt",
+		".xlsb",
+		".xlsm",
 		".xlsx",
-		".odg",
-		".dotx",
+		".xlt",
+		".xltm",
 		".xltx",
+		".xlw",
+		".xml",
+		".xpm",
+		".zabw",
 	}
 }
 

pkg/modules/libreoffice/api/api_test.go

@@ -14,6 +14,15 @@ import (
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
+func TestDefaultOptions(t *testing.T) {
+	actual := DefaultOptions()
+	notExpect := Options{}
+
+	if reflect.DeepEqual(actual, notExpect) {
+		t.Errorf("expected %v and got identical %v", actual, notExpect)
+	}
+}
+
 func TestApi_Descriptor(t *testing.T) {
 	descriptor := new(Api).Descriptor()
 
@@ -424,6 +433,13 @@ func TestApi_Pdf(t *testing.T) {
 			}},
 			expectError: true,
 		},
+		{
+			scenario: "ErrCoreDumped",
+			libreOffice: &libreOfficeMock{pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+				return ErrCoreDumped
+			}},
+			expectError: false,
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			a := new(Api)
@@ -450,7 +466,7 @@ func TestApi_Extensions(t *testing.T) {
 	extensions := a.Extensions()
 
 	actual := len(extensions)
-	expect := 79
+	expect := 130
 
 	if actual != expect {
 		t.Errorf("expected %d extensions, but got %d", expect, actual)

pkg/modules/libreoffice/api/libreoffice.go

@@ -8,6 +8,7 @@ import (
 	"net"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -265,6 +266,10 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 		args = append(args, "-vvv")
 	}
 
+	if options.Password != "" {
+		args = append(args, "--password", options.Password)
+	}
+
 	if options.Landscape {
 		args = append(args, "--printer", "PaperOrientation=landscape")
 	}
@@ -273,6 +278,27 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 		args = append(args, "--export", fmt.Sprintf("PageRange=%s", options.PageRanges))
 	}
 
+	args = append(args, "--export", fmt.Sprintf("ExportFormFields=%t", options.ExportFormFields))
+	args = append(args, "--export", fmt.Sprintf("AllowDuplicateFieldNames=%t", options.AllowDuplicateFieldNames))
+	args = append(args, "--export", fmt.Sprintf("ExportBookmarks=%t", options.ExportBookmarks))
+	args = append(args, "--export", fmt.Sprintf("ExportBookmarks=%t", options.ExportBookmarks))
+	args = append(args, "--export", fmt.Sprintf("ExportBookmarksToPDFDestination=%t", options.ExportBookmarksToPdfDestination))
+	args = append(args, "--export", fmt.Sprintf("ExportPlaceholders=%t", options.ExportPlaceholders))
+	args = append(args, "--export", fmt.Sprintf("ExportNotes=%t", options.ExportNotes))
+	args = append(args, "--export", fmt.Sprintf("ExportNotesPages=%t", options.ExportNotesPages))
+	args = append(args, "--export", fmt.Sprintf("ExportOnlyNotesPages=%t", options.ExportOnlyNotesPages))
+	args = append(args, "--export", fmt.Sprintf("ExportNotesInMargin=%t", options.ExportNotesInMargin))
+	args = append(args, "--export", fmt.Sprintf("ConvertOOoTargetToPDFTarget=%t", options.ConvertOooTargetToPdfTarget))
+	args = append(args, "--export", fmt.Sprintf("ExportLinksRelativeFsys=%t", options.ExportLinksRelativeFsys))
+	args = append(args, "--export", fmt.Sprintf("ExportHiddenSlides=%t", options.ExportHiddenSlides))
+	args = append(args, "--export", fmt.Sprintf("IsSkipEmptyPages=%t", options.SkipEmptyPages))
+	args = append(args, "--export", fmt.Sprintf("IsAddStream=%t", options.AddOriginalDocumentAsStream))
+	args = append(args, "--export", fmt.Sprintf("SinglePageSheets=%t", options.SinglePageSheets))
+	args = append(args, "--export", fmt.Sprintf("UseLosslessCompression=%t", options.LosslessImageCompression))
+	args = append(args, "--export", fmt.Sprintf("Quality=%d", options.Quality))
+	args = append(args, "--export", fmt.Sprintf("ReduceImageResolution=%t", options.ReduceImageResolution))
+	args = append(args, "--export", fmt.Sprintf("MaxImageResolution=%d", options.MaxImageResolution))
+
 	switch options.PdfFormats.PdfA {
 	case "":
 	case gotenberg.PdfA1b:
@@ -288,8 +314,16 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 	if options.PdfFormats.PdfUa {
 		args = append(
 			args,
-			"--export", "EnableTextAccessForAccessibilityTools=true",
+			"--export", "PDFUACompliance=true",
 			"--export", "UseTaggedPDF=true",
+			"--export", "EnableTextAccessForAccessibilityTools=true",
+		)
+	} else {
+		args = append(
+			args,
+			"--export", "PDFUACompliance=false",
+			"--export", "UseTaggedPDF=false",
+			"--export", "EnableTextAccessForAccessibilityTools=false",
 		)
 	}
 
@@ -313,10 +347,22 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 	}
 
 	// 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
+	// For instance, an exit code 5 may be explained by a malformed page
+	// ranges, but also by a not required password.
+
+	// We may want to retry in case of a core dumped event.
+	// See https://github.com/gotenberg/gotenberg/issues/639.
+	if strings.Contains(err.Error(), "core dumped") {
+		return ErrCoreDumped
+	}
+
+	if exitCode == 5 {
+		// Potentially malformed page ranges or password not required.
+		return ErrUnoException
+	}
+	if exitCode == 6 {
+		// Password potentially required or invalid.
+		return ErrRuntimeException
 	}
 
 	// Possible errors:

pkg/modules/libreoffice/api/libreoffice_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"os"
 	"testing"
 	"time"
@@ -250,7 +251,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 			expectedError: ErrInvalidPdfFormats,
 		},
 		{
-			scenario: "ErrMalformedPageRanges",
+			scenario: "ErrUnoException",
 			libreOffice: newLibreOfficeProcess(
 				libreOfficeArguments{
 					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
@@ -267,7 +268,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
 				}
 
-				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("ErrMalformedPageRanges"), 0o755)
+				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)
 				}
@@ -277,7 +278,61 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 			cancelledCtx:  false,
 			start:         true,
 			expectError:   true,
-			expectedError: ErrMalformedPageRanges,
+			expectedError: ErrUnoException,
+		},
+		{
+			scenario: "ErrRuntimeException",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			options: Options{Password: "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))
+				}
+
+				in, err := os.Open("/tests/test/testdata/libreoffice/protected.docx")
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				defer func() {
+					err := in.Close()
+					if err != nil {
+						t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+					}
+				}()
+
+				out, err := os.Create(fmt.Sprintf("%s/protected.docx", fs.WorkingDirPath()))
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				defer func() {
+					err := out.Close()
+					if err != nil {
+						t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+					}
+				}()
+
+				_, err = io.Copy(out, in)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				return fs
+			}(),
+			cancelledCtx:  false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrRuntimeException,
 		},
 		{
 			scenario: "context done",
@@ -336,7 +391,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 			expectError:  false,
 		},
 		{
-			scenario: "success (landscape)",
+			scenario: "success (not default options)",
 			libreOffice: newLibreOfficeProcess(
 				libreOfficeArguments{
 					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
@@ -352,43 +407,37 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
 				}
 
-				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Landscape"), 0o755)
+				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
 			}(),
-			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"},
+			options: Options{
+				Password:                        "", // Ok, the only exception in this list.
+				Landscape:                       true,
+				PageRanges:                      "1",
+				ExportFormFields:                false,
+				AllowDuplicateFieldNames:        true,
+				ExportBookmarks:                 false,
+				ExportBookmarksToPdfDestination: true,
+				ExportPlaceholders:              true,
+				ExportNotes:                     true,
+				ExportNotesPages:                true,
+				ExportOnlyNotesPages:            true,
+				ExportNotesInMargin:             true,
+				ConvertOooTargetToPdfTarget:     true,
+				ExportLinksRelativeFsys:         true,
+				ExportHiddenSlides:              true,
+				SkipEmptyPages:                  true,
+				AddOriginalDocumentAsStream:     true,
+				SinglePageSheets:                true,
+				LosslessImageCompression:        true,
+				Quality:                         100,
+				ReduceImageResolution:           true,
+				MaxImageResolution:              600,
+			},
 			cancelledCtx: false,
 			start:        true,
 			expectError:  false,

pkg/modules/libreoffice/api/mocks.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"context"
+	"errors"
 
 	"go.uber.org/zap"
 
@@ -33,12 +34,21 @@ func (provider *ProviderMock) LibreOffice() (Uno, error) {
 
 // libreOfficeMock is a mock for the [libreOffice] interface.
 type libreOfficeMock struct {
+	errCoreDumpedCount int
+
 	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)
+	err := b.pdfMock(ctx, logger, inputPath, outputPath, options)
+	if errors.Is(err, ErrCoreDumped) {
+		b.errCoreDumpedCount += 1
+	}
+	if b.errCoreDumpedCount > 1 {
+		return nil
+	}
+	return err
 }
 
 // Interface guards.

pkg/modules/libreoffice/api/mocks_test.go

@@ -42,14 +42,53 @@ func TestProviderMock(t *testing.T) {
 }
 
 func TestLibreOfficeMock(t *testing.T) {
-	mock := &libreOfficeMock{
-		pdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
-			return nil
+	for _, tc := range []struct {
+		scenario    string
+		mock        *libreOfficeMock
+		expectError bool
+	}{
+		{
+			scenario: "success",
+			mock: &libreOfficeMock{
+				pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+					return nil
+				},
+			},
+			expectError: false,
 		},
-	}
+		{
+			scenario: "ErrCoreDumped (first call)",
+			mock: &libreOfficeMock{
+				pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+					return ErrCoreDumped
+				},
+			},
+			expectError: true,
+		},
+		{
+			scenario: "ErrCoreDumped (second call)",
+			mock: func() *libreOfficeMock {
+				m := &libreOfficeMock{
+					pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+						return ErrCoreDumped
+					},
+				}
+				m.pdf(context.Background(), zap.NewNop(), "", "", Options{})
+				return m
+			}(),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.mock.pdf(context.Background(), zap.NewNop(), "", "", Options{})
 
-	err := mock.pdf(context.Background(), zap.NewNop(), "", "", Options{})
-	if err != nil {
-		t.Errorf("expected no error from libreOfficeMock.pdf, but got: %v", err)
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error from libreOfficeMock.pdf but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error from libreOfficeMock.pdf but got none")
+			}
+		})
 	}
 }

pkg/modules/libreoffice/pdfengine/doc.go

@@ -1,4 +1,6 @@
 // Package pdfengine provides a module which interacts with LibreOffice via the
 // UNO (Universal Network Objects) API and implements the gotenberg.PdfEngine
-// interface.
+// interface. This package allows for:
+//
+// 1. The conversion to specific PDF formats.
 package pdfengine

pkg/modules/libreoffice/pdfengine/pdfengine.go

@@ -56,9 +56,9 @@ func (engine *LibreOfficePdfEngine) Merge(ctx context.Context, logger *zap.Logge
 // 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,
-	})
+	opts := api.DefaultOptions()
+	opts.PdfFormats = formats
+	err := engine.unoApi.Pdf(ctx, logger, inputPath, outputPath, opts)
 
 	if err == nil {
 		return nil
@@ -71,6 +71,16 @@ func (engine *LibreOfficePdfEngine) Convert(ctx context.Context, logger *zap.Log
 	return fmt.Errorf("convert PDF to '%+v' with LibreOffice: %w", formats, err)
 }
 
+// ReadMetadata is not available in this implementation.
+func (engine *LibreOfficePdfEngine) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+	return nil, fmt.Errorf("read PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// WriteMetadata is not available in this implementation.
+func (engine *LibreOfficePdfEngine) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+	return fmt.Errorf("write PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
 // Interface guards.
 var (
 	_ gotenberg.Module      = (*LibreOfficePdfEngine)(nil)

pkg/modules/libreoffice/pdfengine/pdfengine_test.go

@@ -166,3 +166,21 @@ func TestLibreOfficePdfEngine_Convert(t *testing.T) {
 		})
 	}
 }
+
+func TestLibreOfficePdfEngine_ReadMetadata(t *testing.T) {
+	engine := new(LibreOfficePdfEngine)
+	_, err := engine.ReadMetadata(context.Background(), zap.NewNop(), "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestLibreOfficePdfEngine_WriteMetadata(t *testing.T) {
+	engine := new(LibreOfficePdfEngine)
+	err := engine.WriteMetadata(context.Background(), zap.NewNop(), nil, "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}

pkg/modules/libreoffice/routes.go

@@ -1,9 +1,12 @@
 package libreoffice
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
+	"slices"
+	"strconv"
 
 	"github.com/labstack/echo/v4"
 
@@ -21,26 +24,115 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 		IsMultipart: true,
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)
+			defaultOptions := libreofficeapi.DefaultOptions()
 
 			// Let's get the data from the form and validate them.
 			var (
-				inputPaths       []string
-				landscape        bool
-				nativePageRanges string
-				pdfa             string
-				pdfua            bool
-				nativePdfFormats bool
-				merge            bool
+				inputPaths                      []string
+				password                        string
+				landscape                       bool
+				nativePageRanges                string
+				exportFormFields                bool
+				allowDuplicateFieldNames        bool
+				exportBookmarks                 bool
+				exportBookmarksToPdfDestination bool
+				exportPlaceholders              bool
+				exportNotes                     bool
+				exportNotesPages                bool
+				exportOnlyNotesPages            bool
+				exportNotesInMargin             bool
+				convertOooTargetToPdfTarget     bool
+				exportLinksRelativeFsys         bool
+				exportHiddenSlides              bool
+				skipEmptyPages                  bool
+				addOriginalDocumentAsStream     bool
+				singlePageSheets                bool
+				losslessImageCompression        bool
+				quality                         int
+				reduceImageResolution           bool
+				maxImageResolution              int
+				pdfa                            string
+				pdfua                           bool
+				nativePdfFormats                bool
+				merge                           bool
+				metadata                        map[string]interface{}
 			)
 
 			err := ctx.FormData().
 				MandatoryPaths(libreOffice.Extensions(), &inputPaths).
-				Bool("landscape", &landscape, false).
-				String("nativePageRanges", &nativePageRanges, "").
+				String("password", &password, defaultOptions.Password).
+				Bool("landscape", &landscape, defaultOptions.Landscape).
+				String("nativePageRanges", &nativePageRanges, defaultOptions.PageRanges).
+				Bool("exportFormFields", &exportFormFields, defaultOptions.ExportFormFields).
+				Bool("allowDuplicateFieldNames", &allowDuplicateFieldNames, defaultOptions.AllowDuplicateFieldNames).
+				Bool("exportBookmarks", &exportBookmarks, defaultOptions.ExportBookmarks).
+				Bool("exportBookmarksToPdfDestination", &exportBookmarksToPdfDestination, defaultOptions.ExportBookmarksToPdfDestination).
+				Bool("exportPlaceholders", &exportPlaceholders, defaultOptions.ExportPlaceholders).
+				Bool("exportNotes", &exportNotes, defaultOptions.ExportNotes).
+				Bool("exportNotesPages", &exportNotesPages, defaultOptions.ExportNotesPages).
+				Bool("exportOnlyNotesPages", &exportOnlyNotesPages, defaultOptions.ExportOnlyNotesPages).
+				Bool("exportNotesInMargin", &exportNotesInMargin, defaultOptions.ExportNotesInMargin).
+				Bool("convertOooTargetToPdfTarget", &convertOooTargetToPdfTarget, defaultOptions.ConvertOooTargetToPdfTarget).
+				Bool("exportLinksRelativeFsys", &exportLinksRelativeFsys, defaultOptions.ExportLinksRelativeFsys).
+				Bool("exportHiddenSlides", &exportHiddenSlides, defaultOptions.ExportHiddenSlides).
+				Bool("skipEmptyPages", &skipEmptyPages, defaultOptions.SkipEmptyPages).
+				Bool("addOriginalDocumentAsStream", &addOriginalDocumentAsStream, defaultOptions.AddOriginalDocumentAsStream).
+				Bool("singlePageSheets", &singlePageSheets, defaultOptions.SinglePageSheets).
+				Bool("losslessImageCompression", &losslessImageCompression, defaultOptions.LosslessImageCompression).
+				Custom("quality", func(value string) error {
+					if value == "" {
+						quality = defaultOptions.Quality
+						return nil
+					}
+
+					intValue, err := strconv.Atoi(value)
+					if err != nil {
+						return err
+					}
+
+					if intValue < 1 {
+						return errors.New("value is inferior to 1")
+					}
+
+					if intValue > 100 {
+						return errors.New("value is superior to 100")
+					}
+
+					quality = intValue
+					return nil
+				}).
+				Bool("reduceImageResolution", &reduceImageResolution, defaultOptions.ReduceImageResolution).
+				Custom("maxImageResolution", func(value string) error {
+					if value == "" {
+						maxImageResolution = defaultOptions.MaxImageResolution
+						return nil
+					}
+
+					intValue, err := strconv.Atoi(value)
+					if err != nil {
+						return err
+					}
+
+					if !slices.Contains([]int{75, 150, 300, 600, 1200}, intValue) {
+						return errors.New("value is not 75, 150, 300, 600 or 1200")
+					}
+
+					maxImageResolution = intValue
+					return nil
+				}).
 				String("pdfa", &pdfa, "").
 				Bool("pdfua", &pdfua, false).
 				Bool("nativePdfFormats", &nativePdfFormats, true).
 				Bool("merge", &merge, false).
+				Custom("metadata", func(value string) error {
+					if len(value) > 0 {
+						err := json.Unmarshal([]byte(value), &metadata)
+						if err != nil {
+							return fmt.Errorf("unmarshal metadata: %w", err)
+						}
+					}
+					return nil
+				}).
 				Validate()
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
@@ -55,10 +147,29 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 			outputPaths := make([]string, len(inputPaths))
 			for i, inputPath := range inputPaths {
 				outputPaths[i] = ctx.GeneratePath(".pdf")
-
 				options := libreofficeapi.Options{
-					Landscape:  landscape,
-					PageRanges: nativePageRanges,
+					Password:                        password,
+					Landscape:                       landscape,
+					PageRanges:                      nativePageRanges,
+					ExportFormFields:                exportFormFields,
+					AllowDuplicateFieldNames:        allowDuplicateFieldNames,
+					ExportBookmarks:                 exportBookmarks,
+					ExportBookmarksToPdfDestination: exportBookmarksToPdfDestination,
+					ExportPlaceholders:              exportPlaceholders,
+					ExportNotes:                     exportNotes,
+					ExportNotesPages:                exportNotesPages,
+					ExportOnlyNotesPages:            exportOnlyNotesPages,
+					ExportNotesInMargin:             exportNotesInMargin,
+					ConvertOooTargetToPdfTarget:     convertOooTargetToPdfTarget,
+					ExportLinksRelativeFsys:         exportLinksRelativeFsys,
+					ExportHiddenSlides:              exportHiddenSlides,
+					SkipEmptyPages:                  skipEmptyPages,
+					AddOriginalDocumentAsStream:     addOriginalDocumentAsStream,
+					SinglePageSheets:                singlePageSheets,
+					LosslessImageCompression:        losslessImageCompression,
+					Quality:                         quality,
+					ReduceImageResolution:           reduceImageResolution,
+					MaxImageResolution:              maxImageResolution,
 				}
 
 				if nativePdfFormats {
@@ -77,10 +188,17 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 						)
 					}
 
-					if errors.Is(err, libreofficeapi.ErrMalformedPageRanges) {
+					if errors.Is(err, libreofficeapi.ErrUnoException) {
 						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("LibreOffice failed to process a document: possible causes include malformed page ranges '%s' (nativePageRanges), or, if a password has been provided, it may not be required. In any case, the exact cause is uncertain.", options.PageRanges)),
+						)
+					}
+
+					if errors.Is(err, libreofficeapi.ErrRuntimeException) {
+						return api.WrapError(
+							fmt.Errorf("convert to PDF: %w", err),
+							api.NewSentinelHttpError(http.StatusBadRequest, "LibreOffice failed to process a document: a password may be required, or, if one has been given, it is invalid. In any case, the exact cause is uncertain."),
 						)
 					}
 
@@ -88,9 +206,7 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				}
 			}
 
-			// So far so good, let's check if we have to merge the PDFs. Quick
-			// win: if there is only one PDF, skip this step.
-
+			// So far so good, let's check if we have to merge the PDFs.
 			if len(outputPaths) > 1 && merge {
 				outputPath := ctx.GeneratePath(".pdf")
 
@@ -99,45 +215,12 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 					return fmt.Errorf("merge PDFs: %w", err)
 				}
 
-				// Now, let's check if the client want to convert this result
-				// PDF to specific PDF formats.
-				zeroValued := gotenberg.PdfFormats{}
-				if !nativePdfFormats && pdfFormats != zeroValued {
-					convertInputPath := outputPath
-					convertOutputPath := ctx.GeneratePath(".pdf")
-
-					err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)
-					if err != nil {
-						if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
-							return api.WrapError(
-								fmt.Errorf("convert PDF: %w", err),
-								api.NewSentinelHttpError(
-									http.StatusBadRequest,
-									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),
-								),
-							)
-						}
-
-						return fmt.Errorf("convert PDF: %w", err)
-					}
-
-					// Important: the output path is now the converted file.
-					outputPath = convertOutputPath
-				}
-
-				// Last but not least, add the output path to the context so that
-				// the Uno is able to send it as a response to the client.
-
-				err = ctx.AddOutputPaths(outputPath)
-				if err != nil {
-					return fmt.Errorf("add output path: %w", err)
-				}
-
-				return nil
+				// Only one output path.
+				outputPaths = []string{outputPath}
 			}
 
-			// 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.
+			// Let's check if the client want to convert each PDF to a specific
+			// PDF format.
 			zeroValued := gotenberg.PdfFormats{}
 			if !nativePdfFormats && pdfFormats != zeroValued {
 				convertOutputPaths := make([]string, len(outputPaths))
@@ -148,28 +231,40 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 
 					err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPaths[i])
 					if err != nil {
-						if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
-							return api.WrapError(
-								fmt.Errorf("convert PDF: %w", err),
-								api.NewSentinelHttpError(
-									http.StatusBadRequest,
-									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),
-								),
-							)
-						}
-
 						return fmt.Errorf("convert PDF: %w", err)
 					}
-
 				}
 
 				// Important: the output paths are now the converted files.
 				outputPaths = convertOutputPaths
 			}
 
-			// Last but not least, add the output paths to the context so that
-			// the Uno is able to send them as a response to the client.
+			// Writes and potentially overrides metadata entries, if any.
+			if len(metadata) > 0 {
+				for _, outputPath := range outputPaths {
+					err = engine.WriteMetadata(ctx, ctx.Log(), metadata, outputPath)
+					if err != nil {
+						return fmt.Errorf("write metadata: %w", err)
+					}
+				}
+			}
 
+			if len(outputPaths) > 1 {
+				// If .zip archive, document.docx -> document.docx.pdf.
+				for i, inputPath := range inputPaths {
+					outputPath := fmt.Sprintf("%s.pdf", inputPath)
+
+					err = ctx.Rename(outputPaths[i], outputPath)
+					if err != nil {
+						return fmt.Errorf("rename output path: %w", err)
+					}
+
+					outputPaths[i] = outputPath
+				}
+			}
+
+			// 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.
 			err = ctx.AddOutputPaths(outputPaths...)
 			if err != nil {
 				return fmt.Errorf("add output paths: %w", err)

pkg/modules/libreoffice/routes_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"net/http"
+	"slices"
 	"testing"
 
 	"github.com/labstack/echo/v4"
@@ -25,6 +26,7 @@ func TestConvertRoute(t *testing.T) {
 		expectHttpError        bool
 		expectHttpStatus       int
 		expectOutputPathsCount int
+		expectOutputPaths      []string
 	}{
 		{
 			scenario: "missing at least one mandatory file",
@@ -37,6 +39,138 @@ func TestConvertRoute(t *testing.T) {
 			expectHttpStatus:       http.StatusBadRequest,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "invalid quality form field (not an integer)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"quality": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid quality form field (< 1)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"quality": {
+						"0",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid quality form field (> 100)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"quality": {
+						"101",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid maxImageResolution form field (not an integer)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"maxImageResolution": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid maxImageResolution form field (not in range)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"maxImageResolution": {
+						"1",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid metadata form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "ErrPdfFormatNotSupported (nativePdfFormats)",
 			ctx: func() *api.ContextMock {
@@ -60,14 +194,14 @@ func TestConvertRoute(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "ErrMalformedPageRanges",
+			scenario: "ErrUnoException",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
 					"document.docx": "/document.docx",
 				})
 				ctx.SetValues(map[string][]string{
-					"pdfa": {
+					"nativePageRanges": {
 						"foo",
 					},
 				})
@@ -75,7 +209,34 @@ func TestConvertRoute(t *testing.T) {
 			}(),
 			libreOffice: &libreofficeapi.ApiMock{
 				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return libreofficeapi.ErrMalformedPageRanges
+					return libreofficeapi.ErrUnoException
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "ErrRuntimeException",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"password": {
+						"invalid",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return libreofficeapi.ErrRuntimeException
 				},
 				ExtensionsMock: func() []string {
 					return []string{".docx"}
@@ -108,18 +269,16 @@ func TestConvertRoute(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "ErrPdfFormatNotSupported (single file)",
+			scenario: "PDF engine merge error",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"document.docx": "/document.docx",
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
 				})
 				ctx.SetValues(map[string][]string{
-					"pdfa": {
-						"foo",
-					},
-					"nativePdfFormats": {
-						"false",
+					"merge": {
+						"true",
 					},
 				})
 				return ctx
@@ -133,17 +292,16 @@ func TestConvertRoute(t *testing.T) {
 				},
 			},
 			engine: &gotenberg.PdfEngineMock{
-				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-					return gotenberg.ErrPdfFormatNotSupported
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return errors.New("foo")
 				},
 			},
 			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusBadRequest,
+			expectHttpError:        false,
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "PDF engine convert error (single file)",
+			scenario: "PDF engine convert error",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
@@ -177,7 +335,64 @@ func TestConvertRoute(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "cannot add output paths (single file)",
+			scenario: "PDF engine write metadata error",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "cannot rename many files",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+					"document2.doc":  "/document2.doc",
+				})
+				ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+					return errors.New("cannot rename")
+				}})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx", ".doc"}
+				},
+			},
+			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{
@@ -203,7 +418,31 @@ func TestConvertRoute(t *testing.T) {
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
-					"document.docx": "/document.docx",
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"quality": {
+						"100",
+					},
+					"maxImageResolution": {
+						"1200",
+					},
+					"merge": {
+						"true",
+					},
+					"pdfa": {
+						gotenberg.PdfA1b,
+					},
+					"pdfua": {
+						"true",
+					},
+					"nativePdfFormats": {
+						"false",
+					},
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
 				})
 				return ctx
 			}(),
@@ -215,6 +454,17 @@ func TestConvertRoute(t *testing.T) {
 					return []string{".docx"}
 				},
 			},
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return nil
+				},
+			},
 			expectError:            false,
 			expectHttpError:        false,
 			expectOutputPathsCount: 1,
@@ -226,27 +476,7 @@ func TestConvertRoute(t *testing.T) {
 				ctx.SetFiles(map[string]string{
 					"document.docx":  "/document.docx",
 					"document2.docx": "/document2.docx",
-				})
-				return ctx
-			}(),
-			libreOffice: &libreofficeapi.ApiMock{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return nil
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx"}
-				},
-			},
-			expectError:            false,
-			expectHttpError:        false,
-			expectOutputPathsCount: 2,
-		},
-		{
-			scenario: "success with non-native PDF/A & PDF/UA (single file)",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"document.docx": "/document.docx",
+					"document2.doc":  "/document2.doc",
 				})
 				ctx.SetValues(map[string][]string{
 					"pdfa": {
@@ -258,7 +488,13 @@ func TestConvertRoute(t *testing.T) {
 					"nativePdfFormats": {
 						"false",
 					},
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
 				})
+				ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+					return nil
+				}})
 				return ctx
 			}(),
 			libreOffice: &libreofficeapi.ApiMock{
@@ -266,20 +502,27 @@ func TestConvertRoute(t *testing.T) {
 					return nil
 				},
 				ExtensionsMock: func() []string {
-					return []string{".docx"}
+					return []string{".docx", ".doc"}
 				},
 			},
 			engine: &gotenberg.PdfEngineMock{
 				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 					return nil
 				},
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return nil
+				},
 			},
 			expectError:            false,
 			expectHttpError:        false,
-			expectOutputPathsCount: 1,
+			expectOutputPathsCount: 3,
+			expectOutputPaths:      []string{"/document.docx.pdf", "/document2.docx.pdf", "/document2.doc.pdf"},
 		},
 		{
-			scenario: "success with native PDF/A & PDF/UA (single file)",
+			scenario: "success with native PDF/A & PDF/UA",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
@@ -303,279 +546,6 @@ func TestConvertRoute(t *testing.T) {
 					return []string{".docx"}
 				},
 			},
-			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,
-		},
-		{
-			scenario: "merge error",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"document.docx":  "/document.docx",
-					"document2.docx": "/document2.docx",
-				})
-				ctx.SetValues(map[string][]string{
-					"merge": {
-						"true",
-					},
-				})
-				return ctx
-			}(),
-			libreOffice: &libreofficeapi.ApiMock{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return nil
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx"}
-				},
-			},
-			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,
-		},
-		{
-			scenario: "ErrPdfFormatNotSupported (merge)",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"document.docx":  "/document.docx",
-					"document2.docx": "/document2.docx",
-				})
-				ctx.SetValues(map[string][]string{
-					"merge": {
-						"true",
-					},
-					"pdfa": {
-						"foo",
-					},
-					"nativePdfFormats": {
-						"false",
-					},
-				})
-				return ctx
-			}(),
-			libreOffice: &libreofficeapi.ApiMock{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return nil
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx"}
-				},
-			},
-			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: "PDF engine convert error (merge)",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"document.docx":  "/document.docx",
-					"document2.docx": "/document2.docx",
-				})
-				ctx.SetValues(map[string][]string{
-					"merge": {
-						"true",
-					},
-					"pdfa": {
-						gotenberg.PdfA1b,
-					},
-					"nativePdfFormats": {
-						"false",
-					},
-				})
-				return ctx
-			}(),
-			libreOffice: &libreofficeapi.ApiMock{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return nil
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx"}
-				},
-			},
-			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: "cannot add output paths (merge)",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"document.docx":  "/document.docx",
-					"document2.docx": "/document2.docx",
-				})
-				ctx.SetValues(map[string][]string{
-					"merge": {
-						"true",
-					},
-				})
-				ctx.SetCancelled(true)
-				return ctx
-			}(),
-			libreOffice: &libreofficeapi.ApiMock{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return nil
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx"}
-				},
-			},
-			engine: &gotenberg.PdfEngineMock{
-				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-					return nil
-				},
-			},
-			expectError:            true,
-			expectHttpError:        false,
-			expectOutputPathsCount: 0,
-		},
-		{
-			scenario: "success (merge)",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"document.docx":  "/document.docx",
-					"document2.docx": "/document2.docx",
-				})
-				ctx.SetValues(map[string][]string{
-					"merge": {
-						"true",
-					},
-				})
-				return ctx
-			}(),
-			libreOffice: &libreofficeapi.ApiMock{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return nil
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx"}
-				},
-			},
-			engine: &gotenberg.PdfEngineMock{
-				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-					return nil
-				},
-			},
-			expectError:            false,
-			expectHttpError:        false,
-			expectOutputPathsCount: 1,
-		},
-		{
-			scenario: "success with non-native PDF/A & PDF/UA (merge)",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"document.docx":  "/document.docx",
-					"document2.docx": "/document2.docx",
-				})
-				ctx.SetValues(map[string][]string{
-					"merge": {
-						"true",
-					},
-					"pdfa": {
-						gotenberg.PdfA1b,
-					},
-					"pdfua": {
-						"true",
-					},
-					"nativePdfFormats": {
-						"false",
-					},
-				})
-				return ctx
-			}(),
-			libreOffice: &libreofficeapi.ApiMock{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return nil
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx"}
-				},
-			},
-			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,
-		},
-		{
-			scenario: "success with non-native PDF/A & PDF/UA (merge)",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"document.docx":  "/document.docx",
-					"document2.docx": "/document2.docx",
-				})
-				ctx.SetValues(map[string][]string{
-					"merge": {
-						"true",
-					},
-					"pdfa": {
-						gotenberg.PdfA1b,
-					},
-					"pdfua": {
-						"true",
-					},
-					"nativePdfFormats": {
-						"false",
-					},
-				})
-				return ctx
-			}(),
-			libreOffice: &libreofficeapi.ApiMock{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return nil
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx"}
-				},
-			},
-			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,
@@ -617,6 +587,12 @@ func TestConvertRoute(t *testing.T) {
 			if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
 				t.Errorf("expected %d output paths but got %d", tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
 			}
+
+			for _, path := range tc.expectOutputPaths {
+				if !slices.Contains(tc.ctx.OutputPaths(), path) {
+					t.Errorf("expected '%s' in output paths %v", path, tc.ctx.OutputPaths())
+				}
+			}
 		})
 	}
 }

pkg/modules/logging/logging.go

@@ -174,7 +174,7 @@ func newLogEncoder(format string) (zapcore.Encoder, error) {
 		// If interactive terminal, make output more human-readable by default.
 		// Credits: https://github.com/caddyserver/caddy/blob/v2.1.1/logging.go#L671.
 		encCfg.EncodeTime = func(ts time.Time, encoder zapcore.PrimitiveArrayEncoder) {
-			encoder.AppendString(ts.UTC().Format("2006/01/02 15:04:05.000"))
+			encoder.AppendString(ts.Local().Format("2006/01/02 15:04:05.000"))
 		}
 
 		if format == textLoggingFormat || format == autoLoggingFormat {

pkg/modules/pdfcpu/doc.go

@@ -1,6 +1,7 @@
 // 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.
+// interface using the pdfcpu command-line tool. This package allows for:
+//
+// 1. The merging of PDF files.
 //
 // See: https://github.com/pdfcpu/pdfcpu.
 package pdfcpu

pkg/modules/pdfcpu/pdfcpu.go

@@ -2,11 +2,10 @@ package pdfcpu
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"os"
 
-	pdfcpuAPI "github.com/pdfcpu/pdfcpu/pkg/api"
-	pdfcpuLog "github.com/pdfcpu/pdfcpu/pkg/log"
-	pdfcpuConfig "github.com/pdfcpu/pdfcpu/pkg/pdfcpu/model"
 	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
@@ -16,10 +15,10 @@ func init() {
 	gotenberg.MustRegisterModule(new(PdfCpu))
 }
 
-// PdfCpu abstracts the pdfcpu library and implements the [gotenberg.PdfEngine]
-// interface.
+// PdfCpu abstracts the CLI tool pdfcpu and implements the
+// [gotenberg.PdfEngine] interface.
 type PdfCpu struct {
-	conf *pdfcpuConfig.Configuration
+	binPath string
 }
 
 // Descriptor returns a [PdfCpu]'s module descriptor.
@@ -32,31 +31,64 @@ func (engine *PdfCpu) Descriptor() gotenberg.ModuleDescriptor {
 
 // Provision sets the engine properties.
 func (engine *PdfCpu) Provision(ctx *gotenberg.Context) error {
-	pdfcpuConfig.ConfigPath = "disable"
-	pdfcpuLog.DisableLoggers()
-	engine.conf = pdfcpuConfig.NewDefaultConfiguration()
+	binPath, ok := os.LookupEnv("PDFCPU_BIN_PATH")
+	if !ok {
+		return errors.New("PDFCPU_BIN_PATH environment variable is not set")
+	}
+
+	engine.binPath = binPath
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (engine *PdfCpu) Validate() error {
+	_, err := os.Stat(engine.binPath)
+	if os.IsNotExist(err) {
+		return fmt.Errorf("pdfcpu binary path does not exist: %w", err)
+	}
 
 	return nil
 }
 
 // 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)
+	var args []string
+	args = append(args, "merge", outputPath)
+	args = append(args, inputPaths...)
+
+	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
+	if err != nil {
+		return fmt.Errorf("create command: %w", err)
+	}
+
+	_, err = cmd.Exec()
 	if err == nil {
 		return nil
 	}
 
-	return fmt.Errorf("merge PDFs with PDFcpu: %w", err)
+	return fmt.Errorf("merge PDFs with pdfcpu: %w", err)
 }
 
 // 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)
+	return fmt.Errorf("convert PDF to '%+v' with pdfcpu: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// ReadMetadata is not available in this implementation.
+func (engine *PdfCpu) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+	return nil, fmt.Errorf("read PDF metadata with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// WriteMetadata is not available in this implementation.
+func (engine *PdfCpu) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+	return fmt.Errorf("write PDF metadata with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Interface guards.
 var (
 	_ gotenberg.Module      = (*PdfCpu)(nil)
 	_ gotenberg.Provisioner = (*PdfCpu)(nil)
+	_ gotenberg.Validator   = (*PdfCpu)(nil)
 	_ gotenberg.PdfEngine   = (*PdfCpu)(nil)
 )

pkg/modules/pdfcpu/pdfcpu_test.go

@@ -33,14 +33,59 @@ func TestPdfCpu_Provision(t *testing.T) {
 	}
 }
 
+func TestPdfCpu_Validate(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		binPath     string
+		expectError bool
+	}{
+		{
+			scenario:    "empty bin path",
+			binPath:     "",
+			expectError: true,
+		},
+		{
+			scenario:    "bin path does not exist",
+			binPath:     "/foo",
+			expectError: true,
+		},
+		{
+			scenario:    "validate success",
+			binPath:     os.Getenv("PDFTK_BIN_PATH"),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(PdfCpu)
+			engine.binPath = tc.binPath
+			err := engine.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 TestPdfCpu_Merge(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
+		ctx         context.Context
 		inputPaths  []string
 		expectError bool
 	}{
+		{
+			scenario:    "invalid context",
+			ctx:         nil,
+			expectError: true,
+		},
 		{
 			scenario: "invalid input path",
+			ctx:      context.TODO(),
 			inputPaths: []string{
 				"foo",
 			},
@@ -48,6 +93,7 @@ func TestPdfCpu_Merge(t *testing.T) {
 		},
 		{
 			scenario: "single file success",
+			ctx:      context.TODO(),
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 			},
@@ -55,10 +101,12 @@ func TestPdfCpu_Merge(t *testing.T) {
 		},
 		{
 			scenario: "many files success",
+			ctx:      context.TODO(),
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 				"/tests/test/testdata/pdfengines/sample2.pdf",
 			},
+			expectError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
@@ -81,7 +129,7 @@ func TestPdfCpu_Merge(t *testing.T) {
 				}
 			}()
 
-			err = engine.Merge(nil, nil, tc.inputPaths, outputDir+"/foo.pdf")
+			err = engine.Merge(tc.ctx, zap.NewNop(), tc.inputPaths, outputDir+"/foo.pdf")
 
 			if !tc.expectError && err != nil {
 				t.Fatalf("expected no error but got: %v", err)
@@ -102,3 +150,21 @@ func TestPdfCpu_Convert(t *testing.T) {
 		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
 	}
 }
+
+func TestLibreOfficePdfEngine_ReadMetadata(t *testing.T) {
+	engine := new(PdfCpu)
+	_, err := engine.ReadMetadata(context.Background(), zap.NewNop(), "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestLibreOfficePdfEngine_WriteMetadata(t *testing.T) {
+	engine := new(PdfCpu)
+	err := engine.WriteMetadata(context.Background(), zap.NewNop(), nil, "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}

pkg/modules/pdfengines/multi.go

@@ -3,6 +3,7 @@ package pdfengines
 import (
 	"context"
 	"fmt"
+	"sync"
 
 	"go.uber.org/multierr"
 	"go.uber.org/zap"
@@ -11,12 +12,23 @@ import (
 )
 
 type multiPdfEngines struct {
-	engines []gotenberg.PdfEngine
+	mergeEngines       []gotenberg.PdfEngine
+	convertEngines     []gotenberg.PdfEngine
+	readMedataEngines  []gotenberg.PdfEngine
+	writeMedataEngines []gotenberg.PdfEngine
 }
 
-func newMultiPdfEngines(engines ...gotenberg.PdfEngine) *multiPdfEngines {
+func newMultiPdfEngines(
+	mergeEngines,
+	convertEngines,
+	readMetadataEngines,
+	writeMedataEngines []gotenberg.PdfEngine,
+) *multiPdfEngines {
 	return &multiPdfEngines{
-		engines: engines,
+		mergeEngines:       mergeEngines,
+		convertEngines:     convertEngines,
+		readMedataEngines:  readMetadataEngines,
+		writeMedataEngines: writeMedataEngines,
 	}
 }
 
@@ -26,7 +38,7 @@ func (multi *multiPdfEngines) Merge(ctx context.Context, logger *zap.Logger, inp
 	var err error
 	errChan := make(chan error, 1)
 
-	for _, engine := range multi.engines {
+	for _, engine := range multi.mergeEngines {
 		go func(engine gotenberg.PdfEngine) {
 			errChan <- engine.Merge(ctx, logger, inputPaths, outputPath)
 		}(engine)
@@ -51,7 +63,7 @@ func (multi *multiPdfEngines) Convert(ctx context.Context, logger *zap.Logger, f
 	var err error
 	errChan := make(chan error, 1)
 
-	for _, engine := range multi.engines {
+	for _, engine := range multi.convertEngines {
 		go func(engine gotenberg.PdfEngine) {
 			errChan <- engine.Convert(ctx, logger, formats, inputPath, outputPath)
 		}(engine)
@@ -70,6 +82,65 @@ func (multi *multiPdfEngines) Convert(ctx context.Context, logger *zap.Logger, f
 	return fmt.Errorf("convert PDF to '%+v' with multi PDF engines: %w", formats, err)
 }
 
+type readMetadataResult struct {
+	metadata map[string]interface{}
+	err      error
+}
+
+func (multi *multiPdfEngines) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+	var err error
+	var mu sync.Mutex // to safely append errors.
+
+	resultChan := make(chan readMetadataResult, len(multi.readMedataEngines))
+
+	for _, engine := range multi.readMedataEngines {
+		go func(engine gotenberg.PdfEngine) {
+			metadata, err := engine.ReadMetadata(ctx, logger, inputPath)
+			resultChan <- readMetadataResult{metadata: metadata, err: err}
+		}(engine)
+	}
+
+	for range multi.readMedataEngines {
+		select {
+		case result := <-resultChan:
+			if result.err != nil {
+				mu.Lock()
+				err = multierr.Append(err, result.err)
+				mu.Unlock()
+			} else {
+				return result.metadata, nil
+			}
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		}
+	}
+
+	return nil, fmt.Errorf("read PDF metadata with multi PDF engines: %w", err)
+}
+
+func (multi *multiPdfEngines) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+	var err error
+	errChan := make(chan error, 1)
+
+	for _, engine := range multi.writeMedataEngines {
+		go func(engine gotenberg.PdfEngine) {
+			errChan <- engine.WriteMetadata(ctx, logger, metadata, inputPath)
+		}(engine)
+
+		select {
+		case writeMetadataErr := <-errChan:
+			errored := multierr.AppendInto(&err, writeMetadataErr)
+			if !errored {
+				return nil
+			}
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+
+	return fmt.Errorf("write PDF metadata with multi PDF engines: %w", err)
+}
+
 // Interface guards.
 var (
 	_ gotenberg.PdfEngine = (*multiPdfEngines)(nil)

pkg/modules/pdfengines/multi_test.go

@@ -20,11 +20,16 @@ func TestMultiPdfEngines_Merge(t *testing.T) {
 		{
 			scenario: "nominal behavior",
 			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return nil
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return nil
+						},
 					},
 				},
+				nil,
+				nil,
+				nil,
 			),
 			ctx:         context.Background(),
 			expectError: false,
@@ -32,16 +37,21 @@ func TestMultiPdfEngines_Merge(t *testing.T) {
 		{
 			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")
-					},
-				},
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return nil
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return nil
+						},
 					},
 				},
+				nil,
+				nil,
+				nil,
 			),
 			ctx:         context.Background(),
 			expectError: false,
@@ -49,16 +59,21 @@ func TestMultiPdfEngines_Merge(t *testing.T) {
 		{
 			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")
-					},
-				},
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return errors.New("foo")
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return errors.New("foo")
+						},
 					},
 				},
+				nil,
+				nil,
+				nil,
 			),
 			ctx:         context.Background(),
 			expectError: true,
@@ -66,11 +81,16 @@ func TestMultiPdfEngines_Merge(t *testing.T) {
 		{
 			scenario: "context expired",
 			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return nil
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return nil
+						},
 					},
 				},
+				nil,
+				nil,
+				nil,
 			),
 			ctx: func() context.Context {
 				ctx, cancel := context.WithCancel(context.Background())
@@ -105,43 +125,58 @@ func TestMultiPdfEngines_Convert(t *testing.T) {
 		{
 			scenario: "nominal behavior",
 			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return nil
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return nil
+						},
 					},
 				},
+				nil,
+				nil,
 			),
 			ctx: context.Background(),
 		},
 		{
 			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")
-					},
-				},
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return nil
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return nil
+						},
 					},
 				},
+				nil,
+				nil,
 			),
 			ctx: context.Background(),
 		},
 		{
 			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")
-					},
-				},
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return errors.New("foo")
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return errors.New("foo")
+						},
 					},
 				},
+				nil,
+				nil,
 			),
 			ctx:         context.Background(),
 			expectError: true,
@@ -149,11 +184,16 @@ func TestMultiPdfEngines_Convert(t *testing.T) {
 		{
 			scenario: "context expired",
 			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return nil
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return nil
+						},
 					},
 				},
+				nil,
+				nil,
 			),
 			ctx: func() context.Context {
 				ctx, cancel := context.WithCancel(context.Background())
@@ -177,3 +217,209 @@ func TestMultiPdfEngines_Convert(t *testing.T) {
 		})
 	}
 }
+
+func TestMultiPdfEngines_ReadMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: newMultiPdfEngines(
+				nil,
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return make(map[string]interface{}), nil
+						},
+					},
+				},
+				nil,
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: newMultiPdfEngines(
+				nil,
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return make(map[string]interface{}), nil
+						},
+					},
+				},
+				nil,
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: newMultiPdfEngines(
+				nil,
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return nil, errors.New("foo")
+						},
+					},
+				},
+				nil,
+			),
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: newMultiPdfEngines(
+				nil,
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return make(map[string]interface{}), nil
+						},
+					},
+				},
+				nil,
+			),
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			_, err := tc.engine.ReadMetadata(tc.ctx, zap.NewNop(), "")
+
+			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 TestMultiPdfEngines_WriteMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: newMultiPdfEngines(
+				nil,
+				nil,
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return nil
+						},
+					},
+				},
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: newMultiPdfEngines(
+				nil,
+				nil,
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return nil
+						},
+					},
+				},
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: newMultiPdfEngines(
+				nil,
+				nil,
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+				},
+			),
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: newMultiPdfEngines(
+				nil,
+				nil,
+				nil,
+				[]gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return nil
+						},
+					},
+				},
+			),
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.WriteMetadata(tc.ctx, zap.NewNop(), nil, "")
+
+			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")
+			}
+		})
+	}
+}

pkg/modules/pdfengines/pdfengines.go

@@ -27,9 +27,12 @@ func init() {
 // the [api.Router] interface to expose relevant PDF processing routes if
 // enabled.
 type PdfEngines struct {
-	names         []string
-	engines       []gotenberg.PdfEngine
-	disableRoutes bool
+	mergeNames        []string
+	convertNames      []string
+	readMetadataNames []string
+	writeMedataNames  []string
+	engines           []gotenberg.PdfEngine
+	disableRoutes     bool
 }
 
 // Descriptor returns a PdfEngines' module descriptor.
@@ -38,9 +41,18 @@ func (mod *PdfEngines) Descriptor() 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 and their order - all by default")
+			fs.StringSlice("pdfengines-merge-engines", []string{"qpdf", "pdfcpu", "pdftk"}, "Set the PDF engines and their order for the merge feature - empty means all")
+			fs.StringSlice("pdfengines-convert-engines", []string{"libreoffice-pdfengine"}, "Set the PDF engines and their order for the convert feature - empty means all")
+			fs.StringSlice("pdfengines-read-metadata-engines", []string{"exiftool"}, "Set the PDF engines and their order for the read metadata feature - empty means all")
+			fs.StringSlice("pdfengines-write-metadata-engines", []string{"exiftool"}, "Set the PDF engines and their order for the write metadata feature - empty means all")
 			fs.Bool("pdfengines-disable-routes", false, "Disable the routes")
 
+			fs.StringSlice("pdfengines-engines", make([]string, 0), "Set the default PDF engines and their default order - all by default")
+			err := fs.MarkDeprecated("pdfengines-engines", "use other flags for a more granular selection of PDF engines per method")
+			if err != nil {
+				panic(err)
+			}
+
 			return fs
 		}(),
 		New: func() gotenberg.Module { return new(PdfEngines) },
@@ -51,7 +63,10 @@ func (mod *PdfEngines) Descriptor() gotenberg.ModuleDescriptor {
 // selected by the user thanks to the "engines" flag.
 func (mod *PdfEngines) Provision(ctx *gotenberg.Context) error {
 	flags := ctx.ParsedFlags()
-	names := flags.MustStringSlice("pdfengines-engines")
+	mergeNames := flags.MustStringSlice("pdfengines-merge-engines")
+	convertNames := flags.MustStringSlice("pdfengines-convert-engines")
+	readMetadataNames := flags.MustStringSlice("pdfengines-read-metadata-engines")
+	writeMetadataNames := flags.MustStringSlice("pdfengines-write-metadata-engines")
 	mod.disableRoutes = flags.MustBool("pdfengines-disable-routes")
 
 	engines, err := ctx.Modules(new(gotenberg.PdfEngine))
@@ -65,26 +80,37 @@ func (mod *PdfEngines) Provision(ctx *gotenberg.Context) error {
 		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
+	defaultNames := make([]string, len(mod.engines))
+	for i, engine := range mod.engines {
+		defaultNames[i] = engine.(gotenberg.Module).Descriptor().ID
 	}
 
-	// No selection from user, use all PDF engines available.
-	mod.names = make([]string, len(mod.engines))
+	// Example in case of deprecated module name.
+	//for i, name := range defaultNames {
+	//	if name == "unoconv-pdfengine" || name == "uno-pdfengine" {
+	//		logger.Warn(fmt.Sprintf("%s is deprecated; prefer libreoffice-pdfengine instead", name))
+	//		mod.defaultNames[i] = "libreoffice-pdfengine"
+	//	}
+	//}
 
-	for i, engine := range mod.engines {
-		mod.names[i] = engine.(gotenberg.Module).Descriptor().ID
+	mod.mergeNames = defaultNames
+	if len(mergeNames) > 0 {
+		mod.mergeNames = mergeNames
+	}
+
+	mod.convertNames = defaultNames
+	if len(convertNames) > 0 {
+		mod.convertNames = convertNames
+	}
+
+	mod.readMetadataNames = defaultNames
+	if len(readMetadataNames) > 0 {
+		mod.readMetadataNames = readMetadataNames
+	}
+
+	mod.writeMedataNames = defaultNames
+	if len(writeMetadataNames) > 0 {
+		mod.writeMedataNames = writeMetadataNames
 	}
 
 	return nil
@@ -105,22 +131,40 @@ func (mod *PdfEngines) Validate() error {
 	}
 
 	nonExistingEngines := make([]string, 0)
+	findNonExistingEngines := func(names []string) {
+		for _, name := range names {
+			engineExists := false
 
-	for _, name := range mod.names {
-		engineExists := false
+			for _, engine := range mod.engines {
+				if name == engine.(gotenberg.Module).Descriptor().ID {
+					engineExists = true
+					break
+				}
+			}
 
-		for _, engine := range mod.engines {
-			if name == engine.(gotenberg.Module).Descriptor().ID {
-				engineExists = true
-				break
+			if engineExists {
+				continue
+			}
+
+			alreadyInSlice := false
+			for _, engine := range nonExistingEngines {
+				if engine == name {
+					alreadyInSlice = true
+					break
+				}
+			}
+
+			if !alreadyInSlice {
+				nonExistingEngines = append(nonExistingEngines, name)
 			}
 		}
-
-		if !engineExists {
-			nonExistingEngines = append(nonExistingEngines, name)
-		}
 	}
 
+	findNonExistingEngines(mod.mergeNames)
+	findNonExistingEngines(mod.convertNames)
+	findNonExistingEngines(mod.readMetadataNames)
+	findNonExistingEngines(mod.writeMedataNames)
+
 	if len(nonExistingEngines) == 0 {
 		return nil
 	}
@@ -132,24 +176,35 @@ func (mod *PdfEngines) Validate() error {
 // modules.
 func (mod *PdfEngines) SystemMessages() []string {
 	return []string{
-		strings.Join(mod.names[:], " "),
+		fmt.Sprintf("merge engines - %s", strings.Join(mod.mergeNames[:], " ")),
+		fmt.Sprintf("convert engines - %s", strings.Join(mod.convertNames[:], " ")),
+		fmt.Sprintf("read metadata engines - %s", strings.Join(mod.readMetadataNames[:], " ")),
+		fmt.Sprintf("write medata engines - %s", strings.Join(mod.writeMedataNames[:], " ")),
 	}
 }
 
 // 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
+	engines := func(names []string) []gotenberg.PdfEngine {
+		list := make([]gotenberg.PdfEngine, len(names))
+		for i, name := range names {
+			for _, engine := range mod.engines {
+				if name == engine.(gotenberg.Module).Descriptor().ID {
+					list[i] = engine
+					break
+				}
 			}
 		}
+
+		return list
 	}
 
-	return newMultiPdfEngines(engines...), nil
+	return newMultiPdfEngines(
+		engines(mod.mergeNames),
+		engines(mod.convertNames),
+		engines(mod.readMetadataNames),
+		engines(mod.writeMedataNames),
+	), nil
 }
 
 // Routes returns the HTTP routes.
@@ -168,6 +223,8 @@ func (mod *PdfEngines) Routes() ([]api.Route, error) {
 	return []api.Route{
 		mergeRoute(engine),
 		convertRoute(engine),
+		readMetadataRoute(engine),
+		writeMetadataRoute(engine),
 	}, nil
 }
 

pkg/modules/pdfengines/pdfengines_test.go

@@ -2,6 +2,7 @@ package pdfengines
 
 import (
 	"errors"
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -22,10 +23,13 @@ func TestPdfEngines_Descriptor(t *testing.T) {
 
 func TestPdfEngines_Provision(t *testing.T) {
 	for _, tc := range []struct {
-		scenario           string
-		ctx                *gotenberg.Context
-		expectedPdfEngines []string
-		expectError        bool
+		scenario                        string
+		ctx                             *gotenberg.Context
+		expectedMergePdfEngines         []string
+		expectedConvertPdfEngines       []string
+		expectedReadMetadataPdfEngines  []string
+		expectedWriteMetadataPdfEngines []string
+		expectError                     bool
 	}{
 		{
 			scenario: "no selection from user",
@@ -61,8 +65,11 @@ func TestPdfEngines_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectedPdfEngines: []string{"bar"},
-			expectError:        false,
+			expectedMergePdfEngines:         []string{"qpdf", "pdfcpu", "pdftk"},
+			expectedConvertPdfEngines:       []string{"libreoffice-pdfengine"},
+			expectedReadMetadataPdfEngines:  []string{"exiftool"},
+			expectedWriteMetadataPdfEngines: []string{"exiftool"},
+			expectError:                     false,
 		},
 		{
 			scenario: "selection from user",
@@ -100,7 +107,7 @@ func TestPdfEngines_Provision(t *testing.T) {
 				}
 
 				fs := new(PdfEngines).Descriptor().FlagSet
-				err := fs.Parse([]string{"--pdfengines-engines=b", "--pdfengines-engines=a"})
+				err := fs.Parse([]string{"--pdfengines-merge-engines=b", "--pdfengines-convert-engines=b", "--pdfengines-read-metadata-engines=a", "--pdfengines-write-metadata-engines=a"})
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -116,8 +123,12 @@ func TestPdfEngines_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectedPdfEngines: []string{"b", "a"},
-			expectError:        false,
+
+			expectedMergePdfEngines:         []string{"b"},
+			expectedConvertPdfEngines:       []string{"b"},
+			expectedReadMetadataPdfEngines:  []string{"a"},
+			expectedWriteMetadataPdfEngines: []string{"a"},
+			expectError:                     false,
 		},
 		{
 			scenario: "no valid PDF engine",
@@ -167,13 +178,43 @@ func TestPdfEngines_Provision(t *testing.T) {
 				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))
+			if len(tc.expectedMergePdfEngines) != len(mod.mergeNames) {
+				t.Fatalf("expected %d merge names but got %d", len(tc.expectedMergePdfEngines), len(mod.mergeNames))
 			}
 
-			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])
+			if len(tc.expectedConvertPdfEngines) != len(mod.convertNames) {
+				t.Fatalf("expected %d convert names but got %d", len(tc.expectedConvertPdfEngines), len(mod.convertNames))
+			}
+
+			if len(tc.expectedReadMetadataPdfEngines) != len(mod.readMetadataNames) {
+				t.Fatalf("expected %d read metadata names but got %d", len(tc.expectedReadMetadataPdfEngines), len(mod.readMetadataNames))
+			}
+
+			if len(tc.expectedWriteMetadataPdfEngines) != len(mod.writeMedataNames) {
+				t.Fatalf("expected %d write metadata names but got %d", len(tc.expectedWriteMetadataPdfEngines), len(mod.writeMedataNames))
+			}
+
+			for index, name := range mod.mergeNames {
+				if name != tc.expectedMergePdfEngines[index] {
+					t.Fatalf("expected merge name at index %d to be %s, but got: %s", index, name, tc.expectedMergePdfEngines[index])
+				}
+			}
+
+			for index, name := range mod.convertNames {
+				if name != tc.expectedConvertPdfEngines[index] {
+					t.Fatalf("expected convert name at index %d to be %s, but got: %s", index, name, tc.expectedConvertPdfEngines[index])
+				}
+			}
+
+			for index, name := range mod.readMetadataNames {
+				if name != tc.expectedReadMetadataPdfEngines[index] {
+					t.Fatalf("expected read metadata name at index %d to be %s, but got: %s", index, name, tc.expectedReadMetadataPdfEngines[index])
+				}
+			}
+
+			for index, name := range mod.writeMedataNames {
+				if name != tc.expectedWriteMetadataPdfEngines[index] {
+					t.Fatalf("expected write metadat name at index %d to be %s, but got: %s", index, name, tc.expectedWriteMetadataPdfEngines[index])
 				}
 			}
 		})
@@ -239,8 +280,11 @@ func TestPdfEngines_Validate(t *testing.T) {
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			mod := PdfEngines{
-				names:   tc.names,
-				engines: tc.engines,
+				mergeNames:        tc.names,
+				convertNames:      tc.names,
+				readMetadataNames: tc.names,
+				writeMedataNames:  tc.names,
+				engines:           tc.engines,
 			}
 
 			err := mod.Validate()
@@ -258,22 +302,36 @@ func TestPdfEngines_Validate(t *testing.T) {
 
 func TestPdfEngines_SystemMessages(t *testing.T) {
 	mod := new(PdfEngines)
-	mod.names = []string{"foo", "bar"}
+	mod.mergeNames = []string{"foo", "bar"}
+	mod.convertNames = []string{"foo", "bar"}
+	mod.readMetadataNames = []string{"foo", "bar"}
+	mod.writeMedataNames = []string{"foo", "bar"}
 
 	messages := mod.SystemMessages()
-	if len(messages) != 1 {
+	if len(messages) != 4 {
 		t.Errorf("expected one and only one message, but got %d", len(messages))
 	}
 
-	expect := strings.Join(mod.names[:], " ")
-	if messages[0] != expect {
-		t.Errorf("expected message '%s', but got '%s'", expect, messages[0])
+	expect := []string{
+		fmt.Sprintf("merge engines - %s", strings.Join(mod.mergeNames[:], " ")),
+		fmt.Sprintf("convert engines - %s", strings.Join(mod.convertNames[:], " ")),
+		fmt.Sprintf("read metadata engines - %s", strings.Join(mod.readMetadataNames[:], " ")),
+		fmt.Sprintf("write medata engines - %s", strings.Join(mod.writeMedataNames[:], " ")),
+	}
+
+	for i, message := range messages {
+		if message != expect[i] {
+			t.Errorf("expected message at index %d to be %s, but got %s", i, message, expect[i])
+		}
 	}
 }
 
 func TestPdfEngines_PdfEngine(t *testing.T) {
 	mod := PdfEngines{
-		names: []string{"foo", "bar"},
+		mergeNames:        []string{"foo", "bar"},
+		convertNames:      []string{"foo", "bar"},
+		readMetadataNames: []string{"foo", "bar"},
+		writeMedataNames:  []string{"foo", "bar"},
 		engines: func() []gotenberg.PdfEngine {
 			engine1 := &struct {
 				gotenberg.ModuleMock
@@ -312,7 +370,7 @@ func TestPdfEngines_Routes(t *testing.T) {
 	}{
 		{
 			scenario:      "routes not disabled",
-			expectRoutes:  2,
+			expectRoutes:  4,
 			disableRoutes: false,
 		},
 		{

pkg/modules/pdfengines/routes.go

@@ -1,9 +1,11 @@
 package pdfengines
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
+	"path/filepath"
 
 	"github.com/labstack/echo/v4"
 
@@ -25,12 +27,22 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 				inputPaths []string
 				pdfa       string
 				pdfua      bool
+				metadata   map[string]interface{}
 			)
 
 			err := ctx.FormData().
 				MandatoryPaths([]string{".pdf"}, &inputPaths).
 				String("pdfa", &pdfa, "").
 				Bool("pdfua", &pdfua, false).
+				Custom("metadata", func(value string) error {
+					if len(value) > 0 {
+						err := json.Unmarshal([]byte(value), &metadata)
+						if err != nil {
+							return fmt.Errorf("unmarshal metadata: %w", err)
+						}
+					}
+					return nil
+				}).
 				Validate()
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
@@ -42,7 +54,6 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 			}
 
 			// Alright, let's merge the PDFs.
-
 			outputPath := ctx.GeneratePath(".pdf")
 
 			err = engine.Merge(ctx, ctx.Log(), inputPaths, outputPath)
@@ -59,18 +70,7 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 				convertOutputPath := ctx.GeneratePath(".pdf")
 
 				err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)
-
 				if err != nil {
-					if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
-						return api.WrapError(
-							fmt.Errorf("convert PDF: %w", err),
-							api.NewSentinelHttpError(
-								http.StatusBadRequest,
-								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),
-							),
-						)
-					}
-
 					return fmt.Errorf("convert PDF: %w", err)
 				}
 
@@ -78,9 +78,16 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 				outputPath = convertOutputPath
 			}
 
+			// Writes and potentially overrides metadata entries, if any.
+			if len(metadata) > 0 {
+				err = engine.WriteMetadata(ctx, ctx.Log(), metadata, outputPath)
+				if err != nil {
+					return fmt.Errorf("write metadata: %w", err)
+				}
+			}
+
 			// 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.
-
 			err = ctx.AddOutputPaths(outputPath)
 			if err != nil {
 				return fmt.Errorf("add output path: %w", err)
@@ -91,8 +98,8 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 	}
 }
 
-// convertRoute returns an [api.Route] which can convert a PDF to a specific
-// PDF format.
+// convertRoute returns an [api.Route] which can convert PDFs to a specific ODF
+// format.
 func convertRoute(engine gotenberg.PdfEngine) api.Route {
 	return api.Route{
 		Method:      http.MethodPost,
@@ -135,30 +142,27 @@ func convertRoute(engine gotenberg.PdfEngine) api.Route {
 
 			// 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(), pdfFormats, inputPath, outputPaths[i])
-
 				if err != nil {
-					if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
-						return api.WrapError(
-							fmt.Errorf("convert PDF: %w", err),
-							api.NewSentinelHttpError(
-								http.StatusBadRequest,
-								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),
-							),
-						)
+					return fmt.Errorf("convert PDF: %w", err)
+				}
+
+				if len(outputPaths) > 1 {
+					// If .zip archive, keep the original filename.
+					err = ctx.Rename(outputPaths[i], inputPath)
+					if err != nil {
+						return fmt.Errorf("rename output path: %w", err)
 					}
 
-					return fmt.Errorf("convert PDF: %w", err)
+					outputPaths[i] = inputPath
 				}
 			}
 
 			// 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.
-
 			err = ctx.AddOutputPaths(outputPaths...)
 			if err != nil {
 				return fmt.Errorf("add output paths: %w", err)
@@ -168,3 +172,98 @@ func convertRoute(engine gotenberg.PdfEngine) api.Route {
 		},
 	}
 }
+
+// readMetadataRoute returns an [api.Route] which returns the metadata of PDFs.
+func readMetadataRoute(engine gotenberg.PdfEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/pdfengines/metadata/read",
+		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
+
+			err := ctx.FormData().
+				MandatoryPaths([]string{".pdf"}, &inputPaths).
+				Validate()
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			// Alright, let's read the metadata.
+			res := make(map[string]map[string]interface{}, len(inputPaths))
+			for _, inputPath := range inputPaths {
+				metadata, err := engine.ReadMetadata(ctx, ctx.Log(), inputPath)
+				if err != nil {
+					return fmt.Errorf("read metadata: %w", err)
+				}
+
+				res[filepath.Base(inputPath)] = metadata
+			}
+
+			err = c.JSON(http.StatusOK, res)
+			if err != nil {
+				return fmt.Errorf("return JSON response: %w", err)
+			}
+
+			return api.ErrNoOutputFile
+		},
+	}
+}
+
+// writeMetadataRoute returns an [api.Route] which can write metadata into
+// PDFs.
+func writeMetadataRoute(engine gotenberg.PdfEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/pdfengines/metadata/write",
+		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
+				metadata   map[string]interface{}
+			)
+
+			err := ctx.FormData().
+				MandatoryPaths([]string{".pdf"}, &inputPaths).
+				MandatoryCustom("metadata", func(value string) error {
+					if len(value) > 0 {
+						err := json.Unmarshal([]byte(value), &metadata)
+						if err != nil {
+							return fmt.Errorf("unmarshal metadata: %w", err)
+						}
+					}
+					if len(metadata) == 0 {
+						return errors.New("no metadata")
+					}
+					return nil
+				}).
+				Validate()
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			// Alright, let's convert the PDFs.
+			for _, inputPath := range inputPaths {
+				err = engine.WriteMetadata(ctx, ctx.Log(), metadata, inputPath)
+				if err != nil {
+					return fmt.Errorf("write metadata: %w", err)
+				}
+			}
+
+			// 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.
+			err = ctx.AddOutputPaths(inputPaths...)
+			if err != nil {
+				return fmt.Errorf("add output paths: %w", err)
+			}
+
+			return nil
+		},
+	}
+}

pkg/modules/pdfengines/routes_test.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"errors"
 	"net/http"
+	"net/http/httptest"
+	"slices"
+	"strings"
 	"testing"
 
 	"github.com/labstack/echo/v4"
@@ -32,7 +35,27 @@ func TestMergeHandler(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "error from PDF engine",
+			scenario: "invalid metadata form field",
+			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{
+					"metadata": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "PDF engine merge error",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
@@ -50,6 +73,60 @@ func TestMergeHandler(t *testing.T) {
 			expectHttpError:        false,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "PDF engine convert error",
+			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: "PDF engine write metadata error",
+			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{
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "cannot add output paths",
 			ctx: func() *api.ContextMock {
@@ -72,25 +149,6 @@ func TestMergeHandler(t *testing.T) {
 		},
 		{
 			scenario: "success",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"file.pdf":  "/file.pdf",
-					"file2.pdf": "/file2.pdf",
-				})
-				return ctx
-			}(),
-			engine: &gotenberg.PdfEngineMock{
-				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-					return nil
-				},
-			},
-			expectError:            false,
-			expectHttpError:        false,
-			expectOutputPathsCount: 1,
-		},
-		{
-			scenario: "ErrPdfFormatNotSupported",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
@@ -101,6 +159,9 @@ func TestMergeHandler(t *testing.T) {
 					"pdfa": {
 						gotenberg.PdfA1b,
 					},
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
 				})
 				return ctx
 			}(),
@@ -109,64 +170,9 @@ func TestMergeHandler(t *testing.T) {
 					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 {
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
 					return nil
 				},
 			},
@@ -224,6 +230,7 @@ func TestConvertHandler(t *testing.T) {
 		expectHttpError        bool
 		expectHttpStatus       int
 		expectOutputPathsCount int
+		expectOutputPaths      []string
 	}{
 		{
 			scenario:               "missing at least one mandatory file",
@@ -247,30 +254,6 @@ func TestConvertHandler(t *testing.T) {
 			expectHttpStatus:       http.StatusBadRequest,
 			expectOutputPathsCount: 0,
 		},
-		{
-			scenario: "ErrPdfFormatNotSupported",
-			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 gotenberg.ErrPdfFormatNotSupported
-				},
-			},
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusBadRequest,
-			expectOutputPathsCount: 0,
-		},
 		{
 			scenario: "error from PDF engine",
 			ctx: func() *api.ContextMock {
@@ -344,6 +327,36 @@ func TestConvertHandler(t *testing.T) {
 			expectHttpError:        false,
 			expectOutputPathsCount: 1,
 		},
+		{
+			scenario: "cannot rename many files",
+			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",
+					},
+				})
+				ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+					return errors.New("cannot rename")
+				}})
+				return ctx
+			}(),
+			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,
+		},
 		{
 			scenario: "success with PDF/A & PDF/UA form fields (many files)",
 			ctx: func() *api.ContextMock {
@@ -360,6 +373,9 @@ func TestConvertHandler(t *testing.T) {
 						"true",
 					},
 				})
+				ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+					return nil
+				}})
 				return ctx
 			}(),
 			engine: &gotenberg.PdfEngineMock{
@@ -370,6 +386,7 @@ func TestConvertHandler(t *testing.T) {
 			expectError:            false,
 			expectHttpError:        false,
 			expectOutputPathsCount: 2,
+			expectOutputPaths:      []string{"/file.pdf", "/file2.pdf"},
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
@@ -408,6 +425,304 @@ func TestConvertHandler(t *testing.T) {
 			if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
 				t.Errorf("expected %d output paths but got %d", tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
 			}
+
+			for _, path := range tc.expectOutputPaths {
+				if !slices.Contains(tc.ctx.OutputPaths(), path) {
+					t.Errorf("expected '%s' in output paths %v", path, tc.ctx.OutputPaths())
+				}
+			}
+		})
+	}
+}
+
+func TestReadMetadataHandler(t *testing.T) {
+	for _, tc := range []struct {
+		scenario         string
+		ctx              *api.ContextMock
+		engine           gotenberg.PdfEngine
+		expectError      bool
+		expectedError    error
+		expectHttpError  bool
+		expectHttpStatus int
+		expectedJson     string
+	}{
+		{
+			scenario:         "missing at least one mandatory file",
+			ctx:              &api.ContextMock{Context: new(api.Context)},
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			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",
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+					return nil, errors.New("foo")
+				},
+			},
+			expectError:     true,
+			expectHttpError: false,
+		},
+		{
+			scenario: "success",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+					return map[string]interface{}{
+						"foo": "bar",
+						"bar": "foo",
+					}, nil
+				},
+			},
+			expectError:     true,
+			expectedError:   api.ErrNoOutputFile,
+			expectHttpError: false,
+			expectedJson:    `{"file.pdf":{"bar":"foo","foo":"bar"}}`,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.SetLogger(zap.NewNop())
+			req := httptest.NewRequest(http.MethodPost, "/forms/pdfengines/metadata/read", nil)
+			rec := httptest.NewRecorder()
+			c := echo.New().NewContext(req, rec)
+			c.Set("context", tc.ctx.Context)
+
+			err := readMetadataRoute(tc.engine).Handler(c)
+
+			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 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 tc.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+
+			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.expectedJson != "" && tc.expectedJson != strings.TrimSpace(rec.Body.String()) {
+				t.Errorf("expected '%s' as HTTP response but got '%s'", tc.expectedJson, strings.TrimSpace(rec.Body.String()))
+			}
+		})
+	}
+}
+
+func TestWriteMetadataHandler(t *testing.T) {
+	for _, tc := range []struct {
+		scenario               string
+		ctx                    *api.ContextMock
+		engine                 gotenberg.PdfEngine
+		expectError            bool
+		expectHttpError        bool
+		expectHttpStatus       int
+		expectOutputPathsCount int
+		expectOutputPaths      []string
+	}{
+		{
+			scenario:               "missing at least one mandatory file",
+			ctx:                    &api.ContextMock{Context: new(api.Context)},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "no metadata form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				return ctx
+			}(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid metadata form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "no metadata",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"{}",
+					},
+				})
+				return ctx
+			}(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			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{
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath 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{
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				ctx.SetCancelled(true)
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return nil
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "success",
+			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{
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 1,
+		},
+	} {
+		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)
+
+			err := writeMetadataRoute(tc.engine).Handler(c)
+
+			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 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()))
+			}
+
+			for _, path := range tc.expectOutputPaths {
+				if !slices.Contains(tc.ctx.OutputPaths(), path) {
+					t.Errorf("expected '%s' in output paths %v", path, tc.ctx.OutputPaths())
+				}
+			}
 		})
 	}
 }

pkg/modules/pdftk/doc.go

@@ -1,8 +1,10 @@
 // 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.
+// interface using the PDFtk command-line tool. This package allows for:
+//
+// 1. The merging of PDF files.
+//
+// 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

pkg/modules/pdftk/pdftk.go

@@ -45,7 +45,7 @@ func (engine *PdfTk) Provision(ctx *gotenberg.Context) 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
@@ -75,6 +75,16 @@ func (engine *PdfTk) Convert(ctx context.Context, logger *zap.Logger, formats go
 	return fmt.Errorf("convert PDF to '%+v' with PDFtk: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
+// ReadMetadata is not available in this implementation.
+func (engine *PdfTk) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+	return nil, fmt.Errorf("read PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// WriteMetadata is not available in this implementation.
+func (engine *PdfTk) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+	return fmt.Errorf("write PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
 // Interface guards.
 var (
 	_ gotenberg.Module      = (*PdfTk)(nil)

pkg/modules/pdftk/pdftk_test.go

@@ -97,6 +97,7 @@ func TestPdfTk_Merge(t *testing.T) {
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 			},
+			expectError: false,
 		},
 		{
 			scenario: "many files success",
@@ -105,6 +106,7 @@ func TestPdfTk_Merge(t *testing.T) {
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 				"/tests/test/testdata/pdfengines/sample2.pdf",
 			},
+			expectError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
@@ -148,3 +150,21 @@ func TestPdfTk_Convert(t *testing.T) {
 		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
 	}
 }
+
+func TestLibreOfficePdfEngine_ReadMetadata(t *testing.T) {
+	engine := new(PdfTk)
+	_, err := engine.ReadMetadata(context.Background(), zap.NewNop(), "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestLibreOfficePdfEngine_WriteMetadata(t *testing.T) {
+	engine := new(PdfTk)
+	err := engine.WriteMetadata(context.Background(), zap.NewNop(), nil, "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}

pkg/modules/qpdf/doc.go

@@ -1,8 +1,10 @@
 // Package qpdf provides an implementation of the gotenberg.PdfEngine
-// interface using the QPDF 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 QPDF binary must be specified using the
-// QPDK_BIN_PATH environment variable.
+// interface using the QPDF command-line tool. This package allows for:
+//
+// 1. The merging of PDF files.
+//
+// The path to the QPDF binary must be specified using the QPDK_BIN_PATH
+// environment variable.
 //
 // See: https://github.com/qpdf/qpdf.
 package qpdf

pkg/modules/qpdf/qpdf.go

@@ -77,6 +77,16 @@ func (engine *QPdf) Convert(ctx context.Context, logger *zap.Logger, formats got
 	return fmt.Errorf("convert PDF to '%+v' with QPDF: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
+// ReadMetadata is not available in this implementation.
+func (engine *QPdf) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+	return nil, fmt.Errorf("read PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// WriteMetadata is not available in this implementation.
+func (engine *QPdf) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+	return fmt.Errorf("write PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
 var (
 	_ gotenberg.Module      = (*QPdf)(nil)
 	_ gotenberg.Provisioner = (*QPdf)(nil)

pkg/modules/qpdf/qpdf_test.go

@@ -97,6 +97,7 @@ func TestQPdf_Merge(t *testing.T) {
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 			},
+			expectError: false,
 		},
 		{
 			scenario: "many files success",
@@ -105,6 +106,7 @@ func TestQPdf_Merge(t *testing.T) {
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 				"/tests/test/testdata/pdfengines/sample2.pdf",
 			},
+			expectError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
@@ -148,3 +150,21 @@ func TestQPdf_Convert(t *testing.T) {
 		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
 	}
 }
+
+func TestLibreOfficePdfEngine_ReadMetadata(t *testing.T) {
+	engine := new(QPdf)
+	_, err := engine.ReadMetadata(context.Background(), zap.NewNop(), "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestLibreOfficePdfEngine_WriteMetadata(t *testing.T) {
+	engine := new(QPdf)
+	err := engine.WriteMetadata(context.Background(), zap.NewNop(), nil, "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}

pkg/modules/webhook/client.go

@@ -27,9 +27,9 @@ type client struct {
 
 // send call the webhook either to send the success response or the error response.
 func (c client) send(body io.Reader, headers map[string]string, erroed bool) error {
-	URL := c.url
+	url := c.url
 	if erroed {
-		URL = c.errorUrl
+		url = c.errorUrl
 	}
 
 	method := c.method
@@ -37,9 +37,9 @@ func (c client) send(body io.Reader, headers map[string]string, erroed bool) err
 		method = c.errorMethod
 	}
 
-	req, err := retryablehttp.NewRequest(method, URL, body)
+	req, err := retryablehttp.NewRequest(method, url, body)
 	if err != nil {
-		return fmt.Errorf("create '%s' request to '%s': %w", method, URL, err)
+		return fmt.Errorf("create '%s' request to '%s': %w", method, url, err)
 	}
 
 	req.Header.Set("User-Agent", "Gotenberg")
@@ -75,17 +75,17 @@ func (c client) send(body io.Reader, headers map[string]string, erroed bool) err
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return fmt.Errorf("send '%s' request to '%s': %w", method, URL, err)
+		return fmt.Errorf("send '%s' request to '%s': %w", method, url, err)
 	}
 
 	if resp.StatusCode >= http.StatusBadRequest {
-		return fmt.Errorf("send '%s' request to '%s': got status: '%s'", method, URL, resp.Status)
+		return fmt.Errorf("send '%s' request to '%s': got status: '%s'", method, url, resp.Status)
 	}
 
 	defer func() {
 		err := resp.Body.Close()
 		if err != nil {
-			c.logger.Error(fmt.Sprintf("close response body from '%s': %s", URL, err))
+			c.logger.Error(fmt.Sprintf("close response body from '%s': %s", url, err))
 		}
 	}()
 
@@ -94,7 +94,7 @@ func (c client) send(body io.Reader, headers map[string]string, erroed bool) err
 
 	// Now let's log!
 	fields := make([]zap.Field, 5)
-	fields[0] = zap.String("webhook_url", URL)
+	fields[0] = zap.String("webhook_url", url)
 	fields[1] = zap.String("method", method)
 	fields[2] = zap.Int64("latency", int64(finishTime.Sub(c.startTime)))
 	fields[3] = zap.String("latency_human", finishTime.Sub(c.startTime).String())
@@ -110,34 +110,3 @@ func (c client) send(body io.Reader, headers map[string]string, erroed bool) err
 
 	return nil
 }
-
-// leveledLogger is wrapper around a [zap.Logger] which is used by the
-// [retryablehttp.Client].
-type leveledLogger struct {
-	logger *zap.Logger
-}
-
-// Error logs a message at error level using the wrapped zap.Logger.
-func (leveled leveledLogger) Error(msg string, keysAndValues ...interface{}) {
-	leveled.logger.Error(fmt.Sprintf("%s: %+v", msg, keysAndValues))
-}
-
-// Warn logs a message at warning level using the wrapped zap.Logger.
-func (leveled leveledLogger) Warn(msg string, keysAndValues ...interface{}) {
-	leveled.logger.Warn(fmt.Sprintf("%s: %+v", msg, keysAndValues))
-}
-
-// Info logs a message at info level using the wrapped zap.Logger.
-func (leveled leveledLogger) Info(msg string, keysAndValues ...interface{}) {
-	leveled.logger.Info(fmt.Sprintf("%s: %+v", msg, keysAndValues))
-}
-
-// Debug logs a message at debug level using the wrapped zap.Logger.
-func (leveled leveledLogger) Debug(msg string, keysAndValues ...interface{}) {
-	leveled.logger.Debug(fmt.Sprintf("%s: %+v", msg, keysAndValues))
-}
-
-// Interface guards.
-var (
-	_ retryablehttp.LeveledLogger = (*leveledLogger)(nil)
-)

pkg/modules/webhook/middleware.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"net/http"
 	"os"
-	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -17,6 +16,7 @@ import (
 	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
 
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 )
 
@@ -44,38 +44,19 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 						)
 					}
 
-					// 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 api.WrapError(
-								fmt.Errorf("'%s' does not match the expression from the allowed list", URL),
-								api.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 api.WrapError(
-								fmt.Errorf("'%s' matches the expression from the denied list", URL),
-								api.NewSentinelHttpError(
-									http.StatusForbidden,
-									fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URLs", header, URL),
-								),
-							)
-						}
-
-						return nil
+					deadline, ok := ctx.Deadline()
+					if !ok {
+						return errors.New("context has no deadline")
 					}
 
-					err := filter(webhookUrl, "Gotenberg-Webhook-Url", w.allowList, w.denyList)
+					// Let's check if the webhook URLs are acceptable according to our
+					// allowed/denied lists.
+					err := gotenberg.FilterDeadline(w.allowList, w.denyList, webhookUrl, deadline)
 					if err != nil {
 						return fmt.Errorf("filter webhook URL: %w", err)
 					}
 
-					err = filter(webhookErrorUrl, "Gotenberg-Webhook-Error-Url", w.errorAllowList, w.errorDenyList)
+					err = gotenberg.FilterDeadline(w.errorAllowList, w.errorDenyList, webhookErrorUrl, deadline)
 					if err != nil {
 						return fmt.Errorf("filter webhook error URL: %w", err)
 					}
@@ -119,11 +100,11 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 					}
 
 					// What about extra HTTP headers?
-					var extraHTTPHeaders map[string]string
+					var extraHttpHeaders map[string]string
 
-					extraHTTPHeadersJSON := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers")
-					if extraHTTPHeadersJSON != "" {
-						err = json.Unmarshal([]byte(extraHTTPHeadersJSON), &extraHTTPHeaders)
+					extraHttpHeadersJson := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers")
+					if extraHttpHeadersJson != "" {
+						err = json.Unmarshal([]byte(extraHttpHeadersJson), &extraHttpHeaders)
 						if err != nil {
 							return api.WrapError(
 								fmt.Errorf("unmarshal webhook extra HTTP headers: %w", err),
@@ -132,13 +113,19 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 						}
 					}
 
+					// Retrieve values from echo.Context before it get recycled.
+					// See https://github.com/gotenberg/gotenberg/issues/1000.
+					startTime := c.Get("startTime").(time.Time)
+					traceHeader := c.Get("traceHeader").(string)
+					trace := c.Get("trace").(string)
+
 					client := &client{
 						url:              webhookUrl,
 						method:           webhookMethod,
 						errorUrl:         webhookErrorUrl,
 						errorMethod:      webhookErrorMethod,
-						extraHttpHeaders: extraHTTPHeaders,
-						startTime:        c.Get("startTime").(time.Time),
+						extraHttpHeaders: extraHttpHeaders,
+						startTime:        startTime,
 
 						client: &retryablehttp.Client{
 							HTTPClient: &http.Client{
@@ -147,11 +134,9 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 							RetryMax:     w.maxRetry,
 							RetryWaitMin: w.retryMinWait,
 							RetryWaitMax: w.retryMaxWait,
-							Logger: leveledLogger{
-								logger: ctx.Log(),
-							},
-							CheckRetry: retryablehttp.DefaultRetryPolicy,
-							Backoff:    retryablehttp.DefaultBackoff,
+							Logger:       gotenberg.NewLeveledLogger(ctx.Log()),
+							CheckRetry:   retryablehttp.DefaultRetryPolicy,
+							Backoff:      retryablehttp.DefaultBackoff,
 						},
 						logger: ctx.Log(),
 					}
@@ -178,8 +163,8 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 						}
 
 						headers := map[string]string{
-							echo.HeaderContentType:        echo.MIMEApplicationJSONCharsetUTF8,
-							c.Get("traceHeader").(string): c.Get("trace").(string),
+							echo.HeaderContentType: echo.MIMEApplicationJSON,
+							traceHeader:            trace,
 						}
 
 						err = client.send(bytes.NewReader(b), headers, true)
@@ -257,7 +242,7 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 							echo.HeaderContentDisposition: fmt.Sprintf("attachement; filename=%q", ctx.OutputFilename(outputPath)),
 							echo.HeaderContentType:        http.DetectContentType(fileHeader),
 							echo.HeaderContentLength:      strconv.FormatInt(fileStat.Size(), 10),
-							c.Get("traceHeader").(string): c.Get("trace").(string),
+							traceHeader:                   trace,
 						}
 
 						// Send the output file to the webhook.

pkg/modules/webhook/middleware_test.go

@@ -11,11 +11,11 @@ import (
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
-	"regexp"
 	"strings"
 	"testing"
 	"time"
 
+	"github.com/dlclark/regexp2"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
 
@@ -47,10 +47,10 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 
 	buildWebhookModule := func() *Webhook {
 		return &Webhook{
-			allowList:      regexp.MustCompile(""),
-			denyList:       regexp.MustCompile(""),
-			errorAllowList: regexp.MustCompile(""),
-			errorDenyList:  regexp.MustCompile(""),
+			allowList:      regexp2.MustCompile("", 0),
+			denyList:       regexp2.MustCompile("", 0),
+			errorAllowList: regexp2.MustCompile("", 0),
+			errorDenyList:  regexp2.MustCompile("", 0),
 			maxRetry:       0,
 			retryMinWait:   0,
 			retryMaxWait:   0,
@@ -63,6 +63,7 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 		request          *http.Request
 		mod              *Webhook
 		next             echo.HandlerFunc
+		noDeadline       bool
 		expectError      bool
 		expectHttpError  bool
 		expectHttpStatus int
@@ -76,6 +77,7 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 					return nil
 				}
 			}(),
+			noDeadline:      false,
 			expectError:     false,
 			expectHttpError: false,
 		},
@@ -87,10 +89,23 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				return req
 			}(),
 			mod:              buildWebhookModule(),
+			noDeadline:       false,
 			expectError:      true,
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
 		},
+		{
+			scenario: "context has no deadline",
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+				return req
+			}(),
+			mod:         buildWebhookModule(),
+			noDeadline:  true,
+			expectError: true,
+		},
 		{
 			scenario: "webhook URL is not allowed",
 			request: func() *http.Request {
@@ -101,12 +116,11 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 			}(),
 			mod: func() *Webhook {
 				mod := buildWebhookModule()
-				mod.allowList = regexp.MustCompile("bar")
+				mod.allowList = regexp2.MustCompile("bar", 0)
 				return mod
 			}(),
-			expectError:      true,
-			expectHttpError:  true,
-			expectHttpStatus: http.StatusForbidden,
+			noDeadline:  false,
+			expectError: true,
 		},
 		{
 			scenario: "webhook URL is denied",
@@ -118,12 +132,11 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 			}(),
 			mod: func() *Webhook {
 				mod := buildWebhookModule()
-				mod.denyList = regexp.MustCompile("foo")
+				mod.denyList = regexp2.MustCompile("foo", 0)
 				return mod
 			}(),
-			expectError:      true,
-			expectHttpError:  true,
-			expectHttpStatus: http.StatusForbidden,
+			noDeadline:  false,
+			expectError: true,
 		},
 		{
 			scenario: "webhook error URL is not allowed",
@@ -135,12 +148,11 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 			}(),
 			mod: func() *Webhook {
 				mod := buildWebhookModule()
-				mod.errorAllowList = regexp.MustCompile("foo")
+				mod.errorAllowList = regexp2.MustCompile("foo", 0)
 				return mod
 			}(),
-			expectError:      true,
-			expectHttpError:  true,
-			expectHttpStatus: http.StatusForbidden,
+			noDeadline:  false,
+			expectError: true,
 		},
 		{
 			scenario: "webhook error URL is denied",
@@ -152,12 +164,11 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 			}(),
 			mod: func() *Webhook {
 				mod := buildWebhookModule()
-				mod.errorDenyList = regexp.MustCompile("bar")
+				mod.errorDenyList = regexp2.MustCompile("bar", 0)
 				return mod
 			}(),
-			expectError:      true,
-			expectHttpError:  true,
-			expectHttpStatus: http.StatusForbidden,
+			noDeadline:  false,
+			expectError: true,
 		},
 		{
 			scenario: "invalid webhook method (GET)",
@@ -169,6 +180,7 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				return req
 			}(),
 			mod:              buildWebhookModule(),
+			noDeadline:       false,
 			expectError:      true,
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
@@ -183,6 +195,7 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				return req
 			}(),
 			mod:              buildWebhookModule(),
+			noDeadline:       false,
 			expectError:      true,
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
@@ -198,6 +211,7 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				return req
 			}(),
 			mod:              buildWebhookModule(),
+			noDeadline:       false,
 			expectError:      true,
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
@@ -213,6 +227,7 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				return req
 			}(),
 			mod:              buildWebhookModule(),
+			noDeadline:       false,
 			expectError:      true,
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
@@ -228,6 +243,7 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				return req
 			}(),
 			mod:              buildWebhookModule(),
+			noDeadline:       false,
 			expectError:      true,
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
@@ -242,6 +258,7 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				return req
 			}(),
 			mod:              buildWebhookModule(),
+			noDeadline:       false,
 			expectError:      true,
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
@@ -254,15 +271,20 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 
 			c := srv.NewContext(tc.request, httptest.NewRecorder())
 
-			ctx := &api.ContextMock{Context: &api.Context{}}
-			ctx.SetEchoContext(c)
-
-			c.Set("context", ctx.Context)
-			c.Set("cancel", func() context.CancelFunc {
-				return func() {
-					return
-				}
-			}())
+			if tc.noDeadline {
+				ctx := &api.ContextMock{Context: &api.Context{Context: context.Background()}}
+				ctx.SetEchoContext(c)
+				c.Set("context", ctx.Context)
+				c.Set("cancel", func() context.CancelFunc {
+					return nil
+				}())
+			} else {
+				timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Duration(10)*time.Second)
+				ctx := &api.ContextMock{Context: &api.Context{Context: timeoutCtx}}
+				ctx.SetEchoContext(c)
+				c.Set("context", ctx.Context)
+				c.Set("cancel", cancel)
+			}
 
 			err := webhookMiddleware(tc.mod).Handler(tc.next)(c)
 
@@ -320,10 +342,10 @@ func TestWebhookMiddlewareAsynchronousProcess(t *testing.T) {
 
 	buildWebhookModule := func() *Webhook {
 		return &Webhook{
-			allowList:      regexp.MustCompile(""),
-			denyList:       regexp.MustCompile(""),
-			errorAllowList: regexp.MustCompile(""),
-			errorDenyList:  regexp.MustCompile(""),
+			allowList:      regexp2.MustCompile("", 0),
+			denyList:       regexp2.MustCompile("", 0),
+			errorAllowList: regexp2.MustCompile("", 0),
+			errorDenyList:  regexp2.MustCompile("", 0),
 			maxRetry:       0,
 			retryMinWait:   0,
 			retryMaxWait:   0,
@@ -354,7 +376,7 @@ func TestWebhookMiddlewareAsynchronousProcess(t *testing.T) {
 					return errors.New("foo")
 				}
 			}(),
-			expectWebhookContentType:  echo.MIMEApplicationJSONCharsetUTF8,
+			expectWebhookContentType:  echo.MIMEApplicationJSON,
 			expectWebhookMethod:       http.MethodPost,
 			expectWebhookErrorStatus:  http.StatusInternalServerError,
 			expectWebhookErrorMessage: http.StatusText(http.StatusInternalServerError),
@@ -368,7 +390,7 @@ func TestWebhookMiddlewareAsynchronousProcess(t *testing.T) {
 					return api.NewSentinelHttpError(http.StatusBadRequest, http.StatusText(http.StatusBadRequest))
 				}
 			}(),
-			expectWebhookContentType:  echo.MIMEApplicationJSONCharsetUTF8,
+			expectWebhookContentType:  echo.MIMEApplicationJSON,
 			expectWebhookMethod:       http.MethodPost,
 			expectWebhookErrorStatus:  http.StatusBadRequest,
 			expectWebhookErrorMessage: http.StatusText(http.StatusBadRequest),
@@ -408,7 +430,7 @@ func TestWebhookMiddlewareAsynchronousProcess(t *testing.T) {
 				}
 			}(),
 			returnedError:             echo.ErrInternalServerError,
-			expectWebhookContentType:  echo.MIMEApplicationJSONCharsetUTF8,
+			expectWebhookContentType:  echo.MIMEApplicationJSON,
 			expectWebhookMethod:       http.MethodPost,
 			expectWebhookErrorStatus:  http.StatusInternalServerError,
 			expectWebhookErrorMessage: http.StatusText(http.StatusInternalServerError),
@@ -426,22 +448,17 @@ func TestWebhookMiddlewareAsynchronousProcess(t *testing.T) {
 			c.Set("trace", "foo")
 			c.Set("startTime", time.Now())
 
-			ctx := &api.ContextMock{Context: &api.Context{}}
+			timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Duration(10)*time.Second)
+			ctx := &api.ContextMock{Context: &api.Context{Context: timeoutCtx}}
 			ctx.SetLogger(zap.NewNop())
 			ctx.SetEchoContext(c)
 
 			c.Set("context", ctx.Context)
-			c.Set("cancel", func() context.CancelFunc {
-				return func() {
-					return
-				}
-			}())
+			c.Set("cancel", cancel)
 
 			webhook := echo.New()
 			webhook.HideBanner = true
 			webhook.HidePort = true
-
-			rand.Seed(time.Now().UnixNano())
 			webhookPort := rand.Intn(65535-1025+1) + 1025
 
 			c.Request().Header.Set("Gotenberg-Webhook-Url", fmt.Sprintf("http://localhost:%d/", webhookPort))
@@ -476,7 +493,7 @@ func TestWebhookMiddlewareAsynchronousProcess(t *testing.T) {
 							}
 						}
 
-						if contentType == echo.MIMEApplicationJSONCharsetUTF8 {
+						if contentType == echo.MIMEApplicationJSON {
 							body, err := io.ReadAll(c.Request().Body)
 							if err != nil {
 								errChan <- err

pkg/modules/webhook/webhook.go

@@ -1,9 +1,9 @@
 package webhook
 
 import (
-	"regexp"
 	"time"
 
+	"github.com/dlclark/regexp2"
 	flag "github.com/spf13/pflag"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
@@ -17,10 +17,10 @@ func init() {
 // Webhook is a module which provides a middleware for uploading output files
 // to any destinations in an asynchronous fashion.
 type Webhook struct {
-	allowList      *regexp.Regexp
-	denyList       *regexp.Regexp
-	errorAllowList *regexp.Regexp
-	errorDenyList  *regexp.Regexp
+	allowList      *regexp2.Regexp
+	denyList       *regexp2.Regexp
+	errorAllowList *regexp2.Regexp
+	errorDenyList  *regexp2.Regexp
 	maxRetry       int
 	retryMinWait   time.Duration
 	retryMaxWait   time.Duration

pkg/standard/imports.go

@@ -4,6 +4,7 @@ import (
 	// Standard Gotenberg modules.
 	_ "github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 	_ "github.com/gotenberg/gotenberg/v8/pkg/modules/chromium"
+	_ "github.com/gotenberg/gotenberg/v8/pkg/modules/exiftool"
 	_ "github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice"
 	_ "github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/api"
 	_ "github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/pdfengine"

scripts/release.sh

@@ -2,50 +2,61 @@
 
 set -e
 
+# Args.
 GOLANG_VERSION="$1"
 GOTENBERG_VERSION="$2"
 GOTENBERG_USER_GID="$3"
 GOTENBERG_USER_UID="$4"
 NOTO_COLOR_EMOJI_VERSION="$5"
 PDFTK_VERSION="$6"
-DOCKER_REPOSITORY="$7"
-
-if [ "$GOTENBERG_VERSION" == "edge" ]; then
-  docker buildx build \
-    --build-arg GOLANG_VERSION="$GOLANG_VERSION" \
-    --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" \
-    --platform linux/amd64 \
-    --platform linux/arm64 \
-    --platform linux/386 \
-    --platform linux/arm/v7 \
-    -t "$DOCKER_REPOSITORY/gotenberg:edge" \
-    --push \
-    -f build/Dockerfile .
-
-  # Cloud Run variant.
-  # Only linux/amd64! See https://github.com/gotenberg/gotenberg/issues/505#issuecomment-1264679278.
-  docker buildx build \
-    --build-arg DOCKER_REPOSITORY="$DOCKER_REPOSITORY" \
-    --build-arg GOTENBERG_VERSION="$GOTENBERG_VERSION" \
-    --platform linux/amd64 \
-    -t "$DOCKER_REPOSITORY/gotenberg:edge-cloudrun" \
-    --push \
-    -f build/Dockerfile.cloudrun .
-
-  exit 0
-fi
+PDFCPU_VERSION="$7"
+DOCKER_REGISTRY="$8"
+DOCKER_REPOSITORY="$9"
+LINUX_AMD64_RELEASE="${10}"
 
+# Find out if given version is "semver".
 GOTENBERG_VERSION="${GOTENBERG_VERSION//v}"
 IFS='.' read -ra SEMVER <<< "$GOTENBERG_VERSION"
 VERSION_LENGTH=${#SEMVER[@]}
+TAGS=()
+TAGS_CLOUD_RUN=()
 
-if [ "$VERSION_LENGTH" -ne 3 ]; then
-  echo "$VERSION is not semver."
-  exit 1
+if [ "$VERSION_LENGTH" -eq 3 ]; then
+  MAJOR="${SEMVER[0]}"
+  MINOR="${SEMVER[1]}"
+  PATCH="${SEMVER[2]}"
+
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:latest")
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR")
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR.$MINOR")
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR.$MINOR.$PATCH")
+
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:latest-cloudrun")
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR-cloudrun")
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR.$MINOR-cloudrun")
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR.$MINOR.$PATCH-cloudrun")
+else
+    # Normalizes version.
+    GOTENBERG_VERSION="${GOTENBERG_VERSION// /-}"
+    GOTENBERG_VERSION="$(echo "$GOTENBERG_VERSION" | tr -cd '[:alnum:]._\-')"
+
+    if [[ "$GOTENBERG_VERSION" =~ ^[\.\-] ]]; then
+      GOTENBERG_VERSION="_${GOTENBERG_VERSION#?}"
+    fi
+
+    if [ "${#GOTENBERG_VERSION}" -gt 128 ]; then
+      GOTENBERG_VERSION="${GOTENBERG_VERSION:0:128}"
+    fi
+
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$GOTENBERG_VERSION")
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$GOTENBERG_VERSION-cloudrun")
+fi
+
+# Multi-arch build takes a lot of time.
+if [ "$LINUX_AMD64_RELEASE" = true ]; then
+    PLATFORM_FLAG="--platform linux/amd64"
+else
+    PLATFORM_FLAG="--platform linux/amd64,linux/arm64,linux/386,linux/arm/v7"
 fi
 
 docker buildx build \
@@ -55,26 +66,19 @@ docker buildx build \
   --build-arg GOTENBERG_USER_UID="$GOTENBERG_USER_UID" \
   --build-arg NOTO_COLOR_EMOJI_VERSION="$NOTO_COLOR_EMOJI_VERSION" \
   --build-arg PDFTK_VERSION="$PDFTK_VERSION" \
-  --platform linux/amd64 \
-  --platform linux/arm64 \
-  --platform linux/386 \
-  --platform linux/arm/v7 \
-  -t "$DOCKER_REPOSITORY/gotenberg:latest" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}.${SEMVER[1]}" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}.${SEMVER[1]}.${SEMVER[2]}" \
+  --build-arg PDFCPU_VERSION="$PDFCPU_VERSION" \
+  $PLATFORM_FLAG \
+  "${TAGS[@]}" \
   --push \
   -f build/Dockerfile .
 
 # Cloud Run variant.
 # Only linux/amd64! See https://github.com/gotenberg/gotenberg/issues/505#issuecomment-1264679278.
 docker buildx build \
+  --build-arg DOCKER_REGISTRY="$DOCKER_REGISTRY" \
   --build-arg DOCKER_REPOSITORY="$DOCKER_REPOSITORY" \
   --build-arg GOTENBERG_VERSION="$GOTENBERG_VERSION" \
   --platform linux/amd64 \
-  -t "$DOCKER_REPOSITORY/gotenberg:latest-cloudrun" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}-cloudrun" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}.${SEMVER[1]}-cloudrun" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}.${SEMVER[1]}.${SEMVER[2]}-cloudrun" \
+  "${TAGS_CLOUD_RUN[@]}" \
   --push \
-  -f build/Dockerfile.cloudrun .
+  -f build/Dockerfile.cloudrun .

test/Dockerfile

@@ -1,19 +1,20 @@
 ARG GOLANG_VERSION
+ARG DOCKER_REGISTRY
 ARG DOCKER_REPOSITORY
 ARG GOTENBERG_VERSION
 ARG GOLANGCI_LINT_VERSION
 
-FROM golang:$GOLANG_VERSION-bookworm as golang
+FROM golang:$GOLANG_VERSION-bookworm AS golang
 
 # We're extending the Gotenberg's Docker image because our code relies on external
 # dependencies like Google Chrome, LibreOffice, etc.
-FROM $DOCKER_REPOSITORY/gotenberg:$GOTENBERG_VERSION
+FROM $DOCKER_REGISTRY/$DOCKER_REPOSITORY:$GOTENBERG_VERSION
 
 USER root
 
-ENV GOPATH /go
-ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
-ENV CGO_ENABLED 1
+ENV GOPATH=/go
+ENV PATH=$GOPATH/bin:/usr/local/go/bin:$PATH
+ENV CGO_ENABLED=1
 
 COPY --from=golang /usr/local/go /usr/local/go
 

test/docker-entrypoint.sh

@@ -5,19 +5,19 @@
 # Credits: https://github.com/thecodingmachine/docker-images-php.
 
 set +e
-mkdir testing_file_system_rights.foo
+mkdir -p testing_file_system_rights.foo
 chmod 700 testing_file_system_rights.foo
 su gotenberg -c "touch testing_file_system_rights.foo/foo > /dev/null 2>&1"
 HAS_CONSISTENT_RIGHTS=$?
 
 if [[ "$HAS_CONSISTENT_RIGHTS" != "0" ]]; then
     # If not specified, the DOCKER_USER is the owner of the current working directory (heuristic!).
-    DOCKER_USER=$(stat -c '%U' "$(pwd)")
+    DOCKER_USER=$(stat -c '%u' "$(pwd)")
 else
     # macOs or Windows.
     # Note: in most cases, we don't care about the rights (they are not respected).
-    FILE_OWNER=$(stat -c '%U' "testing_file_system_rights.foo/foo")
-    if [[ "$FILE_OWNER" == "root" ]]; then
+    FILE_OWNER=$(stat -c '%u' "testing_file_system_rights.foo/foo")
+    if [[ "$FILE_OWNER" == "0" ]]; then
         # If root, we are likely on a Windows host.
         # All files will belong to root, but it does not matter as everybody can write/delete
         # those (0777 access rights).
@@ -56,4 +56,4 @@ go mod tidy
 set +x
 
 # Run the command with the correct user.
-exec "sudo" "-E" "-H" "-u" "#$DOCKER_USER_ID" "$@"
+exec "sudo" "-E" "-H" "-u" "#$DOCKER_USER_ID" "$@"

test/gotest.sh

@@ -3,4 +3,8 @@
 set -x
 
 go test -race -covermode=atomic -coverprofile=/tests/coverage.txt ./...
-go tool cover -html=coverage.txt -o /tests/coverage.html
+RESULT=$?
+
+go tool cover -html=coverage.txt -o /tests/coverage.html
+
+exit $RESULT

test/testdata/api/README.md

@@ -0,0 +1,14 @@
+To generate a valid certificate and private key use the following command:
+
+```bash
+# In OpenSSL ≥ 1.1.1
+openssl req -x509 -newkey rsa:4096 -sha256 -days 9999 -nodes \
+  -keyout key.pem -out cert.pem -subj "/CN=localhost" \
+  -addext "subjectAltName=DNS:localhost,IP:127.0.0.1,IP:::1"
+```
+
+To check a certificate use the following command:
+
+```bash
+openssl x509 -in cert.pem -text
+```

test/testdata/api/cert.pem

@@ -0,0 +1,30 @@
+-----BEGIN CERTIFICATE-----
+MIIFOjCCAyKgAwIBAgIUZaht2QoZwWDK8wEuwm+wmip9sqwwDQYJKoZIhvcNAQEL
+BQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MCAXDTI0MDUyNjA1MDExNFoYDzIwNTEx
+MDExMDUwMTE0WjAUMRIwEAYDVQQDDAlsb2NhbGhvc3QwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCm3TNckD55ae6pxXS03iV2P3X/edZT4vRa8D15elsi
+CSRf6mdU2TVAQyg22GEcMXgsbba7sotJVg7559LkWAgb3Dj9rbPputdS29ebncat
+x1nzo1QHMCS/v7nWoPe9fQVlDEf3ebM198f+5vhccSYFxFa+YvsUmSw9yMF8z1nA
+6POZTpm6ErByAY9EGvC8EcNOQd9xLOfBZc0e+mY/rMRxmL+0N+sSRE/ACU+2zxHN
+KcCiFX5WQdLDYW1ZjX5xAVatCPNlxSQpj97/ktGsnqwGnJWSTeMUOPv7L0LrQasf
+k1VXBvfTW2/ZqhI9WA8qfdC5XOuzVwfU14gv+6vv9AGZnUFmOjeo9XG4xWBxlIKj
+AQAzeNwAGFltPkp5a3yPczxMjKY4xLsMGcDfpaNtv1B24+7fV77Nyty/gLLT9pUa
+FtXLuRfIPSaUK3kFhAuYzGUL/sO9O9jJkNlxxygxQ+VyIgmdw0zWrUi3q+Lfmdya
+FFjHdM7LnLrLCjSv3dEoMINngR3+IejsY+98Ehd25O3oW+ZnGIQX0VwykV8sOQWq
+rpnnZ+2iHMtF6Vsj40z/Y9y7yVE18AIJFC+Yr/dD/nQyg6SE70wdNcOx0Ay1xHbP
+WuV3fqKOfhONR7NEBSO2UbHi6GZAiYMMwwul+4yKAQ4+lHOEXG4JQcKvtZasxq9v
+GwIDAQABo4GBMH8wHQYDVR0OBBYEFPPMaH3C0rAkD/E0gtBZwM0x8N9MMB8GA1Ud
+IwQYMBaAFPPMaH3C0rAkD/E0gtBZwM0x8N9MMA8GA1UdEwEB/wQFMAMBAf8wLAYD
+VR0RBCUwI4IJbG9jYWxob3N0hwR/AAABhxAAAAAAAAAAAAAAAAAAAAABMA0GCSqG
+SIb3DQEBCwUAA4ICAQB0DXz59JfQgfJvRJfraa+Cv/3nG4NNmHYtNGhrid5sagH3
+LM8jkbA+JKRAn34SmsqUZb1f2XFI64TwrScgMfAvfi+5ibRqBjM/YL06bTlG61Ua
+t2IQchV2kcX4zQnaMCIYG0dUj6JoXIspiFULMHyGDs7G9BKVcZxlaLrEvPXBqQjd
+nwF80KHS/rCConmICU9uWHPgHxS1VmhQiwYGbrakETilau1ppRS0bpH2k/stVyjc
+plttIr1DUD6xaRV4mZ0NZVlIXl2nDf78iQvreJeMrGl6AcNHzV+/rGHpY/gOrziP
+PQkB1VtSiHtBe/VMKXcVB69SEzsoGEknqs4GPXuVYm47POo3/U5HmGU+FadSATNP
+qtorRECUMbVn0IfDzJX2jBLUjZlhPI9gqO9DhiAT8FWHRV2yPsZKuiBBg5/hUvyb
+Qsswtmi/YV5e6AnXEuvylwE3wYzlqDzxwlZM08bWFyZYnSf38d3hAjVwUHAugiaX
+4sgE6GPAiONW5FkTZ4Z2oXYiN213QDIIcQeFAl04qSEFkGBV8x2hM0uXgFH1S++j
+JePdKBbV/CjxegyyYsmnln+eO1kC8pCalB6k6pEtYMqNYOnmimC8UKrJATrH9EVq
+eAehGBiIe514Oz06Ws2Vm4PTiY2x0KVbqphwkuz85ohSF9UXOHUcMryusr1zlg==
+-----END CERTIFICATE-----

test/testdata/api/key.pem

@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----

test/testdata/chromium/html/footer.html

@@ -2,8 +2,8 @@
 <head>
     <style>
         body {
-            font-size: 30rem;
-            margin: 4rem auto;
+            font-size: 12px;
+            margin: auto 20px;
         }
     </style>
 </head>

test/testdata/chromium/html/header.html

@@ -2,8 +2,8 @@
 <head>
     <style>
         body {
-            font-size: 8rem;
-            margin: 4rem auto;
+            font-size: 12px;
+            margin: auto 20px;
         }
     </style>
 </head>

test/testdata/chromium/html/index.html

@@ -2,6 +2,12 @@
 <html lang="en">
 <head>
     <meta charset="utf-8">
+    <!-- net::ERR_FILE_NOT_FOUND -->
+    <link rel="stylesheet" type="text/css" href="doesnotexist.css">
+    <!-- net::ERR_CONNECTION_REFUSED -->
+    <link rel="stylesheet" type="text/css" href="http://localhost:100/style.css">
+    <!-- 400 Bad Request -->
+    <link rel="stylesheet" type="text/css" href="https://httpstat.us/400">
     <link rel="stylesheet" type="text/css" href="style.css">
     <link href="https://fonts.googleapis.com/css?family=Montserrat" rel="stylesheet">
     <title>Gutenberg</title>
@@ -23,7 +29,7 @@
 
     <blockquote cite="https://sites.google.com/site/johanngutenbergper5/q">
         <p>It is a press, certainly, but a press from which shall flow in inexhaustible streams...Through it, God will spread His Word. A spring of truth shall flow from it: like a new star it shall scatter the darkness of ignorance, and cause a light heretofore unknown to shine amongst men.</p>
-        <footer>— <a href="https://sites.google.com/site/johanngutenbergper5/q">Johannes Gutenberg</a></cite></footer>
+        <footer>— <a href="https://sites.google.com/site/johanngutenbergper5/q">Johannes Gutenberg</a></footer>
     </blockquote>
 </div>
 
@@ -59,6 +65,14 @@
     <p id="javascript" style="display: none">Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
 </div>
 
+<div class="page-break-after">
+    <h2>/etc/passwd</h2>
+    <iframe src="/etc/passwd"></iframe>
+
+    <h2>\\localhost/etc/passwd</h2>
+    <iframe src="\\localhost/etc/passwd"></iframe>
+</div>
+
 <script type="application/javascript">
     var globalVar = 'notReady'
 

test/testdata/chromium/markdown/footer.html

@@ -2,8 +2,8 @@
 <head>
     <style>
         body {
-            font-size: 8rem;
-            margin: 4rem auto;
+            font-size: 12px;
+            margin: auto 20px;
         }
     </style>
 </head>

test/testdata/chromium/markdown/header.html

@@ -2,8 +2,8 @@
 <head>
     <style>
         body {
-            font-size: 8rem;
-            margin: 4rem auto;
+            font-size: 12px;
+            margin: auto 20px;
         }
     </style>
 </head>

test/testdata/chromium/markdown/index.html

@@ -2,6 +2,12 @@
 <html lang="en">
 <head>
     <meta charset="utf-8">
+    <!-- net::ERR_FILE_NOT_FOUND -->
+    <link rel="stylesheet" type="text/css" href="doesnotexist.css">
+    <!-- net::ERR_CONNECTION_REFUSED -->
+    <link rel="stylesheet" type="text/css" href="http://localhost:100/style.css">
+    <!-- 400 Bad Request -->
+    <link rel="stylesheet" type="text/css" href="https://httpstat.us/400">
     <link rel="stylesheet" type="text/css" href="style.css">
     <link href="https://fonts.googleapis.com/css?family=Montserrat" rel="stylesheet">
     <title>Gutenberg</title>
@@ -15,7 +21,7 @@
 
     <blockquote cite="https://sites.google.com/site/johanngutenbergper5/q">
         <p>It is a press, certainly, but a press from which shall flow in inexhaustible streams...Through it, God will spread His Word. A spring of truth shall flow from it: like a new star it shall scatter the darkness of ignorance, and cause a light heretofore unknown to shine amongst men.</p>
-        <footer>— <a href="https://sites.google.com/site/johanngutenbergper5/q">Johannes Gutenberg</a></cite></footer>
+        <footer>— <a href="https://sites.google.com/site/johanngutenbergper5/q">Johannes Gutenberg</a></footer>
     </blockquote>
 </div>