diff --git a/README.md b/README.md
index f26ed76..1b357f2 100644
--- a/README.md
+++ b/README.md
@@ -11,6 +11,7 @@ SDK **3.5** supports Module API **1.4**. First-party module packages live in the
 - Typed frontend contributions through [`frontend/index.d.ts`](frontend/index.d.ts): full-page routes, settings pages, menus, HTTP access, translations, notifications, and lifecycle events. The host supplies the Vue, router, Axios, and i18n instances—modules do not bundle another framework runtime.
 - Actions, panels, form sections and save hooks on host records (invoices, estimates, customers, payments and more), plus entries in the global New menu.
 - Company abilities contributed to the host's authorization catalogue, so a module can ship its own permissions instead of reusing host ones.
+- Whole invoices to read and structured XML to embed in invoice PDFs (Module API 1.5.0), for modules that produce e-invoices; see [Documents and invoice PDFs](#documents-and-invoice-pdfs).
 - Narrow host contracts under [`src/Contracts/Host`](src/Contracts/Host) for settings, authorization, and read-only company-data queries. `CompanyDataReader` covers the AI assistant's built-in queries plus `companyMembers()` and `existingInvoiceIds()` for modules that assign work to members or stamp their entries against invoices. Module code must not depend on InvoiceShelf Eloquent models.
 - AI drivers through [`src/Ai`](src/Ai): extend `AiDriver`, return `AiChatResponse`, and throw `AiException` for safe, localizable provider failures.
 
@@ -22,8 +23,8 @@ Declare compatibility in `module.json`, then test it against the host versions y
 
 | Concern | Current contract |
 | --- | --- |
-| SDK | `invoiceshelf/modules` `^3.5` |
-| Module API | `^1.3.0`, or `^1.4.0` for a module with bundled dependencies |
+| SDK | `invoiceshelf/modules` `^3.6` |
+| Module API | `^1.3.0`; `^1.4.0` for bundled dependencies and record slots; `^1.5.0` for documents and invoice PDF attachments |
 | Host application | Your explicit InvoiceShelf 3.x range |
 | PHP | The range your module actually supports |
 
@@ -241,6 +242,17 @@ extensions.registerCreateAction({ id: 'tasks.new', label: 'tasks.new_task', icon
 
 These slots are Module API **1.4.0** additions; declare `"module_api": "^1.4.0"` to use them.
 
+### Documents and invoice PDFs
+
+A module that turns invoices into other documents, such as an EN 16931 e-invoice, reads them through `InvoiceDocumentReader` and can hand the host an XML to embed in every invoice PDF.
+
+- **Reading.** `InvoiceDocumentReader::invoiceDocument($companyId, $invoiceId)` returns an `InvoiceDocument` ([`src/Documents/Data`](src/Documents/Data)): seller and buyer with addresses and tax identifiers, lines with their unit codes, document and line taxes with their EN 16931 category codes, the related invoice of a credit note, and the totals. Money is in hundredths exactly as stored, credit notes negative, nothing recalculated. An invoice of another company reads as `null`. `seller($companyId)` reads the company alone, for checks made before any invoice exists.
+- **Embedding.** Implement `InvoicePdfAttachmentProvider` and register it once: `Registry::registerInvoicePdfAttachmentProvider('e-invoicing', FacturXProvider::class)`. On every invoice PDF the host renders (download, public link, customer portal, mail attachment, archive), while the module is enabled and `PdfCapabilities::embedsFacturX()` is true, it calls `attachmentFor()` and embeds the returned `FacturXAttachment` as `factur-x.xml` in a PDF/A-3b file. `appliesTo()` must stay cheap: the host also calls it to decide whether an archived PDF is still current.
+- **Failures never block billing.** A provider that throws is reported and the invoice gets its ordinary PDF, as does a PDF service that rejects the attachment.
+- Only Gotenberg can build the container; with dompdf, `embedsFacturX()` is false and providers are not asked. Show that to your users instead of reading the host's configuration.
+
+These are Module API **1.5.0** additions; declare `"module_api": "^1.5.0"` to use them.
+
 ### Thin clients
 
 The InvoiceShelf mobile clients run the same frontend as the web app, but as a static app package
diff --git a/RELEASING.md b/RELEASING.md
index ee410fb..680a626 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -18,7 +18,7 @@ An official module normally calls the tagged SDK workflow from its own tag workf
 ```yaml
 jobs:
   release:
-    uses: InvoiceShelf/modules/.github/workflows/module-release.yml@3.5.0
+    uses: InvoiceShelf/modules/.github/workflows/module-release.yml@3.6.0
     with:
       channel: stable
     secrets: inherit
diff --git a/src/Contracts/Host/InvoiceDocumentReader.php b/src/Contracts/Host/InvoiceDocumentReader.php
new file mode 100644
index 0000000..dbaffdc
--- /dev/null
+++ b/src/Contracts/Host/InvoiceDocumentReader.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Contracts\Host;
+
+use InvoiceShelf\Modules\Documents\Data\DocumentParty;
+use InvoiceShelf\Modules\Documents\Data\InvoiceDocument;
+
+/**
+ * Reads whole invoices for modules that turn them into other documents, such
+ * as structured e-invoices. Module API 1.5.0.
+ *
+ * Every read is scoped to the company: an id from another company reads as
+ * null, exactly like one that does not exist.
+ */
+interface InvoiceDocumentReader
+{
+    public function invoiceDocument(int $companyId, int $invoiceId): ?InvoiceDocument;
+
+    /** The company as the seller of its documents, with its postal address; null when it does not exist. */
+    public function seller(int $companyId): ?DocumentParty;
+}
diff --git a/src/Contracts/Host/PdfCapabilities.php b/src/Contracts/Host/PdfCapabilities.php
new file mode 100644
index 0000000..662448b
--- /dev/null
+++ b/src/Contracts/Host/PdfCapabilities.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Contracts\Host;
+
+/**
+ * What the host's PDF rendering can do right now. Module API 1.5.0.
+ */
+interface PdfCapabilities
+{
+    /**
+     * Whether invoice PDFs can carry an embedded Factur-X / ZUGFeRD XML:
+     * true when they are rendered by a Gotenberg service recent enough to
+     * build the PDF/A-3 container. dompdf cannot.
+     */
+    public function embedsFacturX(): bool;
+}
diff --git a/src/Documents/Data/DocumentLine.php b/src/Documents/Data/DocumentLine.php
new file mode 100644
index 0000000..588271a
--- /dev/null
+++ b/src/Documents/Data/DocumentLine.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Documents\Data;
+
+/**
+ * One line of a document, in the order the document lists it.
+ *
+ * `quantity` is a decimal string. `unit_name` is the line's own snapshot and
+ * `unit_code` the UN/ECE Recommendation 20 code of the company unit by that
+ * name now, null when no unit matches. `description` is plain text. `taxes`
+ * is empty unless the document taxes each line. Amounts are in hundredths,
+ * see {@see InvoiceDocument}.
+ */
+final class DocumentLine
+{
+    /**
+     * @param  list<DocumentTax>  $taxes
+     */
+    public function __construct(
+        public readonly int $id,
+        public readonly string $name,
+        public readonly ?string $description,
+        public readonly string $quantity,
+        public readonly int $price,
+        public readonly int $discountVal,
+        public readonly int $total,
+        public readonly ?string $unitName = null,
+        public readonly ?string $unitCode = null,
+        public readonly array $taxes = [],
+    ) {}
+
+    /** @param  array<string, mixed>  $data */
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            Values::int($data, 'id'),
+            Values::string($data, 'name'),
+            Values::optionalString($data, 'description'),
+            Values::string($data, 'quantity'),
+            Values::int($data, 'price'),
+            Values::optionalInt($data, 'discount_val') ?? 0,
+            Values::int($data, 'total'),
+            Values::optionalString($data, 'unit_name'),
+            Values::optionalString($data, 'unit_code'),
+            array_map(DocumentTax::fromArray(...), Values::list($data, 'taxes')),
+        );
+    }
+
+    /** @return array<string, mixed> */
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id,
+            'name' => $this->name,
+            'description' => $this->description,
+            'quantity' => $this->quantity,
+            'price' => $this->price,
+            'discount_val' => $this->discountVal,
+            'total' => $this->total,
+            'unit_name' => $this->unitName,
+            'unit_code' => $this->unitCode,
+            'taxes' => array_map(static fn (DocumentTax $tax): array => $tax->toArray(), $this->taxes),
+        ];
+    }
+}
diff --git a/src/Documents/Data/DocumentParty.php b/src/Documents/Data/DocumentParty.php
new file mode 100644
index 0000000..de21a7b
--- /dev/null
+++ b/src/Documents/Data/DocumentParty.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Documents\Data;
+
+/**
+ * The seller (the company) or the buyer (the customer) of a document.
+ *
+ * `vat_id` and `tax_id` are what the host holds: a company has both; a
+ * customer has only `tax_id`, an untyped field that may hold a VAT identifier
+ * or a national tax number, so `vat_id` is null for a buyer.
+ */
+final class DocumentParty
+{
+    public function __construct(
+        public readonly string $name,
+        public readonly ?string $companyName = null,
+        public readonly ?string $vatId = null,
+        public readonly ?string $taxId = null,
+        public readonly ?string $email = null,
+        public readonly ?string $phone = null,
+        public readonly ?string $contactName = null,
+        public readonly ?PostalAddress $address = null,
+    ) {}
+
+    /** @param  array<string, mixed>  $data */
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            Values::string($data, 'name'),
+            Values::optionalString($data, 'company_name'),
+            Values::optionalString($data, 'vat_id'),
+            Values::optionalString($data, 'tax_id'),
+            Values::optionalString($data, 'email'),
+            Values::optionalString($data, 'phone'),
+            Values::optionalString($data, 'contact_name'),
+            is_array($data['address'] ?? null) ? PostalAddress::fromArray($data['address']) : null,
+        );
+    }
+
+    /** @return array<string, mixed> */
+    public function toArray(): array
+    {
+        return [
+            'name' => $this->name,
+            'company_name' => $this->companyName,
+            'vat_id' => $this->vatId,
+            'tax_id' => $this->taxId,
+            'email' => $this->email,
+            'phone' => $this->phone,
+            'contact_name' => $this->contactName,
+            'address' => $this->address?->toArray(),
+        ];
+    }
+}
diff --git a/src/Documents/Data/DocumentTax.php b/src/Documents/Data/DocumentTax.php
new file mode 100644
index 0000000..453c50a
--- /dev/null
+++ b/src/Documents/Data/DocumentTax.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Documents\Data;
+
+/**
+ * One tax row of a document or of a line, as stored.
+ *
+ * `name` and `percent` are the row's own snapshot; `category_code` (an EN 16931
+ * tax category such as `S`, `Z` or `E`) and `exemption_reason` come from the
+ * tax type as it is now. `percent` is a decimal string, null for a fixed tax,
+ * whose amount per line is `fixed_amount`. Amounts are in hundredths, see
+ * {@see InvoiceDocument}.
+ */
+final class DocumentTax
+{
+    public const CALCULATION_PERCENTAGE = 'percentage';
+
+    public const CALCULATION_FIXED = 'fixed';
+
+    public function __construct(
+        public readonly ?int $taxTypeId,
+        public readonly string $name,
+        public readonly ?string $percent,
+        public readonly int $amount,
+        public readonly string $calculationType = self::CALCULATION_PERCENTAGE,
+        public readonly ?int $fixedAmount = null,
+        public readonly bool $compound = false,
+        public readonly ?string $categoryCode = null,
+        public readonly ?string $exemptionReason = null,
+    ) {}
+
+    /** @param  array<string, mixed>  $data */
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            Values::optionalInt($data, 'tax_type_id'),
+            Values::string($data, 'name'),
+            Values::optionalString($data, 'percent'),
+            Values::int($data, 'amount'),
+            Values::optionalString($data, 'calculation_type') ?? self::CALCULATION_PERCENTAGE,
+            Values::optionalInt($data, 'fixed_amount'),
+            (bool) ($data['compound'] ?? false),
+            Values::optionalString($data, 'category_code'),
+            Values::optionalString($data, 'exemption_reason'),
+        );
+    }
+
+    /** @return array<string, mixed> */
+    public function toArray(): array
+    {
+        return [
+            'tax_type_id' => $this->taxTypeId,
+            'name' => $this->name,
+            'percent' => $this->percent,
+            'amount' => $this->amount,
+            'calculation_type' => $this->calculationType,
+            'fixed_amount' => $this->fixedAmount,
+            'compound' => $this->compound,
+            'category_code' => $this->categoryCode,
+            'exemption_reason' => $this->exemptionReason,
+        ];
+    }
+}
diff --git a/src/Documents/Data/InvoiceDocument.php b/src/Documents/Data/InvoiceDocument.php
new file mode 100644
index 0000000..ff824bb
--- /dev/null
+++ b/src/Documents/Data/InvoiceDocument.php
@@ -0,0 +1,145 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Documents\Data;
+
+use InvoiceShelf\Modules\Contracts\Host\InvoiceDocumentReader;
+
+/**
+ * An invoice or credit note as a module reads it: everything a structured
+ * document such as an EN 16931 e-invoice needs, as plain values.
+ *
+ * Read through {@see InvoiceDocumentReader}.
+ * Money is an integer in hundredths of the currency unit, exactly as the host
+ * stores it, for every currency whatever its precision (`currency_precision`
+ * is how many of those digits the currency shows). Amounts keep their stored
+ * sign: a credit note's prices, totals and taxes are negative. Nothing is
+ * recalculated. Dates are `Y-m-d`; `notes` is plain text with the host's
+ * placeholders already filled in. `tax_per_item` means each line carries its
+ * own `taxes`; otherwise the document-level `taxes` apply to every line.
+ * `exchange_rate` (a decimal string) converts to `company_currency_code`.
+ */
+final class InvoiceDocument
+{
+    public const TYPE_INVOICE = 'INVOICE';
+
+    public const TYPE_CREDIT_NOTE = 'CREDIT_NOTE';
+
+    /**
+     * @param  list<DocumentLine>  $lines
+     * @param  list<DocumentTax>  $taxes
+     */
+    public function __construct(
+        public readonly int $id,
+        public readonly int $companyId,
+        public readonly string $number,
+        public readonly string $type,
+        public readonly string $invoiceDate,
+        public readonly ?string $dueDate,
+        public readonly string $currencyCode,
+        public readonly int $currencyPrecision,
+        public readonly bool $taxPerItem,
+        public readonly bool $discountPerItem,
+        public readonly bool $taxIncluded,
+        public readonly int $subTotal,
+        public readonly int $discountVal,
+        public readonly int $tax,
+        public readonly int $total,
+        public readonly int $dueAmount,
+        public readonly DocumentParty $seller,
+        public readonly ?DocumentParty $buyer,
+        public readonly array $lines = [],
+        public readonly array $taxes = [],
+        public readonly ?string $referenceNumber = null,
+        public readonly ?string $notes = null,
+        public readonly ?string $creditReason = null,
+        public readonly ?RelatedDocument $related = null,
+        public readonly ?PostalAddress $deliveryAddress = null,
+        public readonly ?string $exchangeRate = null,
+        public readonly ?string $companyCurrencyCode = null,
+    ) {}
+
+    public function isCreditNote(): bool
+    {
+        return $this->type === self::TYPE_CREDIT_NOTE;
+    }
+
+    /** @param  array<string, mixed>  $data */
+    public static function fromArray(array $data): self
+    {
+        foreach (['seller', 'buyer', 'related', 'delivery_address'] as $key) {
+            if (($data[$key] ?? null) !== null && ! is_array($data[$key])) {
+                throw new \InvalidArgumentException("Document data needs '{$key}' to be an object or null.");
+            }
+        }
+
+        if (! is_array($data['seller'] ?? null)) {
+            throw new \InvalidArgumentException("Document data needs a 'seller'.");
+        }
+
+        return new self(
+            id: Values::int($data, 'id'),
+            companyId: Values::int($data, 'company_id'),
+            number: Values::string($data, 'number'),
+            type: Values::optionalString($data, 'type') ?? self::TYPE_INVOICE,
+            invoiceDate: Values::string($data, 'invoice_date'),
+            dueDate: Values::optionalString($data, 'due_date'),
+            currencyCode: Values::string($data, 'currency_code'),
+            currencyPrecision: Values::optionalInt($data, 'currency_precision') ?? 2,
+            taxPerItem: (bool) ($data['tax_per_item'] ?? false),
+            discountPerItem: (bool) ($data['discount_per_item'] ?? false),
+            taxIncluded: (bool) ($data['tax_included'] ?? false),
+            subTotal: Values::int($data, 'sub_total'),
+            discountVal: Values::optionalInt($data, 'discount_val') ?? 0,
+            tax: Values::int($data, 'tax'),
+            total: Values::int($data, 'total'),
+            dueAmount: Values::int($data, 'due_amount'),
+            seller: DocumentParty::fromArray($data['seller']),
+            buyer: isset($data['buyer']) ? DocumentParty::fromArray($data['buyer']) : null,
+            lines: array_map(DocumentLine::fromArray(...), Values::list($data, 'lines')),
+            taxes: array_map(DocumentTax::fromArray(...), Values::list($data, 'taxes')),
+            referenceNumber: Values::optionalString($data, 'reference_number'),
+            notes: Values::optionalString($data, 'notes'),
+            creditReason: Values::optionalString($data, 'credit_reason'),
+            related: isset($data['related']) ? RelatedDocument::fromArray($data['related']) : null,
+            deliveryAddress: isset($data['delivery_address']) ? PostalAddress::fromArray($data['delivery_address']) : null,
+            exchangeRate: Values::optionalString($data, 'exchange_rate'),
+            companyCurrencyCode: Values::optionalString($data, 'company_currency_code'),
+        );
+    }
+
+    /** @return array<string, mixed> */
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id,
+            'company_id' => $this->companyId,
+            'number' => $this->number,
+            'type' => $this->type,
+            'invoice_date' => $this->invoiceDate,
+            'due_date' => $this->dueDate,
+            'currency_code' => $this->currencyCode,
+            'currency_precision' => $this->currencyPrecision,
+            'tax_per_item' => $this->taxPerItem,
+            'discount_per_item' => $this->discountPerItem,
+            'tax_included' => $this->taxIncluded,
+            'sub_total' => $this->subTotal,
+            'discount_val' => $this->discountVal,
+            'tax' => $this->tax,
+            'total' => $this->total,
+            'due_amount' => $this->dueAmount,
+            'seller' => $this->seller->toArray(),
+            'buyer' => $this->buyer?->toArray(),
+            'lines' => array_map(static fn (DocumentLine $line): array => $line->toArray(), $this->lines),
+            'taxes' => array_map(static fn (DocumentTax $tax): array => $tax->toArray(), $this->taxes),
+            'reference_number' => $this->referenceNumber,
+            'notes' => $this->notes,
+            'credit_reason' => $this->creditReason,
+            'related' => $this->related?->toArray(),
+            'delivery_address' => $this->deliveryAddress?->toArray(),
+            'exchange_rate' => $this->exchangeRate,
+            'company_currency_code' => $this->companyCurrencyCode,
+        ];
+    }
+}
diff --git a/src/Documents/Data/PostalAddress.php b/src/Documents/Data/PostalAddress.php
new file mode 100644
index 0000000..f7fb183
--- /dev/null
+++ b/src/Documents/Data/PostalAddress.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Documents\Data;
+
+/**
+ * A postal address as the host stores it. The country is its ISO 3166-1
+ * alpha-2 code in upper case.
+ */
+final class PostalAddress
+{
+    public function __construct(
+        public readonly ?string $street1 = null,
+        public readonly ?string $street2 = null,
+        public readonly ?string $city = null,
+        public readonly ?string $state = null,
+        public readonly ?string $zip = null,
+        public readonly ?string $countryCode = null,
+        public readonly ?string $phone = null,
+    ) {}
+
+    /** @param  array<string, mixed>  $data */
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            Values::optionalString($data, 'address_street_1'),
+            Values::optionalString($data, 'address_street_2'),
+            Values::optionalString($data, 'city'),
+            Values::optionalString($data, 'state'),
+            Values::optionalString($data, 'zip'),
+            Values::optionalString($data, 'country_code'),
+            Values::optionalString($data, 'phone'),
+        );
+    }
+
+    /** @return array{address_street_1: ?string, address_street_2: ?string, city: ?string, state: ?string, zip: ?string, country_code: ?string, phone: ?string} */
+    public function toArray(): array
+    {
+        return [
+            'address_street_1' => $this->street1,
+            'address_street_2' => $this->street2,
+            'city' => $this->city,
+            'state' => $this->state,
+            'zip' => $this->zip,
+            'country_code' => $this->countryCode,
+            'phone' => $this->phone,
+        ];
+    }
+}
diff --git a/src/Documents/Data/RelatedDocument.php b/src/Documents/Data/RelatedDocument.php
new file mode 100644
index 0000000..ac46c16
--- /dev/null
+++ b/src/Documents/Data/RelatedDocument.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Documents\Data;
+
+/**
+ * The document another one refers to, such as the invoice a credit note
+ * corrects. `date` is `Y-m-d`.
+ */
+final class RelatedDocument
+{
+    public function __construct(
+        public readonly int $id,
+        public readonly string $number,
+        public readonly ?string $date,
+    ) {}
+
+    /** @param  array<string, mixed>  $data */
+    public static function fromArray(array $data): self
+    {
+        return new self(Values::int($data, 'id'), Values::string($data, 'number'), Values::optionalString($data, 'date'));
+    }
+
+    /** @return array{id: int, number: string, date: ?string} */
+    public function toArray(): array
+    {
+        return ['id' => $this->id, 'number' => $this->number, 'date' => $this->date];
+    }
+}
diff --git a/src/Documents/Data/Values.php b/src/Documents/Data/Values.php
new file mode 100644
index 0000000..524b0c3
--- /dev/null
+++ b/src/Documents/Data/Values.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Documents\Data;
+
+use InvalidArgumentException;
+
+/**
+ * Reads typed values out of the arrays the document data is built from, so a
+ * missing or mistyped key fails loudly instead of turning into a zero.
+ *
+ * @internal
+ */
+final class Values
+{
+    /** @param  array<string, mixed>  $data */
+    public static function string(array $data, string $key): string
+    {
+        $value = $data[$key] ?? null;
+
+        if (! is_string($value) && ! is_int($value) && ! is_float($value)) {
+            throw new InvalidArgumentException("Document data needs a string '{$key}'.");
+        }
+
+        return (string) $value;
+    }
+
+    /** @param  array<string, mixed>  $data */
+    public static function optionalString(array $data, string $key): ?string
+    {
+        return ($data[$key] ?? null) === null ? null : self::string($data, $key);
+    }
+
+    /** @param  array<string, mixed>  $data */
+    public static function int(array $data, string $key): int
+    {
+        $value = $data[$key] ?? null;
+
+        if (! is_int($value) && ! (is_string($value) && preg_match('/^-?\d+$/', $value) === 1)) {
+            throw new InvalidArgumentException("Document data needs an integer '{$key}'.");
+        }
+
+        return (int) $value;
+    }
+
+    /** @param  array<string, mixed>  $data */
+    public static function optionalInt(array $data, string $key): ?int
+    {
+        return ($data[$key] ?? null) === null ? null : self::int($data, $key);
+    }
+
+    /**
+     * @param  array<string, mixed>  $data
+     * @return list<array<string, mixed>>
+     */
+    public static function list(array $data, string $key): array
+    {
+        $value = $data[$key] ?? [];
+
+        if (! is_array($value) || ! array_is_list($value)) {
+            throw new InvalidArgumentException("Document data needs a list '{$key}'.");
+        }
+
+        foreach ($value as $entry) {
+            if (! is_array($entry)) {
+                throw new InvalidArgumentException("Every entry of '{$key}' must be an object.");
+            }
+        }
+
+        return $value;
+    }
+}
diff --git a/src/Pdf/Contracts/InvoicePdfAttachmentProvider.php b/src/Pdf/Contracts/InvoicePdfAttachmentProvider.php
new file mode 100644
index 0000000..674eb01
--- /dev/null
+++ b/src/Pdf/Contracts/InvoicePdfAttachmentProvider.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Pdf\Contracts;
+
+use InvoiceShelf\Modules\Contracts\Host\PdfCapabilities;
+use InvoiceShelf\Modules\Pdf\Data\FacturXAttachment;
+use InvoiceShelf\Modules\Registry;
+
+/**
+ * Supplies the structured XML the host embeds in an invoice's PDF, which
+ * turns it into a hybrid e-invoice. Register the class with
+ * {@see Registry::registerInvoicePdfAttachmentProvider()}.
+ * Module API 1.5.0.
+ *
+ * The host asks on every invoice PDF it renders (download, public link,
+ * customer portal, mail attachment, archive), only while the module is
+ * enabled and only when {@see PdfCapabilities::embedsFacturX()}
+ * is true. The first provider that returns an attachment wins. An exception
+ * is reported and the invoice gets its ordinary PDF: a provider can never
+ * stop an invoice from being delivered.
+ */
+interface InvoicePdfAttachmentProvider
+{
+    /**
+     * Whether this provider may attach anything to the company's invoices at
+     * all, such as a setting being on. Keep it cheap: no document work. The
+     * host also uses it to decide whether an archived PDF is still current.
+     */
+    public function appliesTo(int $companyId): bool;
+
+    /** The XML to embed in this invoice's PDF, or null for the ordinary PDF. */
+    public function attachmentFor(int $companyId, int $invoiceId): ?FacturXAttachment;
+}
diff --git a/src/Pdf/Data/FacturXAttachment.php b/src/Pdf/Data/FacturXAttachment.php
new file mode 100644
index 0000000..b4a9751
--- /dev/null
+++ b/src/Pdf/Data/FacturXAttachment.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Pdf\Data;
+
+use InvalidArgumentException;
+
+/**
+ * A Factur-X / ZUGFeRD XML to embed in an invoice PDF, with the profile it
+ * conforms to. The host embeds it as `factur-x.xml` in a PDF/A-3b file and
+ * writes the profile into the file's metadata.
+ */
+final class FacturXAttachment
+{
+    public const FILENAME = 'factur-x.xml';
+
+    public const PROFILE_EN16931 = 'EN 16931';
+
+    /** The conformance levels the Factur-X metadata can name. */
+    public const PROFILES = ['MINIMUM', 'BASIC WL', 'BASIC', self::PROFILE_EN16931, 'EXTENDED', 'XRECHNUNG'];
+
+    public function __construct(
+        public readonly string $xml,
+        public readonly string $profile = self::PROFILE_EN16931,
+    ) {
+        if (trim($xml) === '') {
+            throw new InvalidArgumentException('A Factur-X attachment needs its XML.');
+        }
+
+        if (! in_array($profile, self::PROFILES, true)) {
+            throw new InvalidArgumentException("Factur-X profile '{$profile}' must be one of: ".implode(', ', self::PROFILES).'.');
+        }
+    }
+}
diff --git a/src/Registry.php b/src/Registry.php
index 919f159..e2e8a64 100644
--- a/src/Registry.php
+++ b/src/Registry.php
@@ -6,6 +6,7 @@
 
 use InvalidArgumentException;
 use InvoiceShelf\Modules\Ai\Contracts\AiDriver;
+use InvoiceShelf\Modules\Pdf\Contracts\InvoicePdfAttachmentProvider;
 use InvoiceShelf\Modules\Settings\Schema;
 
 /**
@@ -18,6 +19,9 @@
  */
 class Registry
 {
+    /** The driver type invoice PDF attachment providers are stored under, keyed by module slug. */
+    public const INVOICE_PDF_ATTACHMENT = 'invoice_pdf_attachment';
+
     /**
      * Sidebar items keyed by module slug.
      *
@@ -380,6 +384,38 @@ private static function validateAiDriver(string $name, array $meta): void
         }
     }
 
+    /**
+     * Register the class that supplies the XML embedded in the module's
+     * invoice PDFs. Module API 1.5.0; see InvoicePdfAttachmentProvider.
+     *
+     * One per module. Registering the same class again is a no-op, as
+     * providers boot on every request.
+     *
+     * @param  class-string<InvoicePdfAttachmentProvider>  $class
+     */
+    public static function registerInvoicePdfAttachmentProvider(string $slug, string $class): void
+    {
+        if (! preg_match('/^[a-z0-9]+(?:-[a-z0-9]+)*$/', $slug)) {
+            throw new InvalidArgumentException("Module slug '{$slug}' must be lower-case kebab-case, matching the module.json slug.");
+        }
+
+        if (! class_exists($class) || ! is_subclass_of($class, InvoicePdfAttachmentProvider::class) || (new \ReflectionClass($class))->isAbstract()) {
+            throw new InvalidArgumentException('Invoice PDF attachment provider must be a concrete class implementing '.InvoicePdfAttachmentProvider::class.'.');
+        }
+
+        $meta = ['class' => $class];
+
+        if ((static::$drivers[self::INVOICE_PDF_ATTACHMENT][$slug] ?? null) === $meta) {
+            return;
+        }
+
+        if (isset(static::$drivers[self::INVOICE_PDF_ATTACHMENT][$slug])) {
+            throw new InvalidArgumentException("Module '{$slug}' already registered an invoice PDF attachment provider.");
+        }
+
+        static::registerDriver(self::INVOICE_PDF_ATTACHMENT, $slug, $meta);
+    }
+
     /**
      * Get all registered drivers for a given type.
      *
diff --git a/tests/DocumentContractsTest.php b/tests/DocumentContractsTest.php
new file mode 100644
index 0000000..7804ee8
--- /dev/null
+++ b/tests/DocumentContractsTest.php
@@ -0,0 +1,191 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InvoiceShelf\Modules\Tests;
+
+use InvalidArgumentException;
+use InvoiceShelf\Modules\Contracts\Host\InvoiceDocumentReader;
+use InvoiceShelf\Modules\Contracts\Host\PdfCapabilities;
+use InvoiceShelf\Modules\Documents\Data\DocumentParty;
+use InvoiceShelf\Modules\Documents\Data\DocumentTax;
+use InvoiceShelf\Modules\Documents\Data\InvoiceDocument;
+use InvoiceShelf\Modules\Pdf\Contracts\InvoicePdfAttachmentProvider;
+use InvoiceShelf\Modules\Pdf\Data\FacturXAttachment;
+use PHPUnit\Framework\Attributes\DataProvider;
+use ReflectionClass;
+use ReflectionMethod;
+
+class DocumentContractsTest extends TestCase
+{
+    public function test_host_contracts_expose_the_exact_document_boundary(): void
+    {
+        $this->assertSame(['invoiceDocument', 'seller'], $this->methods(InvoiceDocumentReader::class));
+        $this->assertSame(['embedsFacturX'], $this->methods(PdfCapabilities::class));
+        $this->assertSame(['appliesTo', 'attachmentFor'], $this->methods(InvoicePdfAttachmentProvider::class));
+
+        $read = new ReflectionMethod(InvoiceDocumentReader::class, 'invoiceDocument');
+        $this->assertSame(['int', 'int'], array_map(static fn ($parameter): string => (string) $parameter->getType(), $read->getParameters()));
+        $this->assertSame('?'.InvoiceDocument::class, (string) $read->getReturnType());
+        $this->assertSame('?'.DocumentParty::class, (string) (new ReflectionMethod(InvoiceDocumentReader::class, 'seller'))->getReturnType());
+        $this->assertSame('?'.FacturXAttachment::class, (string) (new ReflectionMethod(InvoicePdfAttachmentProvider::class, 'attachmentFor'))->getReturnType());
+    }
+
+    public function test_an_invoice_document_round_trips_through_its_array_shape(): void
+    {
+        $data = self::creditNote();
+
+        $document = InvoiceDocument::fromArray($data);
+
+        $this->assertSame($data, $document->toArray());
+        $this->assertTrue($document->isCreditNote());
+        $this->assertSame('DE123456789', $document->seller->vatId);
+        $this->assertSame('DE', $document->buyer?->address?->countryCode);
+        $this->assertSame('RE-2026-0001', $document->related?->number);
+        $this->assertSame('-2.00', $document->lines[0]->quantity);
+        $this->assertSame('S', $document->lines[0]->taxes[0]->categoryCode);
+        $this->assertSame(DocumentTax::CALCULATION_PERCENTAGE, $document->lines[0]->taxes[0]->calculationType);
+    }
+
+    public function test_optional_parts_default_when_absent(): void
+    {
+        $data = self::creditNote();
+        unset($data['type'], $data['buyer'], $data['related'], $data['delivery_address'], $data['lines'], $data['taxes'], $data['currency_precision']);
+
+        $document = InvoiceDocument::fromArray($data);
+
+        $this->assertFalse($document->isCreditNote());
+        $this->assertNull($document->buyer);
+        $this->assertSame([], $document->lines);
+        $this->assertSame(2, $document->currencyPrecision);
+    }
+
+    /** @param  array<string, mixed>  $changes */
+    #[DataProvider('malformedDocuments')]
+    public function test_malformed_document_data_is_rejected(array $changes, string $message): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage($message);
+
+        InvoiceDocument::fromArray(array_replace(self::creditNote(), $changes));
+    }
+
+    /** @return iterable<string, array{array<string, mixed>, string}> */
+    public static function malformedDocuments(): iterable
+    {
+        yield 'missing number' => [['number' => null], "a string 'number'"];
+        yield 'fractional total' => [['total' => '12.50'], "an integer 'total'"];
+        yield 'missing seller' => [['seller' => null], "a 'seller'"];
+        yield 'scalar buyer' => [['buyer' => 'Muster GmbH'], "'buyer' to be an object or null"];
+        yield 'lines as a map' => [['lines' => ['first' => []]], "a list 'lines'"];
+        yield 'scalar line' => [['lines' => ['one']], "Every entry of 'lines'"];
+    }
+
+    public function test_a_facturx_attachment_needs_xml_and_a_known_profile(): void
+    {
+        $attachment = new FacturXAttachment('<rsm:CrossIndustryInvoice/>');
+
+        $this->assertSame(FacturXAttachment::PROFILE_EN16931, $attachment->profile);
+        $this->assertSame('factur-x.xml', FacturXAttachment::FILENAME);
+        $this->assertSame('XRECHNUNG', (new FacturXAttachment('<x/>', 'XRECHNUNG'))->profile);
+
+        foreach ([['  ', FacturXAttachment::PROFILE_EN16931, 'needs its XML'], ['<x/>', 'EN16931', 'must be one of']] as [$xml, $profile, $message]) {
+            try {
+                new FacturXAttachment($xml, $profile);
+                $this->fail("Expected '{$message}'.");
+            } catch (InvalidArgumentException $exception) {
+                $this->assertStringContainsString($message, $exception->getMessage());
+            }
+        }
+    }
+
+    /** @return list<string> */
+    private function methods(string $interface): array
+    {
+        return array_map(static fn (ReflectionMethod $method): string => $method->getName(), (new ReflectionClass($interface))->getMethods());
+    }
+
+    /** @return array<string, mixed> */
+    private static function creditNote(): array
+    {
+        $address = static fn (string $street, string $zip, string $city): array => [
+            'address_street_1' => $street,
+            'address_street_2' => null,
+            'city' => $city,
+            'state' => null,
+            'zip' => $zip,
+            'country_code' => 'DE',
+            'phone' => null,
+        ];
+        $tax = [
+            'tax_type_id' => 3,
+            'name' => 'VAT',
+            'percent' => '19.00',
+            'amount' => -1900,
+            'calculation_type' => 'percentage',
+            'fixed_amount' => null,
+            'compound' => false,
+            'category_code' => 'S',
+            'exemption_reason' => null,
+        ];
+
+        return [
+            'id' => 7,
+            'company_id' => 1,
+            'number' => 'CN-2026-0001',
+            'type' => 'CREDIT_NOTE',
+            'invoice_date' => '2026-10-24',
+            'due_date' => null,
+            'currency_code' => 'EUR',
+            'currency_precision' => 2,
+            'tax_per_item' => true,
+            'discount_per_item' => false,
+            'tax_included' => false,
+            'sub_total' => -10000,
+            'discount_val' => 0,
+            'tax' => -1900,
+            'total' => -11900,
+            'due_amount' => 0,
+            'seller' => [
+                'name' => 'Acme GmbH',
+                'company_name' => null,
+                'vat_id' => 'DE123456789',
+                'tax_id' => '12/345/67890',
+                'email' => null,
+                'phone' => '+49 30 1234567',
+                'contact_name' => null,
+                'address' => $address('Hauptstraße 1', '10115', 'Berlin'),
+            ],
+            'buyer' => [
+                'name' => 'Erika Muster',
+                'company_name' => 'Muster GmbH',
+                'vat_id' => null,
+                'tax_id' => null,
+                'email' => 'erika@muster.test',
+                'phone' => null,
+                'contact_name' => 'Erika Muster',
+                'address' => $address('Marktplatz 5', '80331', 'München'),
+            ],
+            'lines' => [[
+                'id' => 11,
+                'name' => 'Consulting',
+                'description' => 'On site',
+                'quantity' => '-2.00',
+                'price' => 5000,
+                'discount_val' => 0,
+                'total' => -10000,
+                'unit_name' => 'hour',
+                'unit_code' => 'HUR',
+                'taxes' => [$tax],
+            ]],
+            'taxes' => [],
+            'reference_number' => 'RE-2026-0001',
+            'notes' => 'Thank you.',
+            'credit_reason' => 'Returned goods',
+            'related' => ['id' => 6, 'number' => 'RE-2026-0001', 'date' => '2026-10-01'],
+            'delivery_address' => null,
+            'exchange_rate' => '1.000000',
+            'company_currency_code' => 'EUR',
+        ];
+    }
+}
diff --git a/tests/RegistryTest.php b/tests/RegistryTest.php
index e8d41d5..1dfab86 100644
--- a/tests/RegistryTest.php
+++ b/tests/RegistryTest.php
@@ -7,6 +7,8 @@
 use InvalidArgumentException;
 use InvoiceShelf\Modules\Ai\Contracts\AiDriver;
 use InvoiceShelf\Modules\Ai\Data\AiChatResponse;
+use InvoiceShelf\Modules\Pdf\Contracts\InvoicePdfAttachmentProvider;
+use InvoiceShelf\Modules\Pdf\Data\FacturXAttachment;
 use InvoiceShelf\Modules\Registry;
 use InvoiceShelf\Modules\Settings\Schema;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -417,6 +419,49 @@ private static function validAiMeta(): array
         ];
     }
 
+    public function test_invoice_pdf_attachment_provider_is_registered_per_module(): void
+    {
+        Registry::flushDrivers();
+        Registry::registerInvoicePdfAttachmentProvider('e-invoicing', FakeAttachmentProvider::class);
+        Registry::registerInvoicePdfAttachmentProvider('e-invoicing', FakeAttachmentProvider::class);
+
+        $this->assertSame(
+            ['e-invoicing' => ['class' => FakeAttachmentProvider::class]],
+            Registry::allDrivers(Registry::INVOICE_PDF_ATTACHMENT),
+        );
+    }
+
+    public function test_invoice_pdf_attachment_provider_rejects_a_second_class_for_one_module(): void
+    {
+        Registry::flushDrivers();
+        Registry::registerInvoicePdfAttachmentProvider('e-invoicing', FakeAttachmentProvider::class);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('already registered an invoice PDF attachment provider');
+
+        Registry::registerInvoicePdfAttachmentProvider('e-invoicing', OtherFakeAttachmentProvider::class);
+    }
+
+    #[DataProvider('invalidAttachmentProviders')]
+    public function test_invoice_pdf_attachment_provider_rejects_malformed_registrations(string $slug, string $class, string $message): void
+    {
+        Registry::flushDrivers();
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage($message);
+
+        Registry::registerInvoicePdfAttachmentProvider($slug, $class);
+    }
+
+    /** @return iterable<string, array{string, string, string}> */
+    public static function invalidAttachmentProviders(): iterable
+    {
+        yield 'non-kebab slug' => ['EInvoicing', FakeAttachmentProvider::class, 'lower-case kebab-case'];
+        yield 'missing class' => ['e-invoicing', 'Missing\\Provider', 'concrete class implementing'];
+        yield 'unrelated class' => ['e-invoicing', self::class, 'concrete class implementing'];
+        yield 'abstract class' => ['e-invoicing', AbstractFakeAttachmentProvider::class, 'concrete class implementing'];
+    }
+
     public function test_all_drivers_returns_empty_array_for_unknown_type(): void
     {
         Registry::flushDrivers();
@@ -615,3 +660,20 @@ public function validateConnection(): array
 }
 
 abstract class AbstractFakeAiDriver extends AiDriver {}
+
+class FakeAttachmentProvider implements InvoicePdfAttachmentProvider
+{
+    public function appliesTo(int $companyId): bool
+    {
+        return true;
+    }
+
+    public function attachmentFor(int $companyId, int $invoiceId): ?FacturXAttachment
+    {
+        return new FacturXAttachment('<rsm:CrossIndustryInvoice/>');
+    }
+}
+
+class OtherFakeAttachmentProvider extends FakeAttachmentProvider {}
+
+abstract class AbstractFakeAttachmentProvider implements InvoicePdfAttachmentProvider {}