chore(deps): update Go dependencies

* 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@v4
+        uses: golangci/golangci-lint-action@v6
         with:
-          version: v1.55.2
+          version: v1.60.3
 
   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,15 @@ 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.042 # See https://github.com/googlefonts/noto-emoji/releases.
 PDFTK_VERSION=v3.3.3 # See https://gitlab.com/pdftk-java/pdftk/-/releases - Binary package.
-GOLANGCI_LINT_VERSION=v1.55.2 # See https://github.com/golangci/golangci-lint/releases.
+GOLANGCI_LINT_VERSION=v1.60.3 # See https://github.com/golangci/golangci-lint/releases.
 
 .PHONY: build
 build: ## Build the Gotenberg's Docker image
@@ -23,7 +24,7 @@ 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) \
+	-t $(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION) \
 	-f build/Dockerfile .
 
 GOTENBERG_GRACEFUL_SHUTDOWN_DURATION=30s
@@ -33,6 +34,13 @@ API_START_TIMEOUT=30s
 API_TIMEOUT=30s
 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
@@ -79,7 +87,9 @@ 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) \
@@ -88,6 +98,11 @@ run: ## Start a Gotenberg container
 	--api-timeout=$(API_TIMEOUT) \
 	--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) \
@@ -134,24 +149,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
@@ -168,8 +184,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) \
@@ -177,4 +195,7 @@ release: ## Build the Gotenberg's Docker image for many platforms, then push it
 	$(GOTENBERG_USER_UID) \
 	$(NOTO_COLOR_EMOJI_VERSION) \
 	$(PDFTK_VERSION) \
-	$(DOCKER_REPOSITORY)
+	$(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

@@ -9,7 +9,7 @@ ARG GOLANG_VERSION
 FROM golang:$GOLANG_VERSION AS 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 +164,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/*
 
@@ -190,11 +191,12 @@ COPY build/fonts.conf /etc/fonts/conf.d/100-gotenberg.conf
 COPY --from=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
 
 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)

go.mod

@@ -1,67 +1,71 @@
 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-20240214232516-ad4608604e9e
-	github.com/chromedp/chromedp v0.9.5
+	github.com/barasher/go-exiftool v1.10.0
+	github.com/chromedp/cdproto v0.0.0-20240919203636-12af5e8a671f
+	github.com/chromedp/chromedp v0.10.0
 	github.com/golang/snappy v0.0.4 // indirect
 	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.6 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.7
+	github.com/klauspost/compress v1.17.9 // 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/pdfcpu/pdfcpu v0.8.1
 	github.com/pierrec/lz4/v4 v4.1.21 // indirect
-	github.com/prometheus/client_golang v1.18.0
+	github.com/prometheus/client_golang v1.20.4
 	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.19.0 // indirect
-	golang.org/x/image v0.15.0 // indirect
-	golang.org/x/net v0.21.0
-	golang.org/x/sync v0.6.0
-	golang.org/x/sys v0.17.0 // indirect
-	golang.org/x/term v0.17.0
-	golang.org/x/text v0.14.0
+	go.uber.org/zap v1.27.0
+	golang.org/x/crypto v0.27.0 // indirect
+	golang.org/x/image v0.20.0 // indirect
+	golang.org/x/net v0.29.0
+	golang.org/x/sync v0.8.0
+	golang.org/x/sys v0.25.0 // indirect
+	golang.org/x/term v0.24.0
+	golang.org/x/text v0.18.0
 )
 
-require github.com/dlclark/regexp2 v1.10.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/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/chromedp/sysutil v1.0.0 // indirect
 	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
 	github.com/gobwas/httphead v0.1.0 // indirect
 	github.com/gobwas/pool v0.2.1 // indirect
-	github.com/gobwas/ws v1.3.2 // indirect
+	github.com/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/mattn/go-runewidth v0.0.16 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/prometheus/client_model v0.6.0 // indirect
-	github.com/prometheus/common v0.47.0 // indirect
-	github.com/prometheus/procfs v0.12.0 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.59.1 // indirect
+	github.com/prometheus/procfs v0.15.1 // indirect
 	github.com/rivo/uniseg v0.4.7 // 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
+	golang.org/x/time v0.6.0 // indirect
+	google.golang.org/protobuf v1.34.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )

go.sum

@@ -5,30 +5,37 @@ github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1
 github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
+github.com/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-20240202021202-6d0b6a386732/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
-github.com/chromedp/cdproto v0.0.0-20240214232516-ad4608604e9e h1:kXEolCWQZzuEFcuaTzfqXToX+e29OcvK87BcBiBBJ1c=
-github.com/chromedp/cdproto v0.0.0-20240214232516-ad4608604e9e/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
-github.com/chromedp/chromedp v0.9.5 h1:viASzruPJOiThk7c5bueOUY91jGLJVximoEMGoH93rg=
-github.com/chromedp/chromedp v0.9.5/go.mod h1:D4I2qONslauw/C7INoCir1BJkSwBYMyZgx8X276z3+Y=
+github.com/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-20240801214329-3f85d328b335/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
+github.com/chromedp/cdproto v0.0.0-20240919203636-12af5e8a671f h1:dEjjp+iN34En5Pl9XIi978DmR2/CMwuOxoPWtiHixKQ=
+github.com/chromedp/cdproto v0.0.0-20240919203636-12af5e8a671f/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
+github.com/chromedp/chromedp v0.10.0 h1:bRclRYVpMm/UVD76+1HcRW9eV3l58rFfy7AdBvKab1E=
+github.com/chromedp/chromedp v0.10.0/go.mod h1:ei/1ncZIqXX1YnAYDkxhD4gzBgavMEUu7JCKvztdomE=
 github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
 github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0=
-github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+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.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=
@@ -41,10 +48,10 @@ 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/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/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=
@@ -53,8 +60,8 @@ github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8Hm
 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.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI=
-github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
+github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
+github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
 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=
@@ -63,8 +70,10 @@ 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=
@@ -76,19 +85,21 @@ 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/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/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/pdfcpu/pdfcpu v0.8.1 h1:AiWUb8uXlrXqJ73OmiYXBjDF0Qxt4OuM281eAfkAOMA=
+github.com/pdfcpu/pdfcpu v0.8.1/go.mod h1:M5SFotxdaw0fedxthpjbA/PADytAo6wJnGH0SSBWJ7s=
 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=
@@ -96,14 +107,14 @@ 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.6.0 h1:k1v3CzpSRUTrKMppY35TLwPvxHqBu0bYgxZzqGIgaos=
-github.com/prometheus/client_model v0.6.0/go.mod h1:NTQHnmxFpouOD0DpvP4XujX3CdOAGQPoaGhyTchlyt8=
-github.com/prometheus/common v0.47.0 h1:p5Cz0FNHo7SnWOmWmoRozVcjEp0bIVU8cV7OShpjL1k=
-github.com/prometheus/common v0.47.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc=
-github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
-github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
+github.com/prometheus/client_golang v1.20.4 h1:Tgh3Yr67PaOv/uTqloMsCEdeuFTatm5zIq5+qNN23vI=
+github.com/prometheus/client_golang v1.20.4/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.59.1 h1:LXb1quJHWm1P6wq/U824uxYi4Sg0oGvNeUm1z5dJoX0=
+github.com/prometheus/common v0.59.1/go.mod h1:GpWM7dewqmVYcd7SmRaiWVe9SSqjf0UrwnYnpEZNuT0=
+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/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
@@ -113,47 +124,50 @@ github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf
 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=
+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.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
-golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
-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.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
-golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
-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.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A=
+golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70=
+golang.org/x/image v0.20.0 h1:7cVCUjQwfL18gyBJOmYvptfSHS8Fb3YUDtfLIZ7Nbpw=
+golang.org/x/image v0.20.0/go.mod h1:0a88To4CYVBAHp5FXJm8o7QbUl37Vd85ply1vyD8auM=
+golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo=
+golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0=
+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/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
-golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U=
-golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-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.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
+golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM=
+golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
+golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
+golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/time v0.6.0 h1:eTDhh4ZXt5Qf0augr54TN6suAUudPcawVZeIAPU7D4U=
+golang.org/x/time v0.6.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=
+google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
+google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
 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=

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/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

@@ -173,6 +173,20 @@ 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
@@ -187,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() {
@@ -212,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

@@ -325,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,
@@ -451,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())
 			}

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

@@ -5,13 +5,12 @@ import (
 	"errors"
 	"fmt"
 	"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 +29,15 @@ func init() {
 // middlewares or health checks.
 type Api struct {
 	port                      int
+	tlsCertFile               string
+	tlsKeyFile                string
 	startTimeout              time.Duration
 	timeout                   time.Duration
 	rootPath                  string
 	traceHeader               string
+	basicAuthUsername         string
+	basicAuthPassword         string
+	downloadFromCfg           downloadFromConfig
 	disableHealthCheckLogging bool
 
 	routes              []Route
@@ -45,6 +49,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 +170,18 @@ 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-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-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 +192,45 @@ func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
 func (a *Api) Provision(ctx *gotenberg.Context) error {
 	flags := ctx.ParsedFlags()
 	a.port = flags.MustInt("api-port")
+	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.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 +326,12 @@ func (a *Api) Validate() error {
 		)
 	}
 
+	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 +354,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 +438,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 +449,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.downloadFromCfg))
 
 			for _, externalMultipartMiddleware := range externalMultipartMiddlewares {
 				middlewares = append(middlewares, externalMultipartMiddleware.Handler)
@@ -431,16 +472,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 +516,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(":%d", a.port), a.tlsCertFile, a.tlsKeyFile)
+		} else {
+			// Start an HTTP/2 Cleartext (non-HTTPS) server.
+			server := &http2.Server{}
+			err = a.srv.StartH2CServer(fmt.Sprintf(":%d", a.port), server)
+		}
 		if !errors.Is(err, http.ErrServerClosed) {
 			a.logger.Fatal(err.Error())
 		}

pkg/modules/api/api_test.go

@@ -58,10 +58,28 @@ func TestApi_Provision(t *testing.T) {
 			expectError: true,
 		},
 		{
-			scenario: "port from env: empty environment variable",
+			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-port-from-env=PORT"})
+				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)
 				}
@@ -74,7 +92,7 @@ func TestApi_Provision(t *testing.T) {
 				)
 			}(),
 			setEnv: func() {
-				err := os.Setenv("PORT", "")
+				err := os.Setenv("GOTENBERG_API_BASIC_AUTH_USERNAME", "foo")
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -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,8 @@ func TestApi_Validate(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
 		port        int
+		tlsCertFile string
+		tlsKeyFile  string
 		rootPath    string
 		traceHeader string
 		routes      []Route
@@ -460,6 +488,26 @@ func TestApi_Validate(t *testing.T) {
 			middlewares: nil,
 			expectError: true,
 		},
+		{
+			scenario:    "invalid TLS files: only cert file provided",
+			port:        10,
+			tlsCertFile: "cert.pem",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid TLS files: only key file provided",
+			port:        10,
+			tlsKeyFile:  "key.pem",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
 		{
 			scenario:    "invalid root path: missing / prefix",
 			port:        10,
@@ -621,10 +669,33 @@ 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,
+				tlsCertFile:         tc.tlsCertFile,
+				tlsKeyFile:          tc.tlsKeyFile,
 				rootPath:            tc.rootPath,
 				traceHeader:         tc.traceHeader,
 				routes:              tc.routes,
@@ -647,6 +718,8 @@ func TestApi_Start(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
 		readyFn     []func() error
+		tlsCertFile string
+		tlsKeyFile  string
 		expectError bool
 	}{
 		{
@@ -665,12 +738,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 +839,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 +864,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 +890,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
 			}

pkg/modules/api/context.go

@@ -3,9 +3,11 @@ package api
 import (
 	"compress/flate"
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
+	"mime"
 	"mime/multipart"
 	"net/http"
 	"os"
@@ -14,9 +16,11 @@ import (
 	"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,20 +38,34 @@ 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 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, downloadFromCfg downloadFromConfig, traceHeader, trace string) (*Context, context.CancelFunc, error) {
 	processCtx, processCancel := context.WithTimeout(context.Background(), timeout)
 
 	ctx := &Context{
@@ -55,6 +73,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		cancelled:   false,
 		logger:      logger,
 		echoCtx:     echoCtx,
+		pathRename:  new(osPathRename),
 		Context:     processCtx,
 	}
 
@@ -86,7 +105,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),
@@ -120,6 +138,147 @@ 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))
+					}
+				}()
+
+				_, err = io.Copy(out, resp.Body)
+				if err != nil {
+					return fmt.Errorf("copy downloaded file from '%s' to local file: %v", 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 {
@@ -143,7 +302,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 {
@@ -161,6 +319,7 @@ 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)
@@ -191,14 +350,19 @@ func (ctx *Context) FormData() *FormData {
 }
 
 // GeneratePath generates a path within the context's working directory.
-// It either generates a new UUID-based filename or uses the provided filename.
-// It does not create a file.
-func (ctx *Context) GeneratePath(filename, extension string) string {
-	if filename == "" {
-		// Generate a new UUID-based filename
-		filename = uuid.New().String()
+// 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().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 fmt.Sprintf("%s/%s%s", ctx.dirPath, filename, extension)
+	return nil
 }
 
 // AddOutputPaths adds the given paths. Those paths will be used later to build
@@ -250,7 +414,7 @@ func (ctx *Context) BuildOutputFile() (string, error) {
 		ImplicitTopLevelFolder: false,
 	}
 
-	archivePath := ctx.GeneratePath("", ".zip")
+	archivePath := ctx.GeneratePath(".zip")
 
 	err := z.Archive(ctx.outputPaths, archivePath)
 	if err != nil {
@@ -273,3 +437,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,102 @@ 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
+		downloadFromCfg  downloadFromConfig
+		downloadFromSrv  *echo.Echo
+		expectContext    *Context
 		expectError      bool
 		expectHttpError  bool
 		expectHttpStatus int
@@ -67,6 +143,236 @@ func TestNewContext(t *testing.T) {
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
 		},
+		{
+			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 +396,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.downloadFromCfg, "Gotenberg-Trace", "123")
 				defer cancel()
 				// Context already cancelled.
 				defer cancel()
@@ -109,6 +467,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
 			}
 
@@ -190,14 +562,44 @@ func TestContext_GeneratePath(t *testing.T) {
 		dirPath: "/foo",
 	}
 
-	path := ctx.GeneratePath("", ".pdf")
+	path := ctx.GeneratePath(".pdf")
 	if !strings.HasPrefix(path, ctx.dirPath) {
 		t.Errorf("expected '%s' to start with '%s'", path, ctx.dirPath)
 	}
+}
 
-	path = ctx.GeneratePath("foo.txt", ".pdf")
-	if !strings.Contains(path, "foo.txt.pdf") {
-		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)
+			}
+		})
 	}
 }
 

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, 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, 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, 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

@@ -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,6 +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),
+		setCookiesActionFunc(logger, options.Cookies),
+		userAgentOverride(logger, options.UserAgent),
 		extraHttpHeadersActionFunc(logger, options.ExtraHttpHeaders),
 		navigateActionFunc(logger, url, options.SkipNetworkIdleEvent),
 		hideDefaultWhiteBackgroundActionFunc(logger, options.OmitBackground, options.PrintBackground),
@@ -246,6 +250,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),
+		setCookiesActionFunc(logger, options.Cookies),
+		userAgentOverride(logger, options.UserAgent),
 		extraHttpHeadersActionFunc(logger, options.ExtraHttpHeaders),
 		navigateActionFunc(logger, url, options.SkipNetworkIdleEvent),
 		hideDefaultWhiteBackgroundActionFunc(logger, options.OmitBackground, true),
@@ -254,6 +260,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),
 	})
 }
@@ -307,6 +314,16 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 		listenForEventExceptionThrown(taskCtx, logger, &consoleExceptions, &consoleExceptionsMu)
 	}
 
+	var (
+		loadingFailed   error
+		loadingFailedMu sync.RWMutex
+	)
+
+	// See:
+	// https://github.com/gotenberg/gotenberg/issues/913
+	// https://github.com/gotenberg/gotenberg/issues/959
+	listenForEventLoadingFailed(taskCtx, logger, &loadingFailed, &loadingFailedMu)
+
 	err = chromedp.Run(taskCtx, tasks...)
 	if err != nil {
 		errMessage := err.Error()
@@ -342,6 +359,16 @@ 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)
+	}
+
 	return nil
 }
 

pkg/modules/chromium/browser_test.go

@@ -249,6 +249,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 		browser            browser
 		fs                 *gotenberg.FileSystem
 		options            PdfOptions
+		url                string
 		noDeadline         bool
 		start              bool
 		expectError        bool
@@ -478,6 +479,32 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 			expectError:   true,
 			expectedError: ErrConsoleExceptions,
 		},
+		{
+			scenario: "ErrLoadingFailed",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			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))
+				}
+
+				return fs
+			}(),
+			url:           "http://localhost:100",
+			noDeadline:    false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrLoadingFailed,
+		},
 		{
 			scenario: "clear cache",
 			browser: newChromiumBrowser(
@@ -579,6 +606,76 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				"JavaScript disabled, skipping wait expression",
 			},
 		},
+		{
+			scenario: "set cookies",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			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/index.html", fs.WorkingDirPath()), []byte("<h1>Set cookies</h1>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: PdfOptions{
+				Options: Options{Cookies: []Cookie{{Name: "foo", Value: "bar", Domain: ".foo.bar"}}},
+			},
+			noDeadline:  false,
+			start:       true,
+			expectError: false,
+			expectedLogEntries: []string{
+				"set cookie",
+			},
+		},
+		{
+			scenario: "user agent override",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			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/index.html", fs.WorkingDirPath()), []byte("<h1>User-Agent override</h1>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: PdfOptions{
+				Options: Options{UserAgent: "foo"},
+			},
+			noDeadline:  false,
+			start:       true,
+			expectError: false,
+			expectedLogEntries: []string{
+				fmt.Sprintf("user agent override: foo"),
+			},
+		},
 		{
 			scenario: "extra HTTP headers",
 			browser: newChromiumBrowser(
@@ -950,6 +1047,41 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				"wait until 'window.globalVar === 'ready'' is true before print",
 			},
 		},
+		{
+			scenario: "single page",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			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/index.html", fs.WorkingDirPath()), []byte("<h1>Custom header and footer</h1>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: PdfOptions{
+				SinglePage: true,
+			},
+			noDeadline:  false,
+			start:       true,
+			expectError: false,
+			expectedLogEntries: []string{
+				"single page PDF",
+			},
+		},
 		{
 			scenario: "custom header and footer",
 			browser: newChromiumBrowser(
@@ -1090,6 +1222,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				"cache not cleared",
 				"cookies not cleared",
 				"JavaScript not disabled",
+				"no cookies to set",
 				"no extra HTTP headers",
 				"navigate to",
 				"default white background not hidden",
@@ -1137,10 +1270,15 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				defer cancel()
 			}
 
+			url := fmt.Sprintf("file://%s/index.html", tc.fs.WorkingDirPath())
+			if tc.url != "" {
+				url = tc.url
+			}
+
 			err := tc.browser.pdf(
 				ctx,
 				logger,
-				fmt.Sprintf("file://%s/index.html", tc.fs.WorkingDirPath()),
+				url,
 				fmt.Sprintf("%s/%s.pdf", tc.fs.WorkingDirPath(), uuid.NewString()),
 				tc.options,
 			)
@@ -1180,6 +1318,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 		browser            browser
 		fs                 *gotenberg.FileSystem
 		options            ScreenshotOptions
+		url                string
 		noDeadline         bool
 		start              bool
 		expectError        bool
@@ -1413,6 +1552,33 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 			expectError:   true,
 			expectedError: ErrConsoleExceptions,
 		},
+		{
+			scenario: "ErrLoadingFailed",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+
+			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))
+				}
+
+				return fs
+			}(),
+			url:           "http://localhost:100",
+			noDeadline:    false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrLoadingFailed,
+		},
 		{
 			scenario: "clear cache",
 			browser: newChromiumBrowser(
@@ -1514,6 +1680,41 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				"JavaScript disabled, skipping wait expression",
 			},
 		},
+		{
+			scenario: "set cookies",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			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/index.html", fs.WorkingDirPath()), []byte("<h1>Set cookies</h1>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: ScreenshotOptions{
+				Options: Options{Cookies: []Cookie{{Name: "fpp", Value: "bar", Domain: ".foo.bar"}}},
+			},
+			noDeadline:  false,
+			start:       true,
+			expectError: false,
+			expectedLogEntries: []string{
+				"set cookie",
+			},
+		},
 		{
 			scenario: "extra HTTP headers",
 			browser: newChromiumBrowser(
@@ -1884,12 +2085,62 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				"cache not cleared",
 				"cookies not cleared",
 				"JavaScript not disabled",
+				"no user agent override",
 				"no extra HTTP headers",
 				"navigate to",
 				"default white background not hidden",
 				"no emulated media type",
 				"no wait delay",
 				"no wait expression",
+				"set device metrics override",
+			},
+		},
+		{
+			scenario: "success (clip)",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			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/index.html", fs.WorkingDirPath()), []byte("<h1>Default options</h1>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: func() ScreenshotOptions {
+				options := DefaultScreenshotOptions()
+				options.Clip = true
+				return options
+			}(),
+			noDeadline:  false,
+			start:       true,
+			expectError: false,
+			expectedLogEntries: []string{
+				"cache not cleared",
+				"cookies not cleared",
+				"JavaScript not disabled",
+				"no cookies to set",
+				"no user agent override",
+				"no extra HTTP headers",
+				"navigate to",
+				"default white background not hidden",
+				"no emulated media type",
+				"no wait delay",
+				"no wait expression",
+				"set device metrics override",
 			},
 		},
 		{
@@ -1929,12 +2180,15 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				"cache not cleared",
 				"cookies not cleared",
 				"JavaScript not disabled",
+				"no cookies to set",
+				"no user agent override",
 				"no extra HTTP headers",
 				"navigate to",
 				"default white background not hidden",
 				"no emulated media type",
 				"no wait delay",
 				"no wait expression",
+				"set device metrics override",
 			},
 		},
 	} {
@@ -1975,10 +2229,15 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				defer cancel()
 			}
 
+			url := fmt.Sprintf("file://%s/index.html", tc.fs.WorkingDirPath())
+			if tc.url != "" {
+				url = tc.url
+			}
+
 			err := tc.browser.screenshot(
 				ctx,
 				logger,
-				fmt.Sprintf("file://%s/index.html", tc.fs.WorkingDirPath()),
+				url,
 				fmt.Sprintf("%s/%s.pdf", tc.fs.WorkingDirPath(), uuid.NewString()),
 				tc.options,
 			)

pkg/modules/chromium/chromium.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/alexliesenfeld/health"
+	"github.com/chromedp/cdproto/network"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/zap"
 
@@ -41,6 +42,9 @@ var (
 	// is set to true.
 	ErrConsoleExceptions = errors.New("console exceptions")
 
+	// ErrLoadingFailed happens when a URL failed to load.
+	ErrLoadingFailed = errors.New("loading failed")
+
 	// PDF specific.
 
 	// ErrOmitBackgroundWithoutPrintBackground happens if
@@ -75,47 +79,44 @@ 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
 
 	// 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.
+	// 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 map[string]string
 
 	// EmulatedMediaType is the media type to emulate, either "screen" or
 	// "print".
-	// Optional.
 	EmulatedMediaType string
 
 	// OmitBackground hides default white background and allows generating PDFs
 	// with transparency.
-	// Optional.
 	OmitBackground bool
 }
 
@@ -128,6 +129,8 @@ func DefaultOptions() Options {
 		WaitDelay:               0,
 		WaitWindowStatus:        "",
 		WaitForExpression:       "",
+		Cookies:                 nil,
+		UserAgent:               "",
 		ExtraHttpHeaders:        nil,
 		EmulatedMediaType:       "",
 		OmitBackground:          false,
@@ -139,43 +142,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
@@ -188,17 +185,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
 }
 
@@ -209,6 +203,7 @@ func DefaultPdfOptions() PdfOptions {
 		Landscape:         false,
 		PrintBackground:   false,
 		Scale:             1.0,
+		SinglePage:        false,
 		PaperWidth:        8.5,
 		PaperHeight:       11,
 		MarginTop:         0.39,
@@ -227,18 +222,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
 }
 
@@ -246,12 +248,47 @@ 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"`
+}
+
 // 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

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

@@ -21,7 +21,8 @@ import (
 )
 
 // listenForEventRequestPaused listens for requests to check if they are
-// allowed or not.
+// allowed or not.network.SetBlockedURLS()
+// TODO: https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setBlockedURLs (experimental for now).
 func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowList *regexp2.Regexp, denyList *regexp2.Regexp) {
 	chromedp.ListenTarget(ctx, func(ev interface{}) {
 		switch e := ev.(type) {
@@ -64,8 +65,8 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowL
 	})
 }
 
-// listenForEventResponseReceived listens for an invalid HTTP status code is
-// returned by the main page.
+// listenForEventResponseReceived listens for an invalid HTTP status code that
+// is returned by the main page.
 // See https://github.com/gotenberg/gotenberg/issues/613.
 func listenForEventResponseReceived(ctx context.Context, logger *zap.Logger, url string, failOnHttpStatusCodes []int64, invalidHttpStatusCode *error, invalidHttpStatusCodeMu *sync.RWMutex) {
 	for _, code := range []int64{199, 299, 399, 499, 599} {
@@ -95,6 +96,52 @@ func listenForEventResponseReceived(ctx context.Context, logger *zap.Logger, url
 	})
 }
 
+// listenForEventLoadingFailed listens for an event indicating that the main
+// page failed to load.
+// See:
+// https://github.com/gotenberg/gotenberg/issues/913.
+// https://github.com/gotenberg/gotenberg/issues/959.
+func listenForEventLoadingFailed(ctx context.Context, logger *zap.Logger, loadingFailed *error, loadingFailedMu *sync.RWMutex) {
+	chromedp.ListenTarget(ctx, func(ev interface{}) {
+		switch ev := ev.(type) {
+		case *network.EventLoadingFailed:
+			logger.Debug(fmt.Sprintf("event EventLoadingFailed fired: %+v", ev.ErrorText))
+
+			if ev.Type != network.ResourceTypeDocument {
+				logger.Debug("skip EventLoadingFailed: is not resource type Document")
+				return
+			}
+
+			// Supposition: except iframe, an event loading failed with a
+			// resource type Document is about the main page.
+
+			// 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",
+			}
+			if !slices.Contains(errors, ev.ErrorText) {
+				logger.Debug(fmt.Sprintf("skip EventLoadingFailed: '%s' is not part of %+v", ev.ErrorText, errors))
+				return
+			}
+
+			loadingFailedMu.Lock()
+			defer loadingFailedMu.Unlock()
+
+			*loadingFailed = fmt.Errorf("%s", 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

@@ -34,6 +34,8 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 		waitDelay               time.Duration
 		waitWindowStatus        string
 		waitForExpression       string
+		cookies                 []Cookie
+		userAgent               string
 		extraHttpHeaders        map[string]string
 		emulatedMediaType       string
 		omitBackground          bool
@@ -58,6 +60,26 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 		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
@@ -78,7 +100,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
@@ -94,6 +116,8 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 		WaitDelay:               waitDelay,
 		WaitWindowStatus:        waitWindowStatus,
 		WaitForExpression:       waitForExpression,
+		Cookies:                 cookies,
+		UserAgent:               userAgent,
 		ExtraHttpHeaders:        extraHttpHeaders,
 		EmulatedMediaType:       emulatedMediaType,
 		OmitBackground:          omitBackground,
@@ -109,7 +133,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 +145,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 +162,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 +185,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 +236,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 +265,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 +290,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 +300,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 +350,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 +361,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 +412,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 +432,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)
 			}
@@ -494,7 +546,7 @@ func markdownToHtml(ctx *api.Context, inputPath string, markdownPaths []string)
 		)
 	}
 
-	inputPath = ctx.GeneratePath("", ".html")
+	inputPath = ctx.GeneratePath(".html")
 
 	err = os.WriteFile(inputPath, buffer.Bytes(), 0o600)
 	if err != nil {
@@ -504,11 +556,11 @@ 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 {
-	outputPath := ctx.GeneratePath("", ".pdf")
+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(
@@ -549,30 +601,10 @@ func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url
 	zeroValued := gotenberg.PdfFormats{}
 	if pdfFormats != zeroValued {
 		convertInputPath := outputPath
-		convertOutputPath := ctx.GeneratePath("", ".pdf")
+		convertOutputPath := ctx.GeneratePath(".pdf")
 
 		err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)
 		if err != nil {
-			if errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) {
-				return api.WrapError(
-					fmt.Errorf("convert PDF: %w", err),
-					api.NewSentinelHttpError(
-						http.StatusTooManyRequests,
-						"The maximum queue size has been reached",
-					),
-				)
-			}
-
-			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)
 		}
 
@@ -580,6 +612,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)
@@ -590,10 +630,10 @@ func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url
 
 func screenshotUrl(ctx *api.Context, chromium Api, url string, options ScreenshotOptions) error {
 	ext := fmt.Sprintf(".%s", options.Format)
-	outputPath := ctx.GeneratePath("", ext)
+	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)
 	}
@@ -606,31 +646,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, gotenberg.ErrMaximumQueueSizeExceeded) {
-		return api.WrapError(
-			err,
-			api.NewSentinelHttpError(
-				http.StatusTooManyRequests,
-				"The maximum queue size has been reached",
-			),
-		)
-	}
-
-	if errors.Is(err, gotenberg.ErrFiltered) {
-		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
@@ -668,5 +688,15 @@ func handleChromiumError(err error, url string, options Options) error {
 		)
 	}
 
+	if errors.Is(err, ErrLoadingFailed) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusBadRequest,
+				fmt.Sprintf("Chromium returned %v", err),
+			),
+		)
+	}
+
 	return err
 }

pkg/modules/chromium/routes_test.go

@@ -62,6 +62,59 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				return options
 			}(),
 		},
+		{
+			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(),
+		},
+		{
+			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
+			}(),
+		},
+		{
+			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
+			}(),
+		},
 		{
 			scenario: "invalid extraHttpHeaders form field",
 			ctx: func() *api.ContextMock {
@@ -332,6 +385,15 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 			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,6 +405,9 @@ 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
@@ -399,6 +464,57 @@ func TestFormDataChromiumPdfFormats(t *testing.T) {
 	}
 }
 
+func TestFormDataPdfMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario         string
+		ctx              *api.ContextMock
+		expectedMetadata map[string]interface{}
+	}{
+		{
+			scenario:         "no metadata form field",
+			ctx:              &api.ContextMock{Context: new(api.Context)},
+			expectedMetadata: nil,
+		},
+		{
+			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,
+		},
+		{
+			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",
+			},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.SetLogger(zap.NewNop())
+			actual := FormDataPdfMetadata(tc.ctx.Context.FormData())
+
+			if !reflect.DeepEqual(actual, tc.expectedMetadata) {
+				t.Fatalf("expected %+v but got: %+v", tc.expectedMetadata, actual)
+			}
+		})
+	}
+}
+
 func TestConvertUrlRoute(t *testing.T) {
 	for _, tc := range []struct {
 		scenario               string
@@ -1223,37 +1339,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: "ErrMaximumQueueSizeExceeded",
-			ctx:      &api.ContextMock{Context: new(api.Context)},
-			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
-				return gotenberg.ErrMaximumQueueSizeExceeded
-			}},
-			options:                DefaultPdfOptions(),
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
-			expectOutputPathsCount: 0,
-		},
-		{
-			scenario: "ErrFiltered",
-			ctx:      &api.ContextMock{Context: new(api.Context)},
-			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
-				return gotenberg.ErrFiltered
-			}},
-			options:                DefaultPdfOptions(),
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusForbidden,
-			expectOutputPathsCount: 0,
-		},
 		{
 			scenario: "ErrOmitBackgroundWithoutPrintBackground",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1342,6 +1435,18 @@ 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: "error from Chromium",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1354,39 +1459,7 @@ func TestConvertUrl(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "ErrMaximumQueueSizeExceeded (PDF engine)",
-			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.ErrMaximumQueueSizeExceeded
-			}},
-			pdfFormats:             gotenberg.PdfFormats{PdfA: "foo"},
-			options:                DefaultPdfOptions(),
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
-			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
@@ -1394,14 +1467,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
@@ -1409,12 +1482,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 {
@@ -1436,7 +1526,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,
@@ -1444,7 +1547,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)
@@ -1490,30 +1593,6 @@ func TestScreenshotUrl(t *testing.T) {
 		expectHttpStatus       int
 		expectOutputPathsCount int
 	}{
-		{
-			scenario: "ErrMaximumQueueSizeExceeded",
-			ctx:      &api.ContextMock{Context: new(api.Context)},
-			api: &ApiMock{ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
-				return gotenberg.ErrMaximumQueueSizeExceeded
-			}},
-			options:                DefaultScreenshotOptions(),
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
-			expectOutputPathsCount: 0,
-		},
-		{
-			scenario: "ErrFiltered",
-			ctx:      &api.ContextMock{Context: new(api.Context)},
-			api: &ApiMock{ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
-				return gotenberg.ErrFiltered
-			}},
-			options:                DefaultScreenshotOptions(),
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusForbidden,
-			expectOutputPathsCount: 0,
-		},
 		{
 			scenario: "ErrInvalidEvaluationExpression (without waitForExpression form field)",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1566,6 +1645,18 @@ 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: "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,6 +232,72 @@ func disableJavaScriptActionFunc(logger *zap.Logger, disable bool) chromedp.Acti
 	}
 }
 
+func setCookiesActionFunc(logger *zap.Logger, cookies []Cookie) chromedp.ActionFunc {
+	return func(ctx context.Context) error {
+		if len(cookies) == 0 {
+			logger.Debug("no cookies to set")
+			return nil
+		}
+
+		deadline, ok := ctx.Deadline()
+		if !ok {
+			return errors.New("context has no deadline, cannot set cookies")
+		}
+		epochTime := cdp.TimeSinceEpoch(deadline)
+
+		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(),
+			)
+		}
+
+		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 user agent override: %w", err)
+	}
+}
+
 func extraHttpHeadersActionFunc(logger *zap.Logger, extraHttpHeaders map[string]string) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		if len(extraHttpHeaders) == 0 {

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
@@ -257,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,10 +1,12 @@
 package libreoffice
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
-	"path/filepath"
+	"slices"
+	"strconv"
 
 	"github.com/labstack/echo/v4"
 
@@ -22,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,11 +146,30 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 			// Alright, let's convert each document to PDF.
 			outputPaths := make([]string, len(inputPaths))
 			for i, inputPath := range inputPaths {
-				// document.docx -> document.docx.pdf.
-				outputPaths[i] = ctx.GeneratePath(filepath.Base(inputPath), ".pdf")
+				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 {
@@ -68,16 +178,6 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 
 				err = libreOffice.Pdf(ctx, ctx.Log(), inputPath, outputPaths[i], options)
 				if err != nil {
-					if errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) {
-						return api.WrapError(
-							fmt.Errorf("convert to PDF: %w", err),
-							api.NewSentinelHttpError(
-								http.StatusTooManyRequests,
-								"The maximum queue size has been reached",
-							),
-						)
-					}
-
 					if errors.Is(err, libreofficeapi.ErrInvalidPdfFormats) {
 						return api.WrapError(
 							fmt.Errorf("convert to PDF: %w", err),
@@ -88,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 the document: possible causes include malformed page ranges '%s' (nativePageRanges) or the document might not be password-protected, but 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 invalid or required, but the exact cause is uncertain"),
 						)
 					}
 
@@ -99,119 +206,65 @@ 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")
+				outputPath := ctx.GeneratePath(".pdf")
 
 				err = engine.Merge(ctx, ctx.Log(), outputPaths, outputPath)
 				if err != nil {
-					if errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) {
-						return api.WrapError(
-							fmt.Errorf("merge PDFs: %w", err),
-							api.NewSentinelHttpError(
-								http.StatusTooManyRequests,
-								"The maximum queue size has been reached",
-							),
-						)
-					}
-
 					return fmt.Errorf("merge PDFs: %w", err)
 				}
 
-				// Now, let's check if the client want to convert this
-				// resulting 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.ErrMaximumQueueSizeExceeded) {
-							return api.WrapError(
-								fmt.Errorf("convert PDF: %w", err),
-								api.NewSentinelHttpError(
-									http.StatusTooManyRequests,
-									"The maximum queue size has been reached",
-								),
-							)
-						}
-
-						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))
 
 				for i, outputPath := range outputPaths {
 					convertInputPath := outputPath
-					// document.docx -> document.docx.pdf.
-					convertOutputPaths[i] = ctx.GeneratePath(filepath.Base(inputPaths[i]), ".pdf")
+					convertOutputPaths[i] = ctx.GeneratePath(".pdf")
 
 					err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPaths[i])
 					if err != nil {
-						if errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) {
-							return api.WrapError(
-								fmt.Errorf("convert PDF: %w", err),
-								api.NewSentinelHttpError(
-									http.StatusTooManyRequests,
-									"The maximum queue size has been reached",
-								),
-							)
-						}
-
-						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

@@ -40,25 +40,135 @@ func TestConvertRoute(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "ErrMaximumQueueSizeExceeded",
+			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{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return gotenberg.ErrMaximumQueueSizeExceeded
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx"}
-				},
-			},
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
 			expectError:            true,
 			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
+			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,
 		},
 		{
@@ -84,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",
 					},
 				})
@@ -99,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"}
@@ -132,18 +269,16 @@ func TestConvertRoute(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "ErrMaximumQueueSizeExceeded (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": {
-						gotenberg.PdfA1b,
-					},
-					"nativePdfFormats": {
-						"false",
+					"merge": {
+						"true",
 					},
 				})
 				return ctx
@@ -157,52 +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.ErrMaximumQueueSizeExceeded
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return errors.New("foo")
 				},
 			},
 			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
+			expectHttpError:        false,
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "ErrPdfFormatNotSupported (single file)",
-			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": {
-						"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{
-				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 (single file)",
+			scenario: "PDF engine convert error",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
@@ -236,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{
@@ -262,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
 			}(),
@@ -274,10 +454,20 @@ 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,
-			expectOutputPaths:      []string{"/document.docx.pdf"},
 		},
 		{
 			scenario: "success (many files)",
@@ -288,6 +478,23 @@ func TestConvertRoute(t *testing.T) {
 					"document2.docx": "/document2.docx",
 					"document2.doc":  "/document2.doc",
 				})
+				ctx.SetValues(map[string][]string{
+					"pdfa": {
+						gotenberg.PdfA1b,
+					},
+					"pdfua": {
+						"true",
+					},
+					"nativePdfFormats": {
+						"false",
+					},
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+					return nil
+				}})
 				return ctx
 			}(),
 			libreOffice: &libreofficeapi.ApiMock{
@@ -298,57 +505,28 @@ func TestConvertRoute(t *testing.T) {
 					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: 3,
 			expectOutputPaths:      []string{"/document.docx.pdf", "/document2.docx.pdf", "/document2.doc.pdf"},
 		},
 		{
-			scenario: "success with non-native PDF/A & PDF/UA (many files)",
+			scenario: "success with native PDF/A & PDF/UA",
 			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{
-					"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{
-				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-					return nil
-				},
-			},
-			expectError:            false,
-			expectHttpError:        false,
-			expectOutputPathsCount: 2,
-			expectOutputPaths:      []string{"/document.docx.pdf", "/document2.docx.pdf"},
-		},
-		{
-			scenario: "success with native PDF/A & PDF/UA (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",
+					"document.docx": "/document.docx",
 				})
 				ctx.SetValues(map[string][]string{
 					"pdfa": {
@@ -368,355 +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: 2,
-			expectOutputPaths:      []string{"/document.docx.pdf", "/document2.docx.pdf"},
-		},
-		{
-			scenario: "ErrMaximumQueueSizeExceeded (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 gotenberg.ErrMaximumQueueSizeExceeded
-				},
-			},
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
-			expectOutputPathsCount: 0,
-		},
-		{
-			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: "ErrMaximumQueueSizeExceeded (convert post-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 gotenberg.ErrMaximumQueueSizeExceeded
-				},
-			},
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
-			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,

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 library. This package allows for:
+//
+// 1. The merging of PDF files.
 //
 // See: https://github.com/pdfcpu/pdfcpu.
 package pdfcpu

pkg/modules/pdfcpu/pdfcpu.go

@@ -46,12 +46,22 @@ func (engine *PdfCpu) Merge(ctx context.Context, logger *zap.Logger, inputPaths
 		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.

pkg/modules/pdfcpu/pdfcpu_test.go

@@ -102,3 +102,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"
@@ -70,6 +71,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.engines))
+
+	for _, engine := range multi.engines {
+		go func(engine gotenberg.PdfEngine) {
+			metadata, err := engine.ReadMetadata(ctx, logger, inputPath)
+			resultChan <- readMetadataResult{metadata: metadata, err: err}
+		}(engine)
+	}
+
+	for range multi.engines {
+		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.engines {
+		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

@@ -177,3 +177,169 @@ 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(
+				&gotenberg.PdfEngineMock{
+					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+						return make(map[string]interface{}), nil
+					},
+				},
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: newMultiPdfEngines(
+				&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
+					},
+				},
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: newMultiPdfEngines(
+				&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")
+					},
+				},
+			),
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+						return make(map[string]interface{}), 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(
+				&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(
+				&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(
+				&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(
+				&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

@@ -168,6 +168,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

@@ -312,7 +312,7 @@ func TestPdfEngines_Routes(t *testing.T) {
 	}{
 		{
 			scenario:      "routes not disabled",
-			expectRoutes:  2,
+			expectRoutes:  4,
 			disableRoutes: false,
 		},
 		{

pkg/modules/pdfengines/routes.go

@@ -1,11 +1,11 @@
 package pdfengines
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
 	"path/filepath"
-	"strings"
 
 	"github.com/labstack/echo/v4"
 
@@ -27,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)
@@ -44,21 +54,10 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 			}
 
 			// Alright, let's merge the PDFs.
-
-			outputPath := ctx.GeneratePath("", ".pdf")
+			outputPath := ctx.GeneratePath(".pdf")
 
 			err = engine.Merge(ctx, ctx.Log(), inputPaths, outputPath)
 			if err != nil {
-				if errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) {
-					return api.WrapError(
-						fmt.Errorf("merge PDFs: %w", err),
-						api.NewSentinelHttpError(
-							http.StatusTooManyRequests,
-							"The maximum queue size has been reached",
-						),
-					)
-				}
-
 				return fmt.Errorf("merge PDFs: %w", err)
 			}
 
@@ -68,30 +67,10 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 			zeroValued := gotenberg.PdfFormats{}
 			if pdfFormats != zeroValued {
 				convertInputPath := outputPath
-				convertOutputPath := ctx.GeneratePath("", ".pdf")
+				convertOutputPath := ctx.GeneratePath(".pdf")
 
 				err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)
 				if err != nil {
-					if errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) {
-						return api.WrapError(
-							fmt.Errorf("convert PDF: %w", err),
-							api.NewSentinelHttpError(
-								http.StatusTooManyRequests,
-								"The maximum queue size has been reached",
-							),
-						)
-					}
-
-					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)
 				}
 
@@ -99,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)
@@ -112,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,
@@ -154,46 +140,29 @@ func convertRoute(engine gotenberg.PdfEngine) api.Route {
 				)
 			}
 
-			// Alright, let's convert the PDFs.s
+			// Alright, let's convert the PDFs.
 			outputPaths := make([]string, len(inputPaths))
-
 			for i, inputPath := range inputPaths {
-				if len(outputPaths) > 1 {
-					// If .zip archive, keep the original filenames.
-					outputPaths[i] = ctx.GeneratePath(strings.TrimSuffix(filepath.Base(inputPath), filepath.Ext(inputPath)), ".pdf")
-				} else {
-					outputPaths[i] = ctx.GeneratePath("", ".pdf")
-				}
+				outputPaths[i] = ctx.GeneratePath(".pdf")
 
 				err = engine.Convert(ctx, ctx.Log(), pdfFormats, inputPath, outputPaths[i])
 				if err != nil {
-					if errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) {
-						return api.WrapError(
-							fmt.Errorf("convert PDF: %w", err),
-							api.NewSentinelHttpError(
-								http.StatusTooManyRequests,
-								"The maximum queue size has been reached",
-							),
-						)
-					}
-
-					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)
+					}
+
+					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)
@@ -203,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,7 +4,9 @@ import (
 	"context"
 	"errors"
 	"net/http"
+	"net/http/httptest"
 	"slices"
+	"strings"
 	"testing"
 
 	"github.com/labstack/echo/v4"
@@ -33,28 +35,27 @@ func TestMergeHandler(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "ErrMaximumQueueSizeExceeded (merge)",
+			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
 			}(),
-			engine: &gotenberg.PdfEngineMock{
-				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-					return gotenberg.ErrMaximumQueueSizeExceeded
-				},
-			},
 			expectError:            true,
 			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
+			expectHttpStatus:       http.StatusBadRequest,
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "error from PDF engine",
+			scenario: "PDF engine merge error",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
@@ -72,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 {
@@ -94,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: "ErrMaximumQueueSizeExceeded (convert)",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
@@ -123,33 +159,8 @@ func TestMergeHandler(t *testing.T) {
 					"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 gotenberg.ErrMaximumQueueSizeExceeded
-				},
-			},
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
-			expectOutputPathsCount: 0,
-		},
-		{
-			scenario: "ErrPdfFormatNotSupported",
-			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": {
-						"foo",
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
 					},
 				})
 				return ctx
@@ -159,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
 				},
 			},
@@ -298,54 +254,6 @@ func TestConvertHandler(t *testing.T) {
 			expectHttpStatus:       http.StatusBadRequest,
 			expectOutputPathsCount: 0,
 		},
-		{
-			scenario: "ErrMaximumQueueSizeExceeded",
-			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.ErrMaximumQueueSizeExceeded
-				},
-			},
-			expectError:            true,
-			expectHttpError:        true,
-			expectHttpStatus:       http.StatusTooManyRequests,
-			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": {
-						"foo",
-					},
-				})
-				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 {
@@ -419,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 {
@@ -435,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{
@@ -493,3 +434,295 @@ func TestConvertHandler(t *testing.T) {
 		})
 	}
 }
+
+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

@@ -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

@@ -148,3 +148,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

@@ -148,3 +148,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

@@ -13,7 +13,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/dlclark/regexp2"
 	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
 
@@ -52,31 +51,12 @@ 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 *regexp2.Regexp, deadline time.Time) error {
-						err := gotenberg.FilterDeadline(allowList, denyList, url, deadline)
-						if err == nil {
-							return nil
-						}
-
-						if errors.Is(err, gotenberg.ErrFiltered) {
-							return api.WrapError(
-								err,
-								api.NewSentinelHttpError(
-									http.StatusForbidden,
-									fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URL", header, url),
-								),
-							)
-						}
-
-						return err
-					}
-
-					err := filter(webhookUrl, "Gotenberg-Webhook-Url", w.allowList, w.denyList, deadline)
+					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, deadline)
+					err = gotenberg.FilterDeadline(w.errorAllowList, w.errorDenyList, webhookErrorUrl, deadline)
 					if err != nil {
 						return fmt.Errorf("filter webhook error URL: %w", err)
 					}
@@ -120,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),
@@ -138,7 +118,7 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 						method:           webhookMethod,
 						errorUrl:         webhookErrorUrl,
 						errorMethod:      webhookErrorMethod,
-						extraHttpHeaders: extraHTTPHeaders,
+						extraHttpHeaders: extraHttpHeaders,
 						startTime:        c.Get("startTime").(time.Time),
 
 						client: &retryablehttp.Client{
@@ -148,11 +128,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(),
 					}
@@ -179,7 +157,7 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 						}
 
 						headers := map[string]string{
-							echo.HeaderContentType:        echo.MIMEApplicationJSONCharsetUTF8,
+							echo.HeaderContentType:        echo.MIMEApplicationJSON,
 							c.Get("traceHeader").(string): c.Get("trace").(string),
 						}
 

pkg/modules/webhook/middleware_test.go

@@ -119,10 +119,8 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				mod.allowList = regexp2.MustCompile("bar", 0)
 				return mod
 			}(),
-			noDeadline:       false,
-			expectError:      true,
-			expectHttpError:  true,
-			expectHttpStatus: http.StatusForbidden,
+			noDeadline:  false,
+			expectError: true,
 		},
 		{
 			scenario: "webhook URL is denied",
@@ -137,10 +135,8 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				mod.denyList = regexp2.MustCompile("foo", 0)
 				return mod
 			}(),
-			noDeadline:       false,
-			expectError:      true,
-			expectHttpError:  true,
-			expectHttpStatus: http.StatusForbidden,
+			noDeadline:  false,
+			expectError: true,
 		},
 		{
 			scenario: "webhook error URL is not allowed",
@@ -155,10 +151,8 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				mod.errorAllowList = regexp2.MustCompile("foo", 0)
 				return mod
 			}(),
-			noDeadline:       false,
-			expectError:      true,
-			expectHttpError:  true,
-			expectHttpStatus: http.StatusForbidden,
+			noDeadline:  false,
+			expectError: true,
 		},
 		{
 			scenario: "webhook error URL is denied",
@@ -173,10 +167,8 @@ func TestWebhookMiddlewareGuards(t *testing.T) {
 				mod.errorDenyList = regexp2.MustCompile("bar", 0)
 				return mod
 			}(),
-			noDeadline:       false,
-			expectError:      true,
-			expectHttpError:  true,
-			expectHttpStatus: http.StatusForbidden,
+			noDeadline:  false,
+			expectError: true,
 		},
 		{
 			scenario: "invalid webhook method (GET)",
@@ -384,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),
@@ -398,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),
@@ -438,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),
@@ -501,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/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,60 @@
 
 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
+DOCKER_REGISTRY="$7"
+DOCKER_REPOSITORY="$8"
+LINUX_AMD64_RELEASE="$9"
 
+# 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 +65,18 @@ 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]}" \
+  $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-----