diff --git a/app/Console/Commands/CheckInvoiceStatus.php b/app/Console/Commands/CheckInvoiceStatus.php
index 564607b8..be6e1a75 100644
--- a/app/Console/Commands/CheckInvoiceStatus.php
+++ b/app/Console/Commands/CheckInvoiceStatus.php
@@ -40,7 +40,10 @@ class CheckInvoiceStatus extends Command
     public function handle(): void
     {
         $date = Carbon::now();
-        $invoices = Invoice::whereNotIn('status', [Invoice::STATUS_COMPLETED, Invoice::STATUS_DRAFT])
+        // Only real invoices can fall overdue: a credit note is never owed, so
+        // it must never be flagged no matter what date it carries.
+        $invoices = Invoice::where('type', Invoice::TYPE_INVOICE)
+            ->whereNotIn('status', [Invoice::STATUS_COMPLETED, Invoice::STATUS_DRAFT])
             ->where('overdue', false)
             ->whereDate('due_date', '<', $date)
             ->get();
diff --git a/app/Http/Controllers/Company/Dashboard/DashboardController.php b/app/Http/Controllers/Company/Dashboard/DashboardController.php
index 805f1ba6..8e7ad2f5 100644
--- a/app/Http/Controllers/Company/Dashboard/DashboardController.php
+++ b/app/Http/Controllers/Company/Dashboard/DashboardController.php
@@ -121,12 +121,22 @@ class DashboardController extends Controller
         ];
 
         $total_customer_count = Customer::whereCompany()->count();
+        // "How many invoices did we issue" counts issued documents, so the
+        // reversals are excluded. The sums above deliberately keep them: a
+        // credit note's negated total is exactly what nets sales back out.
         $total_invoice_count = Invoice::whereCompany()
+            ->where('type', Invoice::TYPE_INVOICE)
             ->count();
         $total_estimate_count = Estimate::whereCompany()->count();
         $total_amount_due = Invoice::whereCompany()
             ->sum('base_due_amount');
 
+        // Raw models, not InvoiceResource: every loaded relation is serialized
+        // with the full $appends set, so a column-limited creditNotes load blew
+        // up in the date accessors (no company_id on the children) and a full
+        // load would run the appends per credit note for nothing. The rows do
+        // not need the relation: credited_status is a resource-level field, and
+        // a fully credited invoice has no due amount so it never appears here.
         $recent_due_invoices = Invoice::with('customer')
             ->whereCompany()
             ->where('base_due_amount', '>', 0)
diff --git a/app/Http/Controllers/Company/General/SerialNumberController.php b/app/Http/Controllers/Company/General/SerialNumberController.php
index 61dc98b0..0c746886 100644
--- a/app/Http/Controllers/Company/General/SerialNumberController.php
+++ b/app/Http/Controllers/Company/General/SerialNumberController.php
@@ -23,7 +23,19 @@ class SerialNumberController extends Controller
         try {
             switch ($key) {
                 case 'invoice':
+                    // Scoped exactly like every invoice create path, so the
+                    // settings preview can never count credit-note rows.
                     $nextNumber = $serial->setModel($invoice)
+                        ->setSequenceScope(['type' => Invoice::TYPE_INVOICE])
+                        ->setModelObject($request->model_id)
+                        ->getNextNumber();
+
+                    break;
+
+                case 'credit_note':
+                    $nextNumber = $serial->setModel($invoice)
+                        ->setSettingKey('credit_note_number_format')
+                        ->setSequenceScope(['type' => Invoice::TYPE_CREDIT_NOTE])
                         ->setModelObject($request->model_id)
                         ->getNextNumber();
 
diff --git a/app/Http/Controllers/Company/Invoice/InvoicesController.php b/app/Http/Controllers/Company/Invoice/InvoicesController.php
index 980c7ec2..8ef66ff6 100644
--- a/app/Http/Controllers/Company/Invoice/InvoicesController.php
+++ b/app/Http/Controllers/Company/Invoice/InvoicesController.php
@@ -4,22 +4,27 @@ namespace App\Http\Controllers\Company\Invoice;
 
 use App\Http\Controllers\Controller;
 use App\Http\Requests;
+use App\Http\Requests\CreateCreditNoteRequest;
 use App\Http\Requests\DeleteInvoiceRequest;
 use App\Http\Requests\SendInvoiceRequest;
+use App\Http\Resources\CreditNoteResource;
 use App\Http\Resources\EstimateResource;
 use App\Http\Resources\InvoiceResource;
 use App\Jobs\GenerateInvoicePdfJob;
 use App\Models\Estimate;
 use App\Models\Invoice;
+use App\Services\Document\CreditNoteService;
 use App\Services\Document\InvoiceService;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 use Illuminate\Mail\Markdown;
+use Illuminate\Validation\ValidationException;
 
 class InvoicesController extends Controller
 {
     public function __construct(
         private readonly InvoiceService $invoiceService,
+        private readonly CreditNoteService $creditNoteService,
     ) {}
 
     /**
@@ -33,9 +38,11 @@ class InvoicesController extends Controller
 
         $limit = $request->input('limit', 10);
 
+        // creditNotes drives the "cancelled" badge on every row, so it is
+        // eager-loaded (two columns) rather than probed per row.
         $invoices = Invoice::whereCompany()
             ->applyFilters($request->all())
-            ->with('customer')
+            ->with(['customer', 'creditNotes:id,related_invoice_id,invoice_number,total'])
             ->latest()
             ->paginateData($limit);
 
@@ -75,7 +82,17 @@ class InvoicesController extends Controller
     {
         $this->authorize('view', $invoice);
 
-        return new InvoiceResource($invoice);
+        if ($invoice->isCreditNote()) {
+            return new CreditNoteResource($invoice->load('relatedInvoice'));
+        }
+
+        // Feeds the credit-note banner on the detail page: how much of the
+        // invoice has been credited, and how much of each line, so the partial
+        // credit form can offer the remaining quantities.
+        return new InvoiceResource($invoice->load([
+            'creditNotes:id,related_invoice_id,invoice_number,total',
+            'creditNotes.items:id,invoice_id,source_invoice_item_id,quantity',
+        ]));
     }
 
     /**
@@ -136,7 +153,11 @@ class InvoicesController extends Controller
         $data = $this->invoiceService->sendInvoiceData($invoice, $request->all());
         $data['url'] = $invoice->invoicePdfUrl;
 
-        return $markdown->render('emails.send.invoice', ['data' => $data]);
+        // Preview the template that will actually be sent: a credit note goes
+        // out through SendCreditNoteMail, so it must preview as one.
+        $view = $invoice->isCreditNote() ? 'emails.send.credit-note' : 'emails.send.invoice';
+
+        return $markdown->render($view, ['data' => $data]);
     }
 
     public function clone(Request $request, Invoice $invoice)
@@ -144,6 +165,14 @@ class InvoicesController extends Controller
         $this->authorize('view', $invoice);
         $this->authorize('create', Invoice::class);
 
+        // Cloning a credit note would mint a positive invoice out of a reversal
+        // document. Domain rule violation (422), not an authorization failure.
+        if ($invoice->isCreditNote()) {
+            throw ValidationException::withMessages([
+                'invoice' => ['a_credit_note_cannot_be_cloned'],
+            ]);
+        }
+
         $newInvoice = $this->invoiceService->clone($invoice);
 
         return new InvoiceResource($newInvoice);
@@ -156,11 +185,59 @@ class InvoicesController extends Controller
         $this->authorize('view', $invoice);
         $this->authorize('create', Estimate::class);
 
+        // Same reason as clone(): the conversion copies the amounts unnegated,
+        // so a credit note would become a positive estimate.
+        if ($invoice->isCreditNote()) {
+            throw ValidationException::withMessages([
+                'invoice' => ['a_credit_note_cannot_be_converted_to_an_estimate'],
+            ]);
+        }
+
         $estimate = $this->invoiceService->convertToEstimate($invoice);
 
         return new EstimateResource($estimate);
     }
 
+    public function createCreditNote(CreateCreditNoteRequest $request, Invoice $invoice)
+    {
+        $this->authorize('create credit note', $invoice);
+
+        // A credit note can only reverse a real invoice, never another credit
+        // note. This is a domain rule (422), not an authorization failure (403).
+        if ($invoice->isCreditNote()) {
+            throw ValidationException::withMessages([
+                'invoice' => ['a_credit_note_cannot_be_created_from_a_credit_note'],
+            ]);
+        }
+
+        // A draft was never issued, so there is nothing to reverse: edit or
+        // delete it instead.
+        if ($invoice->status === Invoice::STATUS_DRAFT) {
+            throw ValidationException::withMessages([
+                'invoice' => ['a_draft_invoice_cannot_be_credited'],
+            ]);
+        }
+
+        // How much of the invoice is still creditable, and whether the credit
+        // fits inside its unpaid balance, is decided by the service under a row
+        // lock. Guarding it here would race.
+        $creditNote = $this->creditNoteService->create(
+            $invoice,
+            $request->input('items', []),
+            $request->input('reason')
+        );
+
+        GenerateInvoicePdfJob::dispatch($creditNote);
+
+        // The original's own PDF changed too: its balance moved and it now
+        // carries the cancellation banner, so the stored file is replaced.
+        GenerateInvoicePdfJob::dispatch($invoice->fresh(), true);
+
+        return (new CreditNoteResource($creditNote))
+            ->response()
+            ->setStatusCode(201);
+    }
+
     public function changeStatus(Request $request, Invoice $invoice)
     {
         $this->authorize('send invoice', $invoice);
diff --git a/app/Http/Controllers/CustomerPortal/General/DashboardController.php b/app/Http/Controllers/CustomerPortal/General/DashboardController.php
index 40f558cf..6a900d4e 100644
--- a/app/Http/Controllers/CustomerPortal/General/DashboardController.php
+++ b/app/Http/Controllers/CustomerPortal/General/DashboardController.php
@@ -24,7 +24,10 @@ class DashboardController extends Controller
         $amountDue = Invoice::whereCustomer($user->id)
             ->where('status', '<>', 'DRAFT')
             ->sum('due_amount');
+        // Counts issued invoices only; a credit note is a reversal document,
+        // not another invoice the customer received.
         $invoiceCount = Invoice::whereCustomer($user->id)
+            ->where('type', Invoice::TYPE_INVOICE)
             ->where('status', '<>', 'DRAFT')
             ->count();
         $estimatesCount = Estimate::whereCustomer($user->id)
diff --git a/app/Http/Controllers/CustomerPortal/Invoice/InvoicesController.php b/app/Http/Controllers/CustomerPortal/Invoice/InvoicesController.php
index 8e8d4335..5d157056 100644
--- a/app/Http/Controllers/CustomerPortal/Invoice/InvoicesController.php
+++ b/app/Http/Controllers/CustomerPortal/Invoice/InvoicesController.php
@@ -30,7 +30,9 @@ class InvoicesController extends Controller
 
         return InvoiceResource::collection($invoices)
             ->additional(['meta' => [
-                'invoiceTotalCount' => Invoice::where('status', '<>', 'DRAFT')->whereCustomer(Auth::guard('customer')->id())->count(),
+                // Issued invoices only: a credit note is a reversal document,
+                // not another invoice the customer received.
+                'invoiceTotalCount' => Invoice::where('type', Invoice::TYPE_INVOICE)->where('status', '<>', 'DRAFT')->whereCustomer(Auth::guard('customer')->id())->count(),
             ]]);
     }
 
diff --git a/app/Http/Requests/CreateCreditNoteRequest.php b/app/Http/Requests/CreateCreditNoteRequest.php
new file mode 100644
index 00000000..e2066b49
--- /dev/null
+++ b/app/Http/Requests/CreateCreditNoteRequest.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class CreateCreditNoteRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * The controller authorizes the ability against the invoice being credited.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * "items" is optional: an absent or empty list credits every remaining
+     * quantity of the invoice, which is the full reversal. Each supplied line
+     * must name a line of THIS invoice, once, with a positive quantity; how
+     * much of it is still creditable is a domain invariant and belongs to
+     * CreditNoteService, which decides it under a row lock.
+     */
+    public function rules(): array
+    {
+        return [
+            'reason' => [
+                'nullable',
+                'string',
+                'max:1000',
+            ],
+            'items' => [
+                'sometimes',
+                'array',
+            ],
+            'items.*.id' => [
+                'required',
+                'integer',
+                'distinct',
+                Rule::exists('invoice_items', 'id')->where('invoice_id', $this->route('invoice')->id),
+            ],
+            'items.*.quantity' => [
+                'required',
+                'numeric',
+                'gt:0',
+            ],
+        ];
+    }
+
+    /**
+     * The message string IS the translation key here, as everywhere else in the
+     * app: the front end maps it to a localized string.
+     */
+    public function messages(): array
+    {
+        return [
+            'items.*.id.required' => 'credit_item_not_on_invoice',
+            'items.*.id.integer' => 'credit_item_not_on_invoice',
+            'items.*.id.distinct' => 'credit_item_not_on_invoice',
+            'items.*.id.exists' => 'credit_item_not_on_invoice',
+            'items.*.quantity.required' => 'credit_quantity_invalid',
+            'items.*.quantity.numeric' => 'credit_quantity_invalid',
+            'items.*.quantity.gt' => 'credit_quantity_invalid',
+        ];
+    }
+}
diff --git a/app/Http/Requests/DeleteInvoiceRequest.php b/app/Http/Requests/DeleteInvoiceRequest.php
index b5e87509..0ddf09ff 100644
--- a/app/Http/Requests/DeleteInvoiceRequest.php
+++ b/app/Http/Requests/DeleteInvoiceRequest.php
@@ -3,6 +3,7 @@
 namespace App\Http\Requests;
 
 use App\Models\Invoice;
+use App\Rules\CreditNoteDeletedTogether;
 use App\Rules\RelationNotExist;
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;
@@ -30,6 +31,7 @@ class DeleteInvoiceRequest extends FormRequest
                 'required',
                 Rule::exists('invoices', 'id'),
                 new RelationNotExist(Invoice::class, 'payments'),
+                new CreditNoteDeletedTogether((array) $this->input('ids', [])),
             ],
         ];
     }
diff --git a/app/Http/Requests/InvoicesRequest.php b/app/Http/Requests/InvoicesRequest.php
index d1a73524..2a085cb3 100644
--- a/app/Http/Requests/InvoicesRequest.php
+++ b/app/Http/Requests/InvoicesRequest.php
@@ -139,6 +139,13 @@ class InvoicesRequest extends FormRequest
         return collect($this->except('items', 'taxes'))
             ->merge([
                 'creator_id' => $this->user()->id ?? null,
+                // Credit notes are minted only by CreditNoteService::create();
+                // this payload feeds Invoice::create/update, so a client must never
+                // be able to declare a document a reversal, re-point its origin,
+                // or write the reason a reversal was issued for.
+                'type' => Invoice::TYPE_INVOICE,
+                'related_invoice_id' => null,
+                'credit_reason' => null,
                 'status' => $this->has('invoiceSend') ? Invoice::STATUS_SENT : Invoice::STATUS_DRAFT,
                 'paid_status' => Invoice::STATUS_UNPAID,
                 'company_id' => $this->header('company'),
diff --git a/app/Http/Requests/PaymentRequest.php b/app/Http/Requests/PaymentRequest.php
index 772d2a80..78692859 100644
--- a/app/Http/Requests/PaymentRequest.php
+++ b/app/Http/Requests/PaymentRequest.php
@@ -4,6 +4,8 @@ namespace App\Http\Requests;
 
 use App\Models\CompanySetting;
 use App\Models\Customer;
+use App\Models\Invoice;
+use App\Models\Payment;
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;
 
@@ -59,6 +61,16 @@ class PaymentRequest extends FormRequest
             ];
         }
 
+        $maxAmount = $this->maxPayableAmount();
+
+        if ($maxAmount !== null) {
+            $rules['amount'] = [
+                'required',
+                'numeric',
+                'max:'.$maxAmount,
+            ];
+        }
+
         $companyCurrency = CompanySetting::getSetting('currency', $this->header('company'));
 
         $customer = Customer::find($this->customer_id);
@@ -74,6 +86,56 @@ class PaymentRequest extends FormRequest
         return $rules;
     }
 
+    /**
+     * The message string IS the translation key here, as everywhere else in the
+     * app: the front end maps it to a localized string.
+     */
+    public function messages(): array
+    {
+        return [
+            'amount.max' => 'payment_amount_exceeds_invoice_due_amount',
+        ];
+    }
+
+    /**
+     * The most that may be paid against the invoice this request names, or null
+     * when the payment is not attached to an invoice and so is uncapped.
+     *
+     * An overpayment used to be accepted and then silently swallowed:
+     * PaymentService hands the amount to Invoice::subtractInvoicePayment(),
+     * which drives the balance negative, and Invoice::getInvoiceStatusByAmount()
+     * returns an empty array for a negative amount, so the status change is
+     * never applied and the invoice keeps a stale balance. Partial credit notes
+     * shrink the balance and make that easy to hit, so the cap is enforced here,
+     * before any of it runs.
+     *
+     * On an edit of a payment that already belongs to this same invoice its own
+     * amount returns to the pool, because PaymentService::update() adds the old
+     * amount back before subtracting the new one.
+     */
+    protected function maxPayableAmount(): ?int
+    {
+        if (! $this->invoice_id) {
+            return null;
+        }
+
+        $invoice = Invoice::find($this->invoice_id);
+
+        if (! $invoice) {
+            return null;
+        }
+
+        $max = (int) $invoice->due_amount;
+
+        $payment = $this->route('payment');
+
+        if ($payment instanceof Payment && (int) $payment->invoice_id === (int) $this->invoice_id) {
+            $max += (int) $payment->amount;
+        }
+
+        return $max;
+    }
+
     public function getPaymentPayload()
     {
         $company_currency = CompanySetting::getSetting('currency', $this->header('company'));
diff --git a/app/Http/Resources/CreditNoteResource.php b/app/Http/Resources/CreditNoteResource.php
new file mode 100644
index 00000000..43fce473
--- /dev/null
+++ b/app/Http/Resources/CreditNoteResource.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Http\Resources;
+
+/**
+ * API representation of a credit note (Stornorechnung).
+ *
+ * A credit note is an invoice with type = CREDIT_NOTE, so this mirrors
+ * InvoiceResource and adds the credit-note specific fields: the type and a
+ * compact reference to the original invoice it reverses. Using a dedicated
+ * resource (rather than PaymentResource, which was the bug in PR #536) keeps
+ * the credit-note payload explicit and self-describing.
+ */
+class CreditNoteResource extends InvoiceResource
+{
+    /**
+     * Transform the resource into an array.
+     */
+    public function toArray($request): array
+    {
+        return array_merge(parent::toArray($request), [
+            // type + related_invoice_id come from InvoiceResource; this adds the
+            // expanded reference to the original invoice being reversed.
+            // Read off the loaded relation rather than probing it: the caller
+            // eager-loads relatedInvoice, so an exists() query here would be
+            // pure overhead.
+            'related_invoice' => $this->when(
+                $this->relationLoaded('relatedInvoice') && $this->relatedInvoice !== null,
+                function () {
+                    $related = $this->relatedInvoice;
+
+                    return [
+                        'id' => $related->id,
+                        'invoice_number' => $related->invoice_number,
+                        'invoice_date' => $related->invoice_date,
+                        'formatted_invoice_date' => $related->formattedInvoiceDate,
+                        'total' => $related->total,
+                        'unique_hash' => $related->unique_hash,
+                    ];
+                }
+            ),
+        ]);
+    }
+}
diff --git a/app/Http/Resources/InvoiceResource.php b/app/Http/Resources/InvoiceResource.php
index 87a37c02..64aff4b3 100644
--- a/app/Http/Resources/InvoiceResource.php
+++ b/app/Http/Resources/InvoiceResource.php
@@ -20,6 +20,8 @@ class InvoiceResource extends JsonResource
             'due_date' => $this->due_date,
             'invoice_number' => $this->invoice_number,
             'reference_number' => $this->reference_number,
+            'type' => $this->type,
+            'related_invoice_id' => $this->related_invoice_id,
             'status' => $this->status,
             'paid_status' => $this->paid_status,
             'tax_per_item' => $this->tax_per_item,
@@ -57,6 +59,67 @@ class InvoiceResource extends JsonResource
             'sales_tax_type' => $this->sales_tax_type,
             'sales_tax_address_type' => $this->sales_tax_address_type,
             'overdue' => $this->overdue,
+            // Credit notes reversing this invoice (minimal reference so the
+            // UI can flag the invoice as cancelled and link to the storno
+            // document, mirroring the related_invoice back-link). Emitted only
+            // where the relation was eager-loaded: probing it per row costs two
+            // queries each, and this resource is serialized in paginated lists.
+            'credit_notes' => $this->when(
+                $this->relationLoaded('creditNotes') && $this->creditNotes->isNotEmpty(),
+                fn () => $this->creditNotes->map(fn ($creditNote) => [
+                    'id' => $creditNote->id,
+                    'invoice_number' => $creditNote->invoice_number,
+                ])->values()
+            ),
+            // Why this invoice was credited, if it was. Set only by the
+            // credit-note flow, never by the invoice form.
+            'credit_reason' => $this->credit_reason,
+            // How much of the invoice has been credited off it, as a positive
+            // number of cents (credit notes store negative totals), and whether
+            // that covers the whole document. Both are read off the same loaded
+            // relation the banner uses, so they cost no extra query.
+            'credited_total' => $this->when(
+                $this->relationLoaded('creditNotes'),
+                fn () => $this->creditedTotal()
+            ),
+            'credited_status' => $this->when(
+                $this->relationLoaded('creditNotes'),
+                function () {
+                    $credited = $this->creditedTotal();
+
+                    if ($credited === 0) {
+                        return 'NONE';
+                    }
+
+                    return $credited === (int) $this->total ? 'FULL' : 'PARTIAL';
+                }
+            ),
+            // Credited quantity per ORIGINAL line, which is what a partial
+            // credit form needs to offer the remaining quantities. Emitted only
+            // when the credit notes' items came along.
+            'credited_quantities' => $this->when(
+                $this->relationLoaded('creditNotes')
+                    && $this->creditNotes->every(fn ($creditNote) => $creditNote->relationLoaded('items')),
+                function () {
+                    $quantities = [];
+
+                    foreach ($this->creditNotes as $creditNote) {
+                        foreach ($creditNote->items as $item) {
+                            if (! $item->source_invoice_item_id) {
+                                continue;
+                            }
+
+                            $quantities[$item->source_invoice_item_id] =
+                                ($quantities[$item->source_invoice_item_id] ?? 0) + (float) $item->quantity;
+                        }
+                    }
+
+                    // Cast to an object because the item ids are the keys: a
+                    // nested array whose keys are all numeric is re-indexed to a
+                    // list by the resource filter, which would throw the ids away.
+                    return (object) $quantities;
+                }
+            ),
             'items' => $this->when($this->items()->exists(), function () {
                 return InvoiceItemResource::collection($this->items);
             }),
@@ -80,4 +143,12 @@ class InvoiceResource extends JsonResource
             }),
         ];
     }
+
+    /**
+     * Sum of the loaded credit notes as a positive number of cents.
+     */
+    protected function creditedTotal(): int
+    {
+        return -(int) $this->creditNotes->sum('total');
+    }
 }
diff --git a/app/Mail/SendCreditNoteMail.php b/app/Mail/SendCreditNoteMail.php
new file mode 100644
index 00000000..1ef7ec60
--- /dev/null
+++ b/app/Mail/SendCreditNoteMail.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace App\Mail;
+
+use App\Facades\Hashids;
+use App\Models\EmailLog;
+use App\Models\Invoice;
+use Illuminate\Bus\Queueable;
+use Illuminate\Mail\Mailable;
+use Illuminate\Queue\SerializesModels;
+
+/**
+ * Mailable for sending a credit note (Stornorechnung) to a customer.
+ *
+ * A credit note is persisted as an Invoice row (type = CREDIT_NOTE), so the
+ * mailable and its EmailLog reference the Invoice model. PR #536 imported a
+ * non-existent CreditNote model here (issue #4); this uses the correct import.
+ */
+class SendCreditNoteMail extends Mailable
+{
+    use Queueable;
+    use SerializesModels;
+
+    public $data = [];
+
+    public function __construct($data)
+    {
+        $this->data = $data;
+    }
+
+    public function build()
+    {
+        $log = EmailLog::create([
+            'from' => $this->data['from'],
+            'to' => $this->data['to'],
+            'cc' => $this->data['cc'] ?? null,
+            'bcc' => $this->data['bcc'] ?? null,
+            'subject' => $this->data['subject'],
+            'body' => $this->data['body'],
+            'mailable_type' => Invoice::class,
+            'mailable_id' => $this->data['invoice']['id'],
+        ]);
+
+        $log->token = Hashids::connection(EmailLog::class)->encode($log->id);
+        $log->save();
+
+        $this->data['url'] = route('invoice', ['email_log' => $log->token]);
+
+        $mailContent = $this->from($this->data['from'], config('mail.from.name'))
+            ->subject($this->data['subject'])
+            ->markdown('emails.send.credit-note', ['data' => $this->data]);
+
+        if ($this->data['attach']['data']) {
+            $mailContent->attachData(
+                $this->data['attach']['data']->output(),
+                $this->data['invoice']['invoice_number'].'.pdf'
+            );
+        }
+
+        return $mailContent;
+    }
+}
diff --git a/app/Models/Invoice.php b/app/Models/Invoice.php
index d4481951..0d0f07e8 100644
--- a/app/Models/Invoice.php
+++ b/app/Models/Invoice.php
@@ -40,6 +40,10 @@ class Invoice extends Model implements HasMedia
 
     public const STATUS_PAID = 'PAID';
 
+    public const TYPE_INVOICE = 'INVOICE';
+
+    public const TYPE_CREDIT_NOTE = 'CREDIT_NOTE';
+
     protected $dates = [
         'created_at',
         'updated_at',
@@ -122,6 +126,28 @@ class Invoice extends Model implements HasMedia
         return $this->belongsTo(User::class, 'creator_id');
     }
 
+    /**
+     * The original invoice this credit note reverses (null for normal invoices).
+     */
+    public function relatedInvoice(): BelongsTo
+    {
+        return $this->belongsTo(Invoice::class, 'related_invoice_id');
+    }
+
+    /**
+     * Credit notes that reverse this invoice.
+     */
+    public function creditNotes(): HasMany
+    {
+        return $this->hasMany(Invoice::class, 'related_invoice_id')
+            ->where('type', self::TYPE_CREDIT_NOTE);
+    }
+
+    public function isCreditNote(): bool
+    {
+        return $this->type === self::TYPE_CREDIT_NOTE;
+    }
+
     public function getInvoicePdfUrlAttribute()
     {
         return url('/invoices/pdf/'.$this->unique_hash);
@@ -138,6 +164,16 @@ class Invoice extends Model implements HasMedia
 
     public function getAllowEditAttribute()
     {
+        // A credited invoice is immutable: its line item ids anchor the lines of
+        // every credit note that reverses it.
+        $hasCreditNotes = $this->relationLoaded('creditNotes')
+            ? $this->creditNotes->isNotEmpty()
+            : $this->creditNotes()->exists();
+
+        if ($hasCreditNotes) {
+            return false;
+        }
+
         $retrospective_edit = CompanySetting::getSetting('retrospective_edits', $this->company_id);
 
         $allowed = true;
diff --git a/app/Policies/CreditNotePolicy.php b/app/Policies/CreditNotePolicy.php
new file mode 100644
index 00000000..77d01a78
--- /dev/null
+++ b/app/Policies/CreditNotePolicy.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Policies;
+
+use App\Models\Invoice;
+use App\Models\User;
+use Illuminate\Auth\Access\HandlesAuthorization;
+use Silber\Bouncer\BouncerFacade;
+
+/**
+ * Authorization for credit notes (Stornorechnungen).
+ *
+ * A credit note is persisted as an invoice row (type = CREDIT_NOTE), so once it
+ * exists the ordinary invoice abilities (view, send, delete) govern it through
+ * InvoicePolicy. What needs its own rule is minting one: the ability maps to
+ * creating an invoice but is gated on the acting user belonging to the *source*
+ * invoice's company (tenant isolation, issue #9 from PR #536).
+ */
+class CreditNotePolicy
+{
+    use HandlesAuthorization;
+
+    /**
+     * Whether the user may create a credit note for the given source invoice.
+     */
+    public function create(User $user, Invoice $invoice): bool
+    {
+        return BouncerFacade::can('create-invoice', Invoice::class)
+            && $user->hasCompany($invoice->company_id);
+    }
+}
diff --git a/app/Policies/InvoicePolicy.php b/app/Policies/InvoicePolicy.php
index 72dfa428..2615e05f 100644
--- a/app/Policies/InvoicePolicy.php
+++ b/app/Policies/InvoicePolicy.php
@@ -61,6 +61,13 @@ class InvoicePolicy
      */
     public function update(User $user, Invoice $invoice): bool
     {
+        // A credit note is a reversal document: it is immutable once minted,
+        // because saving it back through the invoice form would recompute its
+        // totals positive.
+        if ($invoice->isCreditNote()) {
+            return false;
+        }
+
         if (BouncerFacade::can('edit-invoice', $invoice) && $user->hasCompany($invoice->company_id)) {
             return $invoice->allow_edit;
         }
diff --git a/app/Providers/AppServiceProvider.php b/app/Providers/AppServiceProvider.php
index cf87366c..fe09eb69 100644
--- a/app/Providers/AppServiceProvider.php
+++ b/app/Providers/AppServiceProvider.php
@@ -5,6 +5,7 @@ namespace App\Providers;
 use App\Models\AiConversation;
 use App\Policies\AiConversationPolicy;
 use App\Policies\CompanyPolicy;
+use App\Policies\CreditNotePolicy;
 use App\Policies\CustomerPolicy;
 use App\Policies\DashboardPolicy;
 use App\Policies\EstimatePolicy;
@@ -153,6 +154,7 @@ class AppServiceProvider extends ServiceProvider
         Gate::define('view notes', [NotePolicy::class, 'viewNotes']);
 
         Gate::define('send invoice', [InvoicePolicy::class, 'send']);
+        Gate::define('create credit note', [CreditNotePolicy::class, 'create']);
         Gate::define('send estimate', [EstimatePolicy::class, 'send']);
         Gate::define('send payment', [PaymentPolicy::class, 'send']);
 
diff --git a/app/Rules/CreditNoteDeletedTogether.php b/app/Rules/CreditNoteDeletedTogether.php
new file mode 100644
index 00000000..84d0c998
--- /dev/null
+++ b/app/Rules/CreditNoteDeletedTogether.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Rules;
+
+use App\Models\Invoice;
+use Closure;
+use Illuminate\Contracts\Validation\ValidationRule;
+
+/**
+ * An invoice may not be deleted while a credit note still reverses it.
+ *
+ * RelationNotExist cannot express this: the credit note is allowed to go, as
+ * long as it goes in the same batch. Deleting only the original would leave the
+ * credit note pointing at a row that no longer exists, so its detail page, its
+ * PDF banner and the delete-side balance restore all lose their counterpart.
+ * The rule therefore looks at the whole `ids` list, not just the value it was
+ * handed.
+ */
+class CreditNoteDeletedTogether implements ValidationRule
+{
+    /**
+     * @param  array<int, mixed>  $ids  every id in the delete request
+     */
+    public function __construct(private readonly array $ids) {}
+
+    public function validate(string $attribute, mixed $value, Closure $fail): void
+    {
+        $batch = array_map('intval', array_filter($this->ids, 'is_numeric'));
+
+        $orphaned = Invoice::where('related_invoice_id', (int) $value)
+            ->where('type', Invoice::TYPE_CREDIT_NOTE)
+            ->whereNotIn('id', $batch)
+            ->exists();
+
+        if ($orphaned) {
+            $fail('Credit note exists.');
+        }
+    }
+}
diff --git a/app/Services/Ai/Tools/GetCompanyStatsTool.php b/app/Services/Ai/Tools/GetCompanyStatsTool.php
index 69ea6e0e..0de161bf 100644
--- a/app/Services/Ai/Tools/GetCompanyStatsTool.php
+++ b/app/Services/Ai/Tools/GetCompanyStatsTool.php
@@ -75,8 +75,11 @@ class GetCompanyStatsTool extends AiTool
         // so rangeFor() is guaranteed to return a non-null pair here.
         [$start, $end] = $this->rangeFor($period);
 
+        // Counts issued invoices only; the total below keeps the credit notes,
+        // whose negated amounts are what net the sales figure back out.
         $invoiceCount = Invoice::query()
             ->where('company_id', $companyId)
+            ->where('type', Invoice::TYPE_INVOICE)
             ->whereBetween('invoice_date', [$start, $end])
             ->count();
 
diff --git a/app/Services/Ai/Tools/GetCustomerTool.php b/app/Services/Ai/Tools/GetCustomerTool.php
index 803e9397..61c09db3 100644
--- a/app/Services/Ai/Tools/GetCustomerTool.php
+++ b/app/Services/Ai/Tools/GetCustomerTool.php
@@ -49,9 +49,11 @@ class GetCustomerTool extends AiTool
         }
 
         // Aggregate totals — done with lightweight queries rather than loading every invoice.
+        // Issued invoices only: a credit note reverses one, it is not another.
         $invoiceCount = Invoice::query()
             ->where('company_id', $companyId)
             ->where('customer_id', $customer->id)
+            ->where('type', Invoice::TYPE_INVOICE)
             ->count();
 
         $outstanding = (float) Invoice::query()
diff --git a/app/Services/Company/CompanyService.php b/app/Services/Company/CompanyService.php
index c96b6e4b..86ecf75d 100644
--- a/app/Services/Company/CompanyService.php
+++ b/app/Services/Company/CompanyService.php
@@ -204,6 +204,7 @@ class CompanyService
             'payment_email_attachment' => 'NO',
             'retrospective_edits' => 'allow',
             'invoice_number_format' => '{{SERIES:INV}}{{DELIMITER:-}}{{SEQUENCE:6}}',
+            'credit_note_number_format' => '{{SERIES:CN}}{{DELIMITER:-}}{{SEQUENCE:6}}',
             'estimate_number_format' => '{{SERIES:EST}}{{DELIMITER:-}}{{SEQUENCE:6}}',
             'payment_number_format' => '{{SERIES:PAY}}{{DELIMITER:-}}{{SEQUENCE:6}}',
             'estimate_set_expiry_date_automatically' => 'YES',
diff --git a/app/Services/Document/CreditNoteService.php b/app/Services/Document/CreditNoteService.php
new file mode 100644
index 00000000..28129a59
--- /dev/null
+++ b/app/Services/Document/CreditNoteService.php
@@ -0,0 +1,490 @@
+<?php
+
+namespace App\Services\Document;
+
+use App\Facades\Hashids;
+use App\Models\Invoice;
+use App\Models\InvoiceItem;
+use App\Support\CreditNoteAmounts;
+use Carbon\Carbon;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
+
+/**
+ * Creates credit notes (Stornorechnungen) that reverse an invoice in full or in
+ * part, and keeps the reversed invoice's balance in step with them.
+ *
+ * A credit note is an invoice row with type = CREDIT_NOTE pointing back at the
+ * invoice it reverses; each of its lines carries source_invoice_item_id, the
+ * line of the original invoice it credits. Those links are what make partial
+ * credits possible: they say how much of every line has already been credited,
+ * which is the only input {@see CreditNoteAmounts} needs beyond the original
+ * invoice's own stored figures.
+ *
+ * All arithmetic is delegated to that calculator, which works on the
+ * cumulative-difference (telescoping) model, so crediting a line in chunks
+ * always sums to exactly what crediting it in one go would have produced. This
+ * service's job is the surrounding bookkeeping: locking the invoice, deciding
+ * what "before" and "after" are, enforcing the domain invariants, negating the
+ * magnitudes, and persisting the rows.
+ */
+class CreditNoteService
+{
+    public function __construct(
+        private readonly DocumentItemService $documentItemService,
+    ) {}
+
+    /**
+     * Create a credit note reversing the given invoice.
+     *
+     * @param  array  $items  lines to credit as [['id' => invoiceItemId, 'quantity' => float], ...].
+     *                        An empty array credits every remaining quantity (a full reversal).
+     * @param  string|null  $reason  free-text reason stored on the credit note
+     *
+     * @throws ValidationException
+     */
+    public function create(Invoice $invoice, array $items = [], ?string $reason = null): Invoice
+    {
+        return DB::transaction(function () use ($invoice, $items, $reason) {
+            // The invoice is re-read under a row lock because every guard below
+            // is a read-then-write on it: two concurrent credit notes checking
+            // the same remaining quantity would each be allowed and together
+            // overdraw the invoice.
+            $original = Invoice::query()
+                ->whereKey($invoice->getKey())
+                ->lockForUpdate()
+                ->firstOrFail();
+
+            $original->load(['items.taxes', 'taxes', 'fields', 'creditNotes.items']);
+
+            $snapshot = $this->snapshot($original);
+            $invoiced = $this->invoicedQuantities($original);
+            $before = $this->creditedQuantities($original);
+            $after = $this->targetQuantities($invoiced, $before, $items);
+
+            $paid = (int) $original->payments()->sum('amount');
+            $creditedBefore = $this->creditedTotal($original);
+
+            $this->guard($original, $invoiced, $before, $after, $paid, $creditedBefore);
+
+            $amounts = CreditNoteAmounts::forCredit($snapshot, $before, $after);
+
+            if ($creditedBefore + $amounts['total'] > (int) $original->total - $paid) {
+                throw ValidationException::withMessages([
+                    'invoice' => ['credit_amount_exceeds_invoice_balance'],
+                ]);
+            }
+
+            $creditNote = $this->persist($original, $amounts, $reason);
+
+            $this->recalculateBalance($original);
+
+            return Invoice::with([
+                'items',
+                'items.fields',
+                'items.fields.customField',
+                'customer',
+                'taxes',
+                'relatedInvoice',
+            ])->find($creditNote->id);
+        });
+    }
+
+    /**
+     * How much of every line of the invoice is still creditable, in hundredths,
+     * keyed by the original invoice_items.id.
+     */
+    public function remainingQuantities(Invoice $invoice): array
+    {
+        $invoice->loadMissing(['items', 'creditNotes.items']);
+
+        $credited = $this->creditedQuantities($invoice);
+        $remaining = [];
+
+        foreach ($this->invoicedQuantities($invoice) as $itemId => $hundredths) {
+            $remaining[$itemId] = max(0, $hundredths - ($credited[$itemId] ?? 0));
+        }
+
+        return $remaining;
+    }
+
+    /**
+     * The amount already credited off this invoice, as a positive number of
+     * cents (credit notes store negative totals).
+     */
+    public function creditedTotal(Invoice $invoice): int
+    {
+        return -(int) $invoice->creditNotes()->sum('total');
+    }
+
+    /**
+     * Recompute the invoice's balance and status from what it was paid and what
+     * has been credited off it.
+     *
+     * This deliberately does not live in {@see Invoice::getInvoiceStatusByAmount()}:
+     * that method is called from the payment flow, and PaymentService::create()
+     * adjusts the invoice BEFORE the Payment row is written, so a rule derived
+     * from payments()->sum() would read a stale total there and settle the
+     * invoice one payment short. This method only runs when a credit note is
+     * created or deleted, where every payment and every credit note involved is
+     * already persisted.
+     */
+    public function recalculateBalance(Invoice $invoice): void
+    {
+        $paid = (int) $invoice->payments()->sum('amount');
+        $credited = $this->creditedTotal($invoice);
+        $due = max(0, (int) $invoice->total - $paid - $credited);
+
+        $invoice->due_amount = $due;
+        $invoice->base_due_amount = (int) round($due * $invoice->exchange_rate);
+
+        if ($due === 0) {
+            // Nothing is owed any more, whether that came from money or from a
+            // reversal, so the invoice must drop out of every "awaiting
+            // payment" view. Which of the two settled it is carried by the
+            // creditNotes relation, not by the status.
+            $invoice->status = Invoice::STATUS_COMPLETED;
+            $invoice->paid_status = Invoice::STATUS_PAID;
+            $invoice->overdue = false;
+        } else {
+            $invoice->status = $invoice->getPreviousStatus();
+            $invoice->paid_status = $paid > 0
+                ? Invoice::STATUS_PARTIALLY_PAID
+                : Invoice::STATUS_UNPAID;
+        }
+
+        $invoice->save();
+    }
+
+    /**
+     * Enforce the credit-note invariants, in the order that produces the most
+     * specific message for each situation.
+     *
+     * @throws ValidationException
+     */
+    protected function guard(Invoice $invoice, array $invoiced, array $before, array $after, int $paid, int $creditedBefore): void
+    {
+        $remaining = 0;
+
+        foreach ($invoiced as $itemId => $hundredths) {
+            $remaining += max(0, $hundredths - ($before[$itemId] ?? 0));
+        }
+
+        if ($remaining === 0 || (int) $invoice->total - $paid - $creditedBefore <= 0) {
+            throw ValidationException::withMessages([
+                'invoice' => ['invoice_already_fully_credited'],
+            ]);
+        }
+
+        foreach ($after as $itemId => $hundredths) {
+            if ($hundredths > ($invoiced[$itemId] ?? 0)) {
+                throw ValidationException::withMessages([
+                    'invoice' => ['credit_quantity_exceeds_remaining'],
+                ]);
+            }
+        }
+
+        foreach ($after as $itemId => $hundredths) {
+            if ($hundredths > ($before[$itemId] ?? 0)) {
+                return;
+            }
+        }
+
+        throw ValidationException::withMessages([
+            'invoice' => ['credit_note_must_credit_something'],
+        ]);
+    }
+
+    /**
+     * Write the credit-note document, its lines and its taxes.
+     */
+    protected function persist(Invoice $invoice, array $amounts, ?string $reason): Invoice
+    {
+        // A fresh SerialNumberService per document, as everywhere else in the
+        // app: it is a stateful builder that keeps the number it computed, so a
+        // shared instance would hand the same number to the next credit note.
+        $serial = (new SerialNumberService)
+            ->setModel(new Invoice)
+            ->setCompany($invoice->company_id)
+            ->setCustomer($invoice->customer_id)
+            ->setSettingKey('credit_note_number_format')
+            ->setSequenceScope(['type' => Invoice::TYPE_CREDIT_NOTE])
+            ->setNextNumbers();
+
+        // exchange_rate is a float multiplier, not a currency amount. The base_*
+        // fields are pro-rated from the original's stored base_* integers by the
+        // calculator, so they are negated as-is rather than recomputed through
+        // the rate, which would re-round a decision already made.
+        $creditNote = Invoice::create([
+            'creator_id' => auth()->id(),
+            'type' => Invoice::TYPE_CREDIT_NOTE,
+            'related_invoice_id' => $invoice->id,
+            'credit_reason' => $reason,
+            'invoice_date' => Carbon::now()->format('Y-m-d'),
+            // A reversal is never owed, so it has no due date at all. Leaving it
+            // null also keeps the credit note out of every due/aging query.
+            'due_date' => null,
+            'invoice_number' => $serial->getNextNumber(),
+            'sequence_number' => $serial->nextSequenceNumber,
+            'customer_sequence_number' => $serial->nextCustomerSequenceNumber,
+            'reference_number' => $invoice->invoice_number,
+            'customer_id' => $invoice->customer_id,
+            'company_id' => $invoice->company_id,
+            'template_name' => $invoice->template_name,
+            // A credit note gets the ordinary create-review-send lifecycle: born
+            // DRAFT so the Send affordances appear, promoted to SENT by send().
+            // Nothing is ever owed on it, so paid_status/due_amount below keep
+            // it out of the payment flows regardless of status.
+            'status' => Invoice::STATUS_DRAFT,
+            // The credit note is born settled: it exists to pair with the
+            // original invoice, nothing is ever owed on it, so it must never
+            // surface as an open (negative) balance in any due/aging view.
+            'paid_status' => Invoice::STATUS_PAID,
+            'sub_total' => -$amounts['sub_total'],
+            'discount' => $invoice->discount,
+            'discount_type' => $invoice->discount_type,
+            'discount_val' => -$amounts['discount_val'],
+            'total' => -$amounts['total'],
+            'due_amount' => 0,
+            'tax_per_item' => $invoice->tax_per_item,
+            'discount_per_item' => $invoice->discount_per_item,
+            'tax' => -$amounts['tax'],
+            'tax_included' => $invoice->tax_included,
+            'notes' => $invoice->notes,
+            'exchange_rate' => $invoice->exchange_rate,
+            'base_discount_val' => -$amounts['base_discount_val'],
+            'base_sub_total' => -$amounts['base_sub_total'],
+            'base_total' => -$amounts['base_total'],
+            'base_tax' => -$amounts['base_tax'],
+            'base_due_amount' => 0,
+            'currency_id' => $invoice->currency_id,
+            'sales_tax_type' => $invoice->sales_tax_type,
+            'sales_tax_address_type' => $invoice->sales_tax_address_type,
+        ]);
+
+        $creditNote->unique_hash = Hashids::connection(Invoice::class)->encode($creditNote->id);
+        $creditNote->save();
+
+        // recompute: false throughout. The calculator has already decided every
+        // cent of this document, and re-deriving the line totals or the base_*
+        // columns from price * quantity * rate would round a second time and
+        // break the telescoping invariant by a cent.
+        $this->documentItemService->createItems(
+            $creditNote,
+            $this->creditItems($invoice, $amounts['items']),
+            recompute: false
+        );
+
+        if ($invoice->tax_per_item !== 'YES' && ! empty($amounts['taxes'])) {
+            $this->documentItemService->createTaxes(
+                $creditNote,
+                $this->creditTaxes($invoice->taxes, $amounts['taxes']),
+                recompute: false
+            );
+        }
+
+        if ($invoice->fields()->exists()) {
+            $customFields = [];
+
+            foreach ($invoice->fields as $field) {
+                $customFields[] = [
+                    'id' => $field->custom_field_id,
+                    'value' => $field->defaultAnswer,
+                ];
+            }
+
+            $creditNote->addCustomFields($customFields);
+        }
+
+        return $creditNote;
+    }
+
+    /**
+     * Build the credit-note line payloads: negated amounts from the calculator,
+     * descriptive fields copied from the line each one credits.
+     */
+    protected function creditItems(Invoice $invoice, array $lines): array
+    {
+        $sourceItems = $invoice->items->keyBy('id');
+        $items = [];
+
+        foreach ($lines as $sourceId => $line) {
+            /** @var InvoiceItem $source */
+            $source = $sourceItems->get($sourceId);
+
+            if (! $source) {
+                continue;
+            }
+
+            $items[] = [
+                'source_invoice_item_id' => $line['source_invoice_item_id'],
+                'item_id' => $source->item_id,
+                'name' => $source->name,
+                'description' => $source->description,
+                'unit_name' => $source->unit_name,
+                'discount_type' => $source->discount_type,
+                'discount' => $source->discount,
+                // The quantity stays positive: what makes the line a credit is
+                // the negative price and total, exactly as a full reversal does.
+                'quantity' => $line['quantity'],
+                'price' => -$line['price'],
+                'base_price' => -$line['base_price'],
+                'discount_val' => -$line['discount_val'],
+                'tax' => -$line['tax'],
+                'total' => -$line['total'],
+                'base_discount_val' => -$line['base_discount_val'],
+                'base_tax' => -$line['base_tax'],
+                'base_total' => -$line['base_total'],
+                'taxes' => $this->creditTaxes($source->taxes, $line['taxes']),
+            ];
+        }
+
+        return $items;
+    }
+
+    /**
+     * Build tax-row payloads: negated amounts from the calculator, descriptive
+     * fields copied from the tax row each one reverses.
+     */
+    protected function creditTaxes(Collection $sourceTaxes, array $amounts): array
+    {
+        $byId = $sourceTaxes->keyBy('id');
+        $taxes = [];
+
+        foreach ($amounts as $taxId => $amount) {
+            $source = $byId->get($taxId);
+
+            if (! $source) {
+                continue;
+            }
+
+            $taxes[] = [
+                'tax_type_id' => $source->tax_type_id,
+                'item_id' => $source->item_id,
+                'name' => $source->name,
+                'percent' => $source->percent,
+                'compound_tax' => $source->compound_tax,
+                'calculation_type' => $source->calculation_type,
+                'fixed_amount' => $source->fixed_amount,
+                'amount' => -$amount['amount'],
+                'base_amount' => -$amount['base_amount'],
+            ];
+        }
+
+        return $taxes;
+    }
+
+    /**
+     * The original invoice's stored figures, in the shape the calculator reads.
+     */
+    protected function snapshot(Invoice $invoice): array
+    {
+        $items = [];
+
+        foreach ($invoice->items as $item) {
+            $items[$item->id] = [
+                'price' => (int) $item->price,
+                'quantity' => (float) $item->quantity,
+                'discount_val' => (int) $item->discount_val,
+                'tax' => (int) $item->tax,
+                'total' => (int) $item->total,
+                'base_price' => (int) $item->base_price,
+                'base_discount_val' => (int) $item->base_discount_val,
+                'base_tax' => (int) $item->base_tax,
+                'base_total' => (int) $item->base_total,
+                'taxes' => $this->snapshotTaxes($item->taxes),
+            ];
+        }
+
+        return [
+            'sub_total' => (int) $invoice->sub_total,
+            'discount_val' => (int) $invoice->discount_val,
+            'tax' => (int) $invoice->tax,
+            'total' => (int) $invoice->total,
+            'base_sub_total' => (int) $invoice->base_sub_total,
+            'base_discount_val' => (int) $invoice->base_discount_val,
+            'base_tax' => (int) $invoice->base_tax,
+            'base_total' => (int) $invoice->base_total,
+            'discount_per_item' => $invoice->discount_per_item,
+            'tax_per_item' => $invoice->tax_per_item,
+            'tax_included' => (bool) $invoice->tax_included,
+            'items' => $items,
+            'taxes' => $this->snapshotTaxes($invoice->taxes),
+        ];
+    }
+
+    protected function snapshotTaxes(Collection $taxes): array
+    {
+        $snapshot = [];
+
+        foreach ($taxes as $tax) {
+            $snapshot[$tax->id] = [
+                'amount' => (int) $tax->amount,
+                'base_amount' => (int) $tax->base_amount,
+            ];
+        }
+
+        return $snapshot;
+    }
+
+    /**
+     * The invoiced quantity of every line, in hundredths.
+     */
+    protected function invoicedQuantities(Invoice $invoice): array
+    {
+        $quantities = [];
+
+        foreach ($invoice->items as $item) {
+            $quantities[$item->id] = CreditNoteAmounts::toHundredths($item->quantity);
+        }
+
+        return $quantities;
+    }
+
+    /**
+     * The already-credited quantity of every line, in hundredths, read off the
+     * credit notes that still exist. Deleting a credit note therefore gives its
+     * quantities back without any separate bookkeeping.
+     */
+    protected function creditedQuantities(Invoice $invoice): array
+    {
+        $quantities = [];
+
+        foreach ($invoice->creditNotes as $creditNote) {
+            foreach ($creditNote->items as $item) {
+                if (! $item->source_invoice_item_id) {
+                    continue;
+                }
+
+                $quantities[$item->source_invoice_item_id] =
+                    ($quantities[$item->source_invoice_item_id] ?? 0)
+                    + CreditNoteAmounts::toHundredths($item->quantity);
+            }
+        }
+
+        return $quantities;
+    }
+
+    /**
+     * The cumulative credited quantities this credit note leaves behind: the
+     * requested quantities on top of what was credited before, or every
+     * invoiced quantity when nothing specific was requested (full reversal).
+     */
+    protected function targetQuantities(array $invoiced, array $before, array $items): array
+    {
+        if (empty($items)) {
+            return $invoiced;
+        }
+
+        $after = $before;
+
+        foreach ($items as $line) {
+            $itemId = (int) $line['id'];
+
+            $after[$itemId] = ($after[$itemId] ?? 0) + CreditNoteAmounts::toHundredths($line['quantity']);
+        }
+
+        return $after;
+    }
+}
diff --git a/app/Services/Document/DocumentItemService.php b/app/Services/Document/DocumentItemService.php
index 8ec3593e..1c9bdd32 100644
--- a/app/Services/Document/DocumentItemService.php
+++ b/app/Services/Document/DocumentItemService.php
@@ -7,20 +7,50 @@ use Illuminate\Database\Eloquent\Model;
 
 class DocumentItemService
 {
-    public function createItems(Model $document, array $items): void
+    /**
+     * Company-currency columns and the column each one is derived from.
+     */
+    private const BASE_FIELDS = [
+        'base_price' => 'price',
+        'base_discount_val' => 'discount_val',
+        'base_tax' => 'tax',
+        'base_total' => 'total',
+    ];
+
+    /**
+     * Persist the line items of a document.
+     *
+     * $recompute = false is for callers that have already decided every cent of
+     * the document and must not have it decided again: partial credit notes
+     * carry pro-rated integers from CreditNoteAmounts, and re-deriving the line
+     * total from price * quantity or the base_* columns from the exchange rate
+     * rounds a second time, drifts a cent, and breaks the telescoping invariant
+     * that makes a chain of partial credits add back up to the invoice. Such a
+     * caller still gets a base_* value derived here for any it did not supply.
+     */
+    public function createItems(Model $document, array $items, bool $recompute = true): void
     {
         $exchangeRate = $document->exchange_rate;
 
         foreach ($items as $item) {
             $item['company_id'] = $document->company_id;
             $item['exchange_rate'] = $exchangeRate;
-            // Recompute the item total from price/quantity so a tampered item
-            // total can't desync from the recomputed document totals (GHSA-8c69).
-            $item['total'] = DocumentTotals::itemTotal($item, $document->discount_per_item === 'YES');
-            $item['base_price'] = $item['price'] * $exchangeRate;
-            $item['base_discount_val'] = $item['discount_val'] * $exchangeRate;
-            $item['base_tax'] = $item['tax'] * $exchangeRate;
-            $item['base_total'] = $item['total'] * $exchangeRate;
+
+            if ($recompute) {
+                // Recompute the item total from price/quantity so a tampered item
+                // total can't desync from the recomputed document totals (GHSA-8c69).
+                $item['total'] = DocumentTotals::itemTotal($item, $document->discount_per_item === 'YES');
+                $item['base_price'] = $item['price'] * $exchangeRate;
+                $item['base_discount_val'] = $item['discount_val'] * $exchangeRate;
+                $item['base_tax'] = $item['tax'] * $exchangeRate;
+                $item['base_total'] = $item['total'] * $exchangeRate;
+            } else {
+                foreach (self::BASE_FIELDS as $baseField => $field) {
+                    if (! array_key_exists($baseField, $item)) {
+                        $item[$baseField] = ($item[$field] ?? 0) * $exchangeRate;
+                    }
+                }
+            }
 
             if (array_key_exists('recurring_invoice_id', $item)) {
                 unset($item['recurring_invoice_id']);
@@ -32,9 +62,12 @@ class DocumentItemService
                 foreach ($item['taxes'] as $tax) {
                     $tax['company_id'] = $document->company_id;
                     $tax['exchange_rate'] = $document->exchange_rate;
-                    $tax['base_amount'] = $tax['amount'] * $exchangeRate;
                     $tax['currency_id'] = $document->currency_id;
 
+                    if ($recompute || ! array_key_exists('base_amount', $tax)) {
+                        $tax['base_amount'] = $tax['amount'] * $exchangeRate;
+                    }
+
                     if (gettype($tax['amount']) !== 'NULL') {
                         if (array_key_exists('recurring_invoice_id', $tax)) {
                             unset($tax['recurring_invoice_id']);
@@ -51,16 +84,25 @@ class DocumentItemService
         }
     }
 
-    public function createTaxes(Model $document, array $taxes): void
+    /**
+     * Persist the document-level tax rows.
+     *
+     * $recompute = false has the same meaning as in {@see createItems()}: the
+     * supplied base_amount is the caller's pro-rated integer and is kept as-is.
+     */
+    public function createTaxes(Model $document, array $taxes, bool $recompute = true): void
     {
         $exchangeRate = $document->exchange_rate;
 
         foreach ($taxes as $tax) {
             $tax['company_id'] = $document->company_id;
             $tax['exchange_rate'] = $document->exchange_rate;
-            $tax['base_amount'] = $tax['amount'] * $exchangeRate;
             $tax['currency_id'] = $document->currency_id;
 
+            if ($recompute || ! array_key_exists('base_amount', $tax)) {
+                $tax['base_amount'] = $tax['amount'] * $exchangeRate;
+            }
+
             if (gettype($tax['amount']) !== 'NULL') {
                 if (array_key_exists('recurring_invoice_id', $tax)) {
                     unset($tax['recurring_invoice_id']);
diff --git a/app/Services/Document/EstimateService.php b/app/Services/Document/EstimateService.php
index 879f9069..057a2b10 100644
--- a/app/Services/Document/EstimateService.php
+++ b/app/Services/Document/EstimateService.php
@@ -316,6 +316,7 @@ class EstimateService
             ->setModel(new Invoice)
             ->setCompany($estimate->company_id)
             ->setCustomer($estimate->customer_id)
+            ->setSequenceScope(['type' => Invoice::TYPE_INVOICE])
             ->setNextNumbers();
 
         $templateName = $estimate->getInvoiceTemplateName();
diff --git a/app/Services/Document/InvoiceService.php b/app/Services/Document/InvoiceService.php
index d9d6051a..46f9a882 100644
--- a/app/Services/Document/InvoiceService.php
+++ b/app/Services/Document/InvoiceService.php
@@ -5,6 +5,7 @@ namespace App\Services\Document;
 use App;
 use App\Facades\Hashids;
 use App\Facades\Pdf;
+use App\Mail\SendCreditNoteMail;
 use App\Mail\SendInvoiceMail;
 use App\Models\Company;
 use App\Models\CompanySetting;
@@ -24,6 +25,7 @@ class InvoiceService
 {
     public function __construct(
         private readonly DocumentItemService $documentItemService,
+        private readonly CreditNoteService $creditNoteService,
     ) {}
 
     public function create(Request $request): Invoice
@@ -40,6 +42,7 @@ class InvoiceService
             ->setModel($invoice)
             ->setCompany($invoice->company_id)
             ->setCustomer($invoice->customer_id)
+            ->setSequenceScope(['type' => Invoice::TYPE_INVOICE])
             ->setNextNumbers();
 
         $invoice->sequence_number = $serial->nextSequenceNumber;
@@ -69,6 +72,7 @@ class InvoiceService
             'items.fields.customField',
             'customer',
             'taxes',
+            'creditNotes',
         ])->find($invoice->id);
     }
 
@@ -81,6 +85,7 @@ class InvoiceService
             ->setModel($invoice)
             ->setCompany($invoice->company_id)
             ->setCustomer($request->customer_id)
+            ->setSequenceScope(['type' => Invoice::TYPE_INVOICE])
             ->setModelObject($invoice->id)
             ->setNextNumbers();
 
@@ -151,11 +156,18 @@ class InvoiceService
             'items.fields.customField',
             'customer',
             'taxes',
+            'creditNotes',
         ])->find($invoice->id);
     }
 
     public function delete(Collection $ids): bool
     {
+        // Invoices that lose a credit note in this batch and survive it. Their
+        // balances are recomputed once, after every deletion has landed, so a
+        // batch deleting several credit notes of the same invoice settles on
+        // the right figure instead of one per deleted document.
+        $creditedInvoiceIds = [];
+
         foreach ($ids as $id) {
             $invoice = Invoice::find($id);
 
@@ -163,9 +175,32 @@ class InvoiceService
                 $invoice->transactions()->delete();
             }
 
+            if ($invoice->isCreditNote() && $invoice->related_invoice_id && ! $ids->contains($invoice->related_invoice_id)) {
+                $creditedInvoiceIds[$invoice->related_invoice_id] = $invoice->related_invoice_id;
+            }
+
             $invoice->delete();
         }
 
+        // There is no DB-level foreign key on related_invoice_id by convention,
+        // so the cascade lives here: nothing that survives the batch may keep
+        // pointing at a row that just went away.
+        Invoice::whereIn('related_invoice_id', $ids)->update(['related_invoice_id' => null]);
+
+        // Deleting a credit note gives back the amount it had credited off its
+        // original invoice (mirror of the create-side adjustment; same symmetry
+        // PR #536 implemented). The balance is recomputed from the payments and
+        // the credit notes that remain rather than restored from a snapshot, so
+        // it is exact whether the invoice was partly paid, partly credited, or
+        // both.
+        foreach ($creditedInvoiceIds as $creditedInvoiceId) {
+            $original = Invoice::find($creditedInvoiceId);
+
+            if ($original) {
+                $this->creditNoteService->recalculateBalance($original);
+            }
+        }
+
         return true;
     }
 
@@ -204,7 +239,11 @@ class InvoiceService
         if (! empty($data['bcc'])) {
             $mail->bcc($data['bcc']);
         }
-        $mail->send(new SendInvoiceMail($data));
+        // A credit note travels through the same send channel as the invoice it
+        // reverses; only the template (and its EmailLog entry) differs.
+        $mail->send($invoice->isCreditNote()
+            ? new SendCreditNoteMail($data)
+            : new SendInvoiceMail($data));
 
         if ($invoice->status == Invoice::STATUS_DRAFT) {
             $invoice->status = Invoice::STATUS_SENT;
@@ -240,6 +279,11 @@ class InvoiceService
 
         $invoiceTemplate = Invoice::find($invoice->id)->template_name;
 
+        // Cheap either way: relatedInvoice is null for regular invoices and
+        // creditNotes is empty for credit notes. Eager-loaded here so the
+        // invoice templates can reference the paired document.
+        $invoice->loadMissing(['relatedInvoice', 'creditNotes']);
+
         $company = Company::find($invoice->company_id);
         $locale = CompanySetting::getSetting('language', $company->id);
         $customFields = CustomField::where('model_type', 'Item')->get();
@@ -266,7 +310,7 @@ class InvoiceService
         }
 
         return Pdf::loadView($templatePath, PdfMetadata::forDocument(
-            __('pdf_invoice_label'),
+            __($invoice->isCreditNote() ? 'pdf_credit_note_label' : 'pdf_invoice_label'),
             $invoice->invoice_number,
             $company,
         ));
@@ -280,6 +324,7 @@ class InvoiceService
             ->setModel($invoice)
             ->setCompany($invoice->company_id)
             ->setCustomer($invoice->customer_id)
+            ->setSequenceScope(['type' => Invoice::TYPE_INVOICE])
             ->setNextNumbers();
 
         $dueDate = null;
diff --git a/app/Services/Document/PaymentService.php b/app/Services/Document/PaymentService.php
index 543f6be2..c32fdb01 100644
--- a/app/Services/Document/PaymentService.php
+++ b/app/Services/Document/PaymentService.php
@@ -119,11 +119,19 @@ class PaymentService
                 $invoice = Invoice::find($payment->invoice_id);
                 $invoice->due_amount = ((int) $invoice->due_amount + (int) $payment->amount);
 
-                if ($invoice->due_amount == $invoice->total) {
-                    $invoice->paid_status = Invoice::STATUS_UNPAID;
-                } else {
-                    $invoice->paid_status = Invoice::STATUS_PARTIALLY_PAID;
-                }
+                // The paid status follows the payments that remain, not the
+                // balance. On an uncredited invoice the two rules agree exactly
+                // (the restored due equals the total precisely when no payment
+                // is left), but on a credited one the due amount is already net
+                // of its credit notes, so comparing it with the total would call
+                // an invoice unpaid while money is still recorded against it.
+                $remainingPaid = (int) $invoice->payments()
+                    ->whereKeyNot($payment->getKey())
+                    ->sum('amount');
+
+                $invoice->paid_status = $remainingPaid > 0
+                    ? Invoice::STATUS_PARTIALLY_PAID
+                    : Invoice::STATUS_UNPAID;
 
                 $invoice->status = $invoice->getPreviousStatus();
                 $invoice->save();
diff --git a/app/Services/Document/RecurringInvoiceService.php b/app/Services/Document/RecurringInvoiceService.php
index 14cff702..661523aa 100644
--- a/app/Services/Document/RecurringInvoiceService.php
+++ b/app/Services/Document/RecurringInvoiceService.php
@@ -130,6 +130,7 @@ class RecurringInvoiceService
             ->setModel(new Invoice)
             ->setCompany($recurringInvoice->company_id)
             ->setCustomer($recurringInvoice->customer_id)
+            ->setSequenceScope(['type' => Invoice::TYPE_INVOICE])
             ->setNextNumbers();
 
         $days = intval(CompanySetting::getSetting('invoice_due_date_days', $recurringInvoice->company_id));
diff --git a/app/Services/Document/SerialNumberService.php b/app/Services/Document/SerialNumberService.php
index 226b45ca..ab9519e7 100644
--- a/app/Services/Document/SerialNumberService.php
+++ b/app/Services/Document/SerialNumberService.php
@@ -17,6 +17,10 @@ class SerialNumberService
 
     private $company;
 
+    private $settingKey;
+
+    private $sequenceScope = [];
+
     /**
      * @var string
      */
@@ -72,13 +76,45 @@ class SerialNumberService
         return $this;
     }
 
+    /**
+     * Override the company setting the number format is read from.
+     *
+     * Without this the key is derived from the model class name, which is not
+     * enough for documents that share a table (credit notes are Invoice rows
+     * but carry their own format).
+     *
+     * @return $this
+     */
+    public function setSettingKey(string $key)
+    {
+        $this->settingKey = $key;
+
+        return $this;
+    }
+
+    /**
+     * Restrict the sequence lookups to a subset of the model's rows.
+     *
+     * Takes column => value constraints that are applied on top of the company
+     * (and customer) filters, so documents sharing a table can each keep an
+     * independent, gapless sequence.
+     *
+     * @return $this
+     */
+    public function setSequenceScope(array $constraints)
+    {
+        $this->sequenceScope = $constraints;
+
+        return $this;
+    }
+
     /**
      * @return string
      */
     public function getNextNumber($data = null)
     {
         $modelName = strtolower(class_basename($this->model));
-        $settingKey = $modelName.'_number_format';
+        $settingKey = $this->settingKey ?: $modelName.'_number_format';
         $companyId = $this->company;
 
         if (request()->has('format')) {
@@ -116,11 +152,15 @@ class SerialNumberService
     {
         $companyId = $this->company;
 
-        $last = $this->model::orderBy('sequence_number', 'desc')
+        $query = $this->model::orderBy('sequence_number', 'desc')
             ->where('company_id', $companyId)
-            ->where('sequence_number', '<>', null)
-            ->take(1)
-            ->first();
+            ->where('sequence_number', '<>', null);
+
+        foreach ($this->sequenceScope as $column => $value) {
+            $query->where($column, $value);
+        }
+
+        $last = $query->take(1)->first();
 
         $this->nextSequenceNumber = ($last) ? $last->sequence_number + 1 : 1;
 
@@ -134,12 +174,16 @@ class SerialNumberService
     {
         $customer_id = ($this->customer) ? $this->customer->id : 1;
 
-        $last = $this->model::orderBy('customer_sequence_number', 'desc')
+        $query = $this->model::orderBy('customer_sequence_number', 'desc')
             ->where('company_id', $this->company)
             ->where('customer_id', $customer_id)
-            ->where('customer_sequence_number', '<>', null)
-            ->take(1)
-            ->first();
+            ->where('customer_sequence_number', '<>', null);
+
+        foreach ($this->sequenceScope as $column => $value) {
+            $query->where($column, $value);
+        }
+
+        $last = $query->take(1)->first();
 
         $this->nextCustomerSequenceNumber = ($last) ? $last->customer_sequence_number + 1 : 1;
 
diff --git a/app/Support/CreditNoteAmounts.php b/app/Support/CreditNoteAmounts.php
new file mode 100644
index 00000000..9af3859a
--- /dev/null
+++ b/app/Support/CreditNoteAmounts.php
@@ -0,0 +1,312 @@
+<?php
+
+namespace App\Support;
+
+/**
+ * Pure calculator for full and partial credit notes.
+ *
+ * A credit note reverses an invoice, either in full or one chunk of a line at a
+ * time. The naive approach (compute each credit note from the quantities being
+ * credited right now) drifts: three separate 1-unit credits of a 3-unit line
+ * each round their own share of the discount and tax, and the three rounded
+ * shares rarely add back up to what the invoice actually charged. This class
+ * uses the cumulative-difference (telescoping) model instead:
+ *
+ *     credit(before -> after) = cumulative(after) - cumulative(before)
+ *
+ * where `cumulative()` answers a single question ("what would the credit be if
+ * exactly these quantities had been credited, in one go?") and always derives
+ * that answer from the ORIGINAL invoice's stored figures, never from previous
+ * credit notes. Summing a chain of credits telescopes:
+ *
+ *     (c1 - c0) + (c2 - c1) + (c3 - c2) = c3 - c0 = c3
+ *
+ * so crediting a 3-unit line as 1+1+1 lands on exactly the same cents as
+ * crediting it 3-at-once, in every field, and a fully credited invoice nets to
+ * zero to the cent. The order the chunks are credited in does not matter
+ * either, because only the endpoint quantities enter the arithmetic.
+ *
+ * Conventions:
+ *
+ * - **Integer minor units.** Every money field is an integer number of cents,
+ *   as stored on the invoice, and every value returned here is an integer.
+ * - **Quantities in hundredths.** `invoice_items.quantity` is `decimal(15,2)`,
+ *   so quantities are carried as integer hundredths internally (2.50 -> 250)
+ *   and only converted back to a decimal at the boundary. Float quantities
+ *   never take part in a comparison or an accumulation.
+ * - **Rounding.** `iround()` is `(int) round((float) $x)`, half away from zero,
+ *   character for character the rule used by {@see DocumentTotals}, so a full
+ *   credit lands on the same cents the invoice was written with.
+ *
+ * Two deliberate decisions in the tax handling:
+ *
+ * - **Fixed-amount tax rows are pro-rated exactly like percentage ones.** It is
+ *   tempting to carry a flat 1.50 handling tax across in full on the first
+ *   credit note, since it is not a function of the amount. But then crediting a
+ *   3-unit line in three chunks charges back 1.50 three times, and the credited
+ *   tax exceeds the tax the invoice ever collected. Pro-rating is what keeps
+ *   the telescoping identity true for every tax row, which is the property the
+ *   books balance on.
+ * - **Percentage tax rows are pro-rated from the STORED amount, not
+ *   re-derived.** The stored `taxes.amount` is what the customer was invoiced
+ *   and what was reported; re-running `percent * base` on the credited slice
+ *   re-does a rounding decision that was already made and can land a cent away
+ *   from it, leaving a residue on a fully credited invoice. The stored integers
+ *   are the ground truth.
+ *
+ * Base (company-currency) figures follow the same rule for the same reason:
+ * they are pro-rated from the original's stored `base_*` integers rather than
+ * recomputed through the exchange rate, so a full credit reproduces the stored
+ * base amounts exactly instead of re-rounding the multiplication.
+ *
+ * This class is deliberately Eloquent-free and static: it takes a plain-array
+ * snapshot of the original invoice and returns plain arrays. Negating the
+ * magnitudes and persisting them is the calling service's job.
+ */
+class CreditNoteAmounts
+{
+    /**
+     * Convert a decimal quantity to integer hundredths (2.50 -> 250).
+     */
+    public static function toHundredths($quantity): int
+    {
+        return (int) round((float) $quantity * 100);
+    }
+
+    /**
+     * Convert integer hundredths back to a decimal quantity (250 -> 2.5).
+     */
+    public static function fromHundredths(int $hundredths): float
+    {
+        return $hundredths / 100;
+    }
+
+    /**
+     * Compute the cumulative credit at the given credited quantities.
+     *
+     * The result is snapshot-shaped: it carries exactly the keys of the
+     * snapshot minus the three configuration flags, so
+     * `cumulative($snapshot, <full quantities>)` reproduces the snapshot field
+     * for field, and `cumulative($snapshot, <all zeros>)` is all zeros.
+     *
+     * @param  array  $snapshot  the ORIGINAL invoice's stored figures:
+     *                           sub_total, discount_val, tax, total, base_sub_total,
+     *                           base_discount_val, base_tax, base_total,
+     *                           discount_per_item ('YES'|'NO'), tax_per_item ('YES'|'NO'),
+     *                           tax_included (bool),
+     *                           items keyed by invoice_items.id, each with
+     *                           price, quantity (decimal), discount_val, tax, total,
+     *                           base_price, base_discount_val, base_tax, base_total and
+     *                           taxes keyed by taxes.id, each with amount + base_amount,
+     *                           taxes: document-level tax rows keyed by taxes.id
+     * @param  array  $creditedHundredths  credited quantity in hundredths, keyed by
+     *                                     invoice_items.id; missing items count as zero
+     * @return array{sub_total:int, discount_val:int, tax:int, total:int, base_sub_total:int,
+     *               base_discount_val:int, base_tax:int, base_total:int, items:array, taxes:array}
+     */
+    public static function cumulative(array $snapshot, array $creditedHundredths): array
+    {
+        $perItemDiscount = self::isYes($snapshot['discount_per_item'] ?? 'NO');
+        $perItemTax = self::isYes($snapshot['tax_per_item'] ?? 'NO');
+        $taxIncluded = (bool) ($snapshot['tax_included'] ?? false);
+
+        $items = [];
+        $subTotal = 0;
+        $itemTaxTotal = 0;
+
+        foreach ($snapshot['items'] ?? [] as $itemId => $item) {
+            $originalHundredths = self::toHundredths($item['quantity'] ?? 0);
+            $credited = (int) ($creditedHundredths[$itemId] ?? 0);
+            $ratio = $originalHundredths === 0 ? 0.0 : $credited / $originalHundredths;
+
+            $amount = self::iround((float) ($item['price'] ?? 0) * $credited / 100);
+            $discount = $perItemDiscount
+                ? self::iround((float) ($item['discount_val'] ?? 0) * $ratio)
+                : 0;
+
+            $taxes = [];
+            $itemTax = 0;
+
+            foreach ($item['taxes'] ?? [] as $taxId => $tax) {
+                $taxAmount = self::iround((float) ($tax['amount'] ?? 0) * $ratio);
+
+                $taxes[$taxId] = [
+                    'amount' => $taxAmount,
+                    'base_amount' => self::scale($tax['base_amount'] ?? 0, $taxAmount, $tax['amount'] ?? 0),
+                ];
+
+                $itemTax += $taxAmount;
+            }
+
+            $total = $amount - $discount;
+
+            $items[$itemId] = [
+                'price' => (int) ($item['price'] ?? 0),
+                'quantity' => self::fromHundredths($credited),
+                'discount_val' => $discount,
+                'tax' => $itemTax,
+                'total' => $total,
+                'base_price' => (int) ($item['base_price'] ?? 0),
+                'base_discount_val' => self::scale($item['base_discount_val'] ?? 0, $discount, $item['discount_val'] ?? 0),
+                'base_tax' => self::scale($item['base_tax'] ?? 0, $itemTax, $item['tax'] ?? 0),
+                'base_total' => self::scale($item['base_total'] ?? 0, $total, $item['total'] ?? 0),
+                'taxes' => $taxes,
+            ];
+
+            $subTotal += $total;
+            $itemTaxTotal += $itemTax;
+        }
+
+        $originalSubTotal = (int) ($snapshot['sub_total'] ?? 0);
+        $ratio = $originalSubTotal === 0 ? 0.0 : $subTotal / $originalSubTotal;
+
+        $discountVal = self::iround((float) ($snapshot['discount_val'] ?? 0) * $ratio);
+
+        $documentTaxes = [];
+        $documentTaxTotal = 0;
+
+        foreach ($snapshot['taxes'] ?? [] as $taxId => $tax) {
+            $taxAmount = self::iround((float) ($tax['amount'] ?? 0) * $ratio);
+
+            $documentTaxes[$taxId] = [
+                'amount' => $taxAmount,
+                'base_amount' => self::scale($tax['base_amount'] ?? 0, $taxAmount, $tax['amount'] ?? 0),
+            ];
+
+            $documentTaxTotal += $taxAmount;
+        }
+
+        $tax = $perItemTax ? $itemTaxTotal : $documentTaxTotal;
+        $total = $taxIncluded ? $subTotal - $discountVal : $subTotal - $discountVal + $tax;
+
+        return [
+            'sub_total' => $subTotal,
+            'discount_val' => $discountVal,
+            'tax' => $tax,
+            'total' => $total,
+            'base_sub_total' => self::scale($snapshot['base_sub_total'] ?? 0, $subTotal, $originalSubTotal),
+            'base_discount_val' => self::scale($snapshot['base_discount_val'] ?? 0, $discountVal, $snapshot['discount_val'] ?? 0),
+            'base_tax' => self::scale($snapshot['base_tax'] ?? 0, $tax, $snapshot['tax'] ?? 0),
+            'base_total' => self::scale($snapshot['base_total'] ?? 0, $total, $snapshot['total'] ?? 0),
+            'items' => $items,
+            'taxes' => $documentTaxes,
+        ];
+    }
+
+    /**
+     * Compute one credit note: the field-wise difference between the cumulative
+     * credit at $after and the cumulative credit at $before.
+     *
+     * Everything comes back as a POSITIVE magnitude. The caller negates what it
+     * persists (a credit note stores negative prices, totals and tax amounts)
+     * and copies the descriptive fields (item name, description, unit, tax
+     * names, percentages, tax_type_id) from the original rows itself; only
+     * amounts and quantities are decided here.
+     *
+     * `items` is keyed by the ORIGINAL invoice item id and only contains lines
+     * whose credited quantity actually moved; a line credited by zero produces
+     * no credit-note row.
+     *
+     * @param  array  $snapshot  the ORIGINAL invoice's stored figures, see {@see cumulative()}
+     * @param  array  $before  already-credited quantities in hundredths, keyed by invoice_items.id
+     * @param  array  $after  total credited quantities after this credit note, same keying
+     * @return array{sub_total:int, discount_val:int, tax:int, total:int, base_sub_total:int,
+     *               base_discount_val:int, base_tax:int, base_total:int,
+     *               items:array<int, array{source_invoice_item_id:int, price:int, base_price:int,
+     *               quantity:float, discount_val:int, tax:int, total:int, base_discount_val:int,
+     *               base_tax:int, base_total:int, taxes:array<int, array{amount:int, base_amount:int}>}>,
+     *               taxes:array<int, array{amount:int, base_amount:int}>}
+     */
+    public static function forCredit(array $snapshot, array $before, array $after): array
+    {
+        $from = self::cumulative($snapshot, $before);
+        $to = self::cumulative($snapshot, $after);
+
+        $items = [];
+
+        foreach ($to['items'] as $itemId => $item) {
+            $previous = $from['items'][$itemId];
+
+            $hundredths = self::toHundredths($item['quantity']) - self::toHundredths($previous['quantity']);
+
+            if ($hundredths === 0) {
+                continue;
+            }
+
+            $taxes = [];
+
+            foreach ($item['taxes'] as $taxId => $tax) {
+                $taxes[$taxId] = [
+                    'amount' => $tax['amount'] - $previous['taxes'][$taxId]['amount'],
+                    'base_amount' => $tax['base_amount'] - $previous['taxes'][$taxId]['base_amount'],
+                ];
+            }
+
+            $items[$itemId] = [
+                'source_invoice_item_id' => (int) $itemId,
+                'price' => $item['price'],
+                'base_price' => $item['base_price'],
+                'quantity' => self::fromHundredths($hundredths),
+                'discount_val' => $item['discount_val'] - $previous['discount_val'],
+                'tax' => $item['tax'] - $previous['tax'],
+                'total' => $item['total'] - $previous['total'],
+                'base_discount_val' => $item['base_discount_val'] - $previous['base_discount_val'],
+                'base_tax' => $item['base_tax'] - $previous['base_tax'],
+                'base_total' => $item['base_total'] - $previous['base_total'],
+                'taxes' => $taxes,
+            ];
+        }
+
+        $taxes = [];
+
+        foreach ($to['taxes'] as $taxId => $tax) {
+            $taxes[$taxId] = [
+                'amount' => $tax['amount'] - $from['taxes'][$taxId]['amount'],
+                'base_amount' => $tax['base_amount'] - $from['taxes'][$taxId]['base_amount'],
+            ];
+        }
+
+        return [
+            'sub_total' => $to['sub_total'] - $from['sub_total'],
+            'discount_val' => $to['discount_val'] - $from['discount_val'],
+            'tax' => $to['tax'] - $from['tax'],
+            'total' => $to['total'] - $from['total'],
+            'base_sub_total' => $to['base_sub_total'] - $from['base_sub_total'],
+            'base_discount_val' => $to['base_discount_val'] - $from['base_discount_val'],
+            'base_tax' => $to['base_tax'] - $from['base_tax'],
+            'base_total' => $to['base_total'] - $from['base_total'],
+            'items' => $items,
+            'taxes' => $taxes,
+        ];
+    }
+
+    /**
+     * Pro-rate a stored base amount by the share its non-base counterpart got.
+     *
+     * A zero denominator means the original never carried the amount, so the
+     * credited share of it is zero.
+     */
+    protected static function scale($value, $part, $whole): int
+    {
+        $whole = (float) $whole;
+
+        if ($whole == 0.0) {
+            return 0;
+        }
+
+        return self::iround((float) $value * (float) $part / $whole);
+    }
+
+    /**
+     * Round to an integer, half away from zero, exactly as DocumentTotals does.
+     */
+    protected static function iround($value): int
+    {
+        return (int) round((float) $value);
+    }
+
+    protected static function isYes($flag): bool
+    {
+        return is_string($flag) && strtoupper(trim($flag)) === 'YES';
+    }
+}
diff --git a/database/factories/InvoiceFactory.php b/database/factories/InvoiceFactory.php
index 97e7f26e..02e9ccbd 100644
--- a/database/factories/InvoiceFactory.php
+++ b/database/factories/InvoiceFactory.php
@@ -81,6 +81,7 @@ class InvoiceFactory extends Factory
         $sequenceNumber = (new SerialNumberService)
             ->setModel(new Invoice)
             ->setCompany(User::find(1)->companies()->first()->id)
+            ->setSequenceScope(['type' => Invoice::TYPE_INVOICE])
             ->setNextNumbers();
 
         return [
diff --git a/database/migrations/2026_08_02_120000_add_credit_note_support.php b/database/migrations/2026_08_02_120000_add_credit_note_support.php
new file mode 100644
index 00000000..1b4bf481
--- /dev/null
+++ b/database/migrations/2026_08_02_120000_add_credit_note_support.php
@@ -0,0 +1,148 @@
+<?php
+
+use App\Models\Company;
+use App\Models\CompanySetting;
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     *
+     * Adds credit-note support across invoices, invoice_items, taxes and
+     * company_settings. A credit note (Stornorechnung) is stored as an invoice
+     * row with type = CREDIT_NOTE that references the original invoice it
+     * reverses, either in full or in part.
+     *
+     * The sibling columns invoices.status / paid_status are plain strings, so
+     * "type" follows the same convention (string + application-level
+     * validation) rather than a DB enum.
+     *
+     * The default on "type" is load-bearing, not cosmetic: it backfills every
+     * pre-existing row with INVOICE. The serial-number queries are scoped by
+     * type, so rows left with a NULL type would fall outside that scope and
+     * numbering would restart from 1 on an existing install.
+     *
+     * related_invoice_id and source_invoice_item_id are plain unsignedInteger
+     * columns with an index and NO DB-level foreign key, which is the
+     * codebase-wide convention (see PRs #618 / #683). invoices.id and
+     * invoice_items.id are INT UNSIGNED (both tables use increments(), not
+     * bigIncrements()), so the column widths have to match exactly, and
+     * constraints across the three supported drivers have repeatedly broken
+     * the v2 to v3 upgrade. The relations are declared on the Invoice and
+     * InvoiceItem models and the delete-side bookkeeping lives in
+     * InvoiceService, not in the database.
+     *
+     * source_invoice_item_id records which line of the original invoice a
+     * credit-note line credits, which is what partial credit notes need in
+     * order to know how much of each line has already been credited.
+     *
+     * Credit-note line items store negative unit prices, so invoice_items.price
+     * and base_price are widened from UNSIGNED to signed. The other amount
+     * columns (total, tax, discount_val, base_*) were already made signed in
+     * 2024_10_09_103306_modify_invoices_to_allow_negative_values.
+     *
+     * taxes.base_amount gets the same treatment, which fixes a pre-existing
+     * bug rather than only serving credit notes: taxes.amount was widened to
+     * signed in 2024_02_08_181804_taxes_amount_as_signed, but base_amount
+     * (added as unsignedBigInteger in 2021_07_16_075100) was left behind. Any
+     * negative tax row on a company with an exchange rate therefore fails to
+     * insert under strict-mode MySQL, and credit notes produce exactly those
+     * rows.
+     *
+     * Finally, every existing company is given a credit_note_number_format.
+     * New companies get the setting from CompanyService::setupDefaultSettings(),
+     * but installs created before independent credit note numbering have no
+     * such row. CompanySetting::getSetting() then returns null, the format
+     * string is empty, and SerialNumberService silently generates an empty
+     * document number, so the data has to be backfilled rather than defaulted
+     * in code.
+     */
+    public function up(): void
+    {
+        Schema::table('invoices', function (Blueprint $table) {
+            if (! Schema::hasColumn('invoices', 'type')) {
+                $table->string('type')->default('INVOICE')->after('status');
+            }
+
+            if (! Schema::hasColumn('invoices', 'related_invoice_id')) {
+                $table->unsignedInteger('related_invoice_id')->nullable()->after('type')->index();
+            }
+
+            if (! Schema::hasColumn('invoices', 'credit_reason')) {
+                $table->text('credit_reason')->nullable()->after('related_invoice_id');
+            }
+        });
+
+        Schema::table('invoice_items', function (Blueprint $table) {
+            $table->bigInteger('price')->change();
+            $table->bigInteger('base_price')->nullable()->change();
+
+            if (! Schema::hasColumn('invoice_items', 'source_invoice_item_id')) {
+                $table->unsignedInteger('source_invoice_item_id')->nullable()->after('invoice_id')->index();
+            }
+        });
+
+        Schema::table('taxes', function (Blueprint $table) {
+            $table->bigInteger('base_amount')->nullable()->change();
+        });
+
+        Company::all()->each(function ($company) {
+            $format = CompanySetting::getSetting('credit_note_number_format', $company->id);
+
+            if ($format) {
+                return;
+            }
+
+            CompanySetting::setSettings([
+                'credit_note_number_format' => '{{SERIES:CN}}{{DELIMITER:-}}{{SEQUENCE:6}}',
+            ], $company->id);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * The indexes on related_invoice_id and source_invoice_item_id have to go
+     * before their columns do. MySQL/MariaDB and PostgreSQL would drop them
+     * along with the columns, but SQLite does not: its "alter table drop
+     * column" leaves the index behind and then fails with "no such column".
+     */
+    public function down(): void
+    {
+        CompanySetting::where('option', 'credit_note_number_format')->delete();
+
+        Schema::table('taxes', function (Blueprint $table) {
+            $table->unsignedBigInteger('base_amount')->nullable()->change();
+        });
+
+        Schema::table('invoice_items', function (Blueprint $table) {
+            if (Schema::hasColumn('invoice_items', 'source_invoice_item_id')) {
+                $table->dropIndex(['source_invoice_item_id']);
+                $table->dropColumn('source_invoice_item_id');
+            }
+        });
+
+        Schema::table('invoice_items', function (Blueprint $table) {
+            $table->unsignedBigInteger('price')->change();
+            $table->unsignedBigInteger('base_price')->nullable()->change();
+        });
+
+        Schema::table('invoices', function (Blueprint $table) {
+            if (Schema::hasColumn('invoices', 'credit_reason')) {
+                $table->dropColumn('credit_reason');
+            }
+
+            if (Schema::hasColumn('invoices', 'related_invoice_id')) {
+                $table->dropIndex(['related_invoice_id']);
+                $table->dropColumn('related_invoice_id');
+            }
+
+            if (Schema::hasColumn('invoices', 'type')) {
+                $table->dropColumn('type');
+            }
+        });
+    }
+};
diff --git a/lang/de.json b/lang/de.json
index 9d052c66..9fb747bc 100644
--- a/lang/de.json
+++ b/lang/de.json
@@ -454,6 +454,28 @@
     "cloned_successfully": "Rechnung erfolgreich kopiert",
     "clone_invoice": "Rechnung kopieren",
     "confirm_clone": "Diese Rechnung wird kopiert",
+    "create_credit_note": "Stornorechnung erstellen",
+    "credit_note_created": "Stornorechnung erfolgreich erstellt",
+    "credit_note": "Stornorechnung",
+    "credit_note_items": "Zu stornierende Positionen",
+    "credit_note_quantity_to_credit": "Storno-Menge",
+    "credit_note_original_quantity": "Berechnet",
+    "credit_note_already_credited": "Storniert",
+    "credit_note_remaining_quantity": "Verbleibend",
+    "credit_note_amount": "Betrag",
+    "credit_note_credited_subtotal": "Stornierte Zwischensumme",
+    "credit_note_reason": "Grund",
+    "credit_note_reason_placeholder": "Optional: warum diese Rechnung storniert wird",
+    "credit_note_proportional_note": "Rabatte und Steuern werden anteilig zu den oben gewählten Positionen und Mengen storniert.",
+    "credit_note_select_at_least_one_item": "Bitte mindestens eine zu stornierende Position auswählen.",
+    "credit_note_quantity_exceeds_remaining": "Die Menge übersteigt die verbleibende Menge dieser Position.",
+    "credit_note_fully_credited_line": "Vollständig storniert",
+    "credited_amount": "Stornierter Betrag",
+    "partially_credited": "Teilweise storniert",
+    "partially_credited_via_credit_notes": "Teilweise storniert durch Stornorechnung",
+    "original_invoice": "Originalrechnung",
+    "cancelled": "Storniert",
+    "cancelled_via_credit_note": "Storniert durch Stornorechnung",
     "item": {
       "title": "Titel des Artikels",
       "description": "Beschreibung",
@@ -1049,6 +1071,13 @@
         "disable_on_invoice_sent": "Deaktivieren, nachdem Rechnung gesendet wurde",
         "retrospective_edits_description": " Basierend auf den Gesetzen Ihres Landes oder Ihrer Präferenz, können Sie Benutzer daran hindern, fertige Rechnungen zu bearbeiten."
       },
+      "credit_notes": {
+        "title": "Stornorechnungen",
+        "credit_note_number_format": "Stornorechnungsnummernformat",
+        "credit_note_number_format_description": "Passen Sie an, wie Ihre Stornorechnungsnummer automatisch generiert wird, wenn Sie eine neue Stornorechnung erstellen. Stornorechnungen werden unabhängig von Rechnungen nummeriert.",
+        "preview_credit_note_number": "Vorschau Stornorechnungsnummer",
+        "credit_note_settings_updated": "Stornorechnungseinstellungen erfolgreich aktualisiert"
+      },
       "estimates": {
         "title": "Angebote",
         "estimate_number_format": "Angebotsnummernformat",
@@ -1591,6 +1620,18 @@
     "estimate_number_used": "Die Angebotsnummer ist bereits vergeben.",
     "invoice_number_used": "Die Rechnungsnummer ist bereits vergeben.",
     "payment_attached": "Dieser Rechnung ist bereits eine Zahlung zugewiesen. Bitte zuerst die zugewiesenen Zahlungen löschen, um mit der Entfernung fortzufahren.",
+    "credit_note_attached": "Diese Rechnung wurde durch eine Stornorechnung storniert. Bitte auch die Stornorechnung auswählen, um beide Belege gemeinsam zu löschen.",
+    "credit_note_cannot_be_created_from_credit_note": "Zu einer Stornorechnung kann keine weitere Stornorechnung erstellt werden.",
+    "draft_invoice_cannot_be_credited": "Ein Rechnungsentwurf kann nicht storniert werden. Bitte den Entwurf stattdessen bearbeiten oder löschen.",
+    "invoice_already_fully_credited": "Bei dieser Rechnung gibt es nichts mehr zu stornieren.",
+    "credit_quantity_exceeds_remaining": "Eine der Mengen übersteigt das, was bei dieser Position noch zu stornieren ist.",
+    "credit_amount_exceeds_invoice_balance": "Der Stornobetrag übersteigt den offenen Betrag der Rechnung.",
+    "credit_note_must_credit_something": "Bitte mindestens eine Position mit einer zu stornierenden Menge auswählen.",
+    "credit_item_not_on_invoice": "Eine der gewählten Positionen gehört nicht zu dieser Rechnung.",
+    "credit_quantity_invalid": "Bitte für jede gewählte Position eine gültige Menge größer als null angeben.",
+    "credit_note_cannot_be_cloned": "Eine Stornorechnung kann nicht kopiert werden.",
+    "credit_note_cannot_be_converted_to_estimate": "Eine Stornorechnung kann nicht in ein Angebot umgewandelt werden.",
+    "payment_amount_exceeds_invoice_due_amount": "Der Zahlungsbetrag übersteigt den offenen Betrag der Rechnung.",
     "payment_number_used": "Die Zahlungsnummer ist bereits vergeben.",
     "name_already_taken": "Der Name ist bereits vergeben.",
     "receipt_does_not_exist": "Beleg existiert nicht.",
@@ -1619,6 +1660,15 @@
   "pdf_invoice_number": "Rechnungsnummer",
   "pdf_invoice_date": "Rechnungsdatum",
   "pdf_invoice_due_date": "Fälligkeitsdatum",
+  "pdf_credit_note_label": "Stornorechnung",
+  "pdf_credit_note_number": "Stornorechnungsnummer",
+  "pdf_credit_note_date": "Stornodatum",
+  "pdf_credit_note_reference": "Bezug auf Rechnung :number vom :date",
+  "pdf_credit_note_reason": "Grund: :reason",
+  "pdf_cancelled_label": "Storniert",
+  "pdf_cancelled_via_credit_note": "Storniert durch Stornorechnung :number",
+  "pdf_partially_credited_label": "Teilweise storniert",
+  "pdf_partially_credited_via_credit_notes": ":amount storniert durch Stornorechnung :numbers",
   "pdf_notes": "Hinweise",
   "pdf_items_label": "Artikel",
   "pdf_quantity_label": "Menge",
@@ -1655,6 +1705,7 @@
   "pdf_tax_label": "Steuer",
   "pdf_tax_id": "Steuer-Nr.",
   "pdf_vat_id": "USt.-ID",
+  "pdf_amount_credited": "Stornierter Betrag",
   "pdf_amount_paid": "Bezahlter Betrag",
   "pdf_amount_due": "Offener Betrag",
   "mail_thanks": "Danke",
diff --git a/lang/en.json b/lang/en.json
index 07e390fd..55e191a0 100644
--- a/lang/en.json
+++ b/lang/en.json
@@ -472,6 +472,28 @@
     "confirm_clone": "This invoice will be cloned into a new Invoice",
     "convert_to_estimate": "Convert to Estimate",
     "confirm_convert_to_estimate": "This invoice will be converted into a new Estimate",
+    "create_credit_note": "Create Credit Note",
+    "credit_note_created": "Credit note created successfully",
+    "credit_note": "Credit Note",
+    "credit_note_items": "Lines to credit",
+    "credit_note_quantity_to_credit": "Credit qty",
+    "credit_note_original_quantity": "Invoiced",
+    "credit_note_already_credited": "Credited",
+    "credit_note_remaining_quantity": "Remaining",
+    "credit_note_amount": "Amount",
+    "credit_note_credited_subtotal": "Credited subtotal",
+    "credit_note_reason": "Reason",
+    "credit_note_reason_placeholder": "Optional: why this invoice is being credited",
+    "credit_note_proportional_note": "Discounts and taxes are credited in proportion to the lines and quantities selected above.",
+    "credit_note_select_at_least_one_item": "Select at least one line to credit.",
+    "credit_note_quantity_exceeds_remaining": "Quantity is more than the remaining quantity of this line.",
+    "credit_note_fully_credited_line": "Fully credited",
+    "credited_amount": "Credited amount",
+    "partially_credited": "Partially credited",
+    "partially_credited_via_credit_notes": "Partially credited via credit note",
+    "original_invoice": "Original invoice",
+    "cancelled": "Cancelled",
+    "cancelled_via_credit_note": "Cancelled via credit note",
     "item": {
       "title": "Item Title",
       "description": "Description",
@@ -1199,6 +1221,13 @@
         "disable_on_invoice_sent": "Disable after invoice is sent",
         "retrospective_edits_description": " Based on your country's laws or your preference, you can restrict users from editing finalised invoices."
       },
+      "credit_notes": {
+        "title": "Credit Notes",
+        "credit_note_number_format": "Credit Note Number Format",
+        "credit_note_number_format_description": "Customize how your credit note number gets generated automatically when you create a new credit note. Credit notes are numbered independently of invoices.",
+        "preview_credit_note_number": "Preview Credit Note Number",
+        "credit_note_settings_updated": "Credit Note Settings updated successfully"
+      },
       "estimates": {
         "title": "Estimates",
         "estimate_number_format": "Estimate Number Format",
@@ -1800,6 +1829,18 @@
     "estimate_number_used": "The estimate number has already been taken.",
     "invoice_number_used": "The invoice number has already been taken.",
     "payment_attached": "This invoice already has a payment attached to it. Make sure to delete the attached payments first in order to go ahead with the removal.",
+    "credit_note_attached": "This invoice has been reversed by a credit note. Select the credit note as well to delete both documents together.",
+    "credit_note_cannot_be_created_from_credit_note": "A credit note cannot be created from another credit note.",
+    "draft_invoice_cannot_be_credited": "A draft invoice cannot be credited. Edit or delete the draft instead.",
+    "invoice_already_fully_credited": "This invoice has nothing left to credit.",
+    "credit_quantity_exceeds_remaining": "One of the quantities is more than what is left to credit on that line.",
+    "credit_amount_exceeds_invoice_balance": "The credit is more than the invoice's outstanding balance.",
+    "credit_note_must_credit_something": "Select at least one line with a quantity to credit.",
+    "credit_item_not_on_invoice": "One of the selected lines does not belong to this invoice.",
+    "credit_quantity_invalid": "Enter a valid quantity greater than zero for every selected line.",
+    "credit_note_cannot_be_cloned": "A credit note cannot be cloned.",
+    "credit_note_cannot_be_converted_to_estimate": "A credit note cannot be converted to an estimate.",
+    "payment_amount_exceeds_invoice_due_amount": "The payment is more than the invoice's outstanding balance.",
     "payment_number_used": "The payment number has already been taken.",
     "name_already_taken": "The name has already been taken.",
     "receipt_does_not_exist": "Receipt does not exist.",
@@ -1828,6 +1869,15 @@
   "pdf_invoice_number": "Invoice Number",
   "pdf_invoice_date": "Invoice Date",
   "pdf_invoice_due_date": "Due Date",
+  "pdf_credit_note_label": "Credit Note",
+  "pdf_credit_note_number": "Credit Note Number",
+  "pdf_credit_note_date": "Credit Note Date",
+  "pdf_credit_note_reference": "With reference to invoice :number dated :date",
+  "pdf_credit_note_reason": "Reason: :reason",
+  "pdf_cancelled_label": "Cancelled",
+  "pdf_cancelled_via_credit_note": "Cancelled via credit note :number",
+  "pdf_partially_credited_label": "Partially Credited",
+  "pdf_partially_credited_via_credit_notes": "Credited :amount via credit note :numbers",
   "pdf_notes": "Notes",
   "pdf_items_label": "Items",
   "pdf_quantity_label": "Quantity",
@@ -1865,6 +1915,7 @@
   "pdf_tax_label": "Tax",
   "pdf_tax_id": "Tax-ID",
   "pdf_vat_id": "VAT-ID",
+  "pdf_amount_credited": "Amount Credited",
   "pdf_amount_paid": "Amount Paid",
   "pdf_amount_due": "Amount Due",
   "mail_thanks": "Thanks",
diff --git a/lang/fr.json b/lang/fr.json
index c22525b1..e3b6bc50 100644
--- a/lang/fr.json
+++ b/lang/fr.json
@@ -454,6 +454,28 @@
     "cloned_successfully": "Facture clonée",
     "clone_invoice": "Dupliquer",
     "confirm_clone": "Cette facture sera dupliquée dans une nouvelle facture",
+    "create_credit_note": "Créer un avoir",
+    "credit_note_created": "Avoir créé",
+    "credit_note": "Avoir",
+    "credit_note_items": "Lignes à créditer",
+    "credit_note_quantity_to_credit": "Qté à créditer",
+    "credit_note_original_quantity": "Facturé",
+    "credit_note_already_credited": "Crédité",
+    "credit_note_remaining_quantity": "Restant",
+    "credit_note_amount": "Montant",
+    "credit_note_credited_subtotal": "Sous-total crédité",
+    "credit_note_reason": "Motif",
+    "credit_note_reason_placeholder": "Facultatif : pourquoi cette facture est créditée",
+    "credit_note_proportional_note": "Les remises et les taxes sont créditées au prorata des lignes et des quantités sélectionnées ci-dessus.",
+    "credit_note_select_at_least_one_item": "Sélectionnez au moins une ligne à créditer.",
+    "credit_note_quantity_exceeds_remaining": "La quantité dépasse la quantité restante de cette ligne.",
+    "credit_note_fully_credited_line": "Entièrement crédité",
+    "credited_amount": "Montant crédité",
+    "partially_credited": "Partiellement créditée",
+    "partially_credited_via_credit_notes": "Partiellement créditée par l'avoir",
+    "original_invoice": "Facture d'origine",
+    "cancelled": "Annulée",
+    "cancelled_via_credit_note": "Annulée par un avoir",
     "item": {
       "title": "Titre de l'article",
       "description": "Description",
@@ -1049,6 +1071,13 @@
         "disable_on_invoice_sent": "Désactiver après l'envoi de la facture",
         "retrospective_edits_description": "Vous pouvez empêcher la modification de factures lorsque un paiement est effectué, pour être en conformité avec la loi de certains pays."
       },
+      "credit_notes": {
+        "title": "Avoirs",
+        "credit_note_number_format": "Format de numéro",
+        "credit_note_number_format_description": "Personnalisez la structure de vos numéros d'avoir. Les avoirs sont numérotés indépendamment des factures.",
+        "preview_credit_note_number": "Aperçu",
+        "credit_note_settings_updated": "Paramètres des avoirs mis à jour"
+      },
       "estimates": {
         "title": "Devis",
         "estimate_number_format": "Format de numéro",
@@ -1591,6 +1620,18 @@
     "estimate_number_used": "Ce numéro de devis est déjà utilisé.",
     "invoice_number_used": "Ce numéro de facture est déjà utilisé.",
     "payment_attached": "Cette facture est liée à un reçu de paiement. Veuillez d'abord le supprimer avant de poursuivre.",
+    "credit_note_attached": "Cette facture a été annulée par un avoir. Sélectionnez également l'avoir afin de supprimer les deux documents ensemble.",
+    "credit_note_cannot_be_created_from_credit_note": "Un avoir ne peut pas être créé à partir d'un autre avoir.",
+    "draft_invoice_cannot_be_credited": "Une facture au brouillon ne peut pas faire l'objet d'un avoir. Modifiez ou supprimez plutôt le brouillon.",
+    "invoice_already_fully_credited": "Il ne reste plus rien à créditer sur cette facture.",
+    "credit_quantity_exceeds_remaining": "L'une des quantités dépasse ce qu'il reste à créditer sur cette ligne.",
+    "credit_amount_exceeds_invoice_balance": "Le crédit dépasse le solde restant dû de la facture.",
+    "credit_note_must_credit_something": "Sélectionnez au moins une ligne avec une quantité à créditer.",
+    "credit_item_not_on_invoice": "L'une des lignes sélectionnées n'appartient pas à cette facture.",
+    "credit_quantity_invalid": "Saisissez une quantité valide supérieure à zéro pour chaque ligne sélectionnée.",
+    "credit_note_cannot_be_cloned": "Un avoir ne peut pas être dupliqué.",
+    "credit_note_cannot_be_converted_to_estimate": "Un avoir ne peut pas être converti en devis.",
+    "payment_amount_exceeds_invoice_due_amount": "Le paiement dépasse le solde restant dû de la facture.",
     "payment_number_used": "Ce numéro de paiement est déjà utilisé.",
     "name_already_taken": "Ce nom est déjà pris.",
     "receipt_does_not_exist": "Le reçu n'existe pas.",
@@ -1619,6 +1660,15 @@
   "pdf_invoice_number": "Numéro",
   "pdf_invoice_date": "Date",
   "pdf_invoice_due_date": "Date d'échéance",
+  "pdf_credit_note_label": "Avoir",
+  "pdf_credit_note_number": "Numéro",
+  "pdf_credit_note_date": "Date",
+  "pdf_credit_note_reference": "En référence à la facture :number du :date",
+  "pdf_credit_note_reason": "Motif : :reason",
+  "pdf_cancelled_label": "Annulée",
+  "pdf_cancelled_via_credit_note": "Annulée par l'avoir :number",
+  "pdf_partially_credited_label": "Partiellement créditée",
+  "pdf_partially_credited_via_credit_notes": ":amount crédités par l'avoir :numbers",
   "pdf_notes": "Notes de bas de page",
   "pdf_items_label": "Articles",
   "pdf_quantity_label": "Quantité",
@@ -1655,6 +1705,7 @@
   "pdf_tax_label": "Taxe",
   "pdf_tax_id": "N° fiscal",
   "pdf_vat_id": "N° de TVA",
+  "pdf_amount_credited": "Montant crédité",
   "pdf_amount_paid": "Montant acquitté",
   "pdf_amount_due": "Montant dû",
   "mail_thanks": "Merci",
diff --git a/lang/it.json b/lang/it.json
index 2f2ab5d7..76764e63 100644
--- a/lang/it.json
+++ b/lang/it.json
@@ -454,6 +454,28 @@
     "cloned_successfully": "Fattura copiata con successo",
     "clone_invoice": "Clona Fattura",
     "confirm_clone": "Questa fattura verrà clonata in una nuova fattura",
+    "create_credit_note": "Crea Nota di Credito",
+    "credit_note_created": "Nota di credito creata con successo",
+    "credit_note": "Nota di Credito",
+    "credit_note_items": "Righe da accreditare",
+    "credit_note_quantity_to_credit": "Qtà da accreditare",
+    "credit_note_original_quantity": "Fatturato",
+    "credit_note_already_credited": "Accreditato",
+    "credit_note_remaining_quantity": "Rimanente",
+    "credit_note_amount": "Importo",
+    "credit_note_credited_subtotal": "Subtotale accreditato",
+    "credit_note_reason": "Motivo",
+    "credit_note_reason_placeholder": "Facoltativo: perché questa fattura viene accreditata",
+    "credit_note_proportional_note": "Sconti e imposte vengono accreditati in proporzione alle righe e alle quantità selezionate sopra.",
+    "credit_note_select_at_least_one_item": "Seleziona almeno una riga da accreditare.",
+    "credit_note_quantity_exceeds_remaining": "La quantità supera la quantità rimanente di questa riga.",
+    "credit_note_fully_credited_line": "Completamente accreditata",
+    "credited_amount": "Importo accreditato",
+    "partially_credited": "Parzialmente accreditata",
+    "partially_credited_via_credit_notes": "Parzialmente accreditata tramite nota di credito",
+    "original_invoice": "Fattura originale",
+    "cancelled": "Annullata",
+    "cancelled_via_credit_note": "Annullata tramite nota di credito",
     "item": {
       "title": "Titolo Commessa",
       "description": "Descrizione",
@@ -1049,6 +1071,13 @@
         "disable_on_invoice_sent": "Disabilita dopo l'invio della fattura",
         "retrospective_edits_description": " In base alle leggi del tuo paese o alle tue preferenze, puoi limitare gli utenti dalla modifica delle fatture finalizzate."
       },
+      "credit_notes": {
+        "title": "Note di Credito",
+        "credit_note_number_format": "Formato Numero Nota di Credito",
+        "credit_note_number_format_description": "Personalizza il modo in cui il numero della nota di credito viene generato automaticamente quando crei una nuova nota di credito. Le note di credito sono numerate indipendentemente dalle fatture.",
+        "preview_credit_note_number": "Anteprima Numero Nota di Credito",
+        "credit_note_settings_updated": "Impostazioni note di credito aggiornate con successo"
+      },
       "estimates": {
         "title": "Preventivi",
         "estimate_number_format": "Formato del Numero di Serie",
@@ -1591,6 +1620,18 @@
     "estimate_number_used": "Il numero stimato è già stato preso.",
     "invoice_number_used": "Il numero della fattura è già stato utilizzato.",
     "payment_attached": "Una delle fatture selezionate ha già associato un pagamento. Assicurati di eliminare il pagamento associato prima di procedere con la rimozione.",
+    "credit_note_attached": "Questa fattura è stata stornata da una nota di credito. Seleziona anche la nota di credito per eliminare entrambi i documenti insieme.",
+    "credit_note_cannot_be_created_from_credit_note": "Non è possibile creare una nota di credito a partire da un'altra nota di credito.",
+    "draft_invoice_cannot_be_credited": "Una fattura in bozza non può essere stornata. Modifica o elimina la bozza.",
+    "invoice_already_fully_credited": "Su questa fattura non resta nulla da accreditare.",
+    "credit_quantity_exceeds_remaining": "Una delle quantità supera quanto resta da accreditare su quella riga.",
+    "credit_amount_exceeds_invoice_balance": "L'accredito supera il saldo residuo della fattura.",
+    "credit_note_must_credit_something": "Seleziona almeno una riga con una quantità da accreditare.",
+    "credit_item_not_on_invoice": "Una delle righe selezionate non appartiene a questa fattura.",
+    "credit_quantity_invalid": "Inserisci una quantità valida maggiore di zero per ogni riga selezionata.",
+    "credit_note_cannot_be_cloned": "Una nota di credito non può essere clonata.",
+    "credit_note_cannot_be_converted_to_estimate": "Una nota di credito non può essere convertita in un preventivo.",
+    "payment_amount_exceeds_invoice_due_amount": "Il pagamento supera il saldo residuo della fattura.",
     "payment_number_used": "Questa modalità di pagamento è già stata inserita.",
     "name_already_taken": "Questo Nome esiste giá.",
     "receipt_does_not_exist": "La ricevuta non esiste.",
@@ -1619,6 +1660,15 @@
   "pdf_invoice_number": "Numero Fattura",
   "pdf_invoice_date": "Data fattura",
   "pdf_invoice_due_date": "Data di scadenza",
+  "pdf_credit_note_label": "Nota di Credito",
+  "pdf_credit_note_number": "Numero Nota di Credito",
+  "pdf_credit_note_date": "Data nota di credito",
+  "pdf_credit_note_reference": "In riferimento alla fattura :number del :date",
+  "pdf_credit_note_reason": "Motivo: :reason",
+  "pdf_cancelled_label": "Annullata",
+  "pdf_cancelled_via_credit_note": "Annullata tramite nota di credito :number",
+  "pdf_partially_credited_label": "Parzialmente accreditata",
+  "pdf_partially_credited_via_credit_notes": ":amount accreditati tramite nota di credito :numbers",
   "pdf_notes": "Note",
   "pdf_items_label": "Commesse",
   "pdf_quantity_label": "Quantità",
@@ -1655,6 +1705,7 @@
   "pdf_tax_label": "Tassa",
   "pdf_tax_id": "Codice Fiscale",
   "pdf_vat_id": "P. IVA",
+  "pdf_amount_credited": "Importo accreditato",
   "pdf_amount_paid": "Importo pagato",
   "pdf_amount_due": "Importo Dovuto",
   "mail_thanks": "Grazie",
diff --git a/lang/mk.json b/lang/mk.json
index ab30c790..d89b5528 100644
--- a/lang/mk.json
+++ b/lang/mk.json
@@ -469,6 +469,28 @@
     "confirm_clone": "Оваа фактура ќе биде клонирана во нова фактура",
     "convert_to_estimate": "Конвертирај во понуда",
     "confirm_convert_to_estimate": "Оваа фактура ќе биде конвертирана во нова понуда",
+    "create_credit_note": "Креирај книжно одобрение",
+    "credit_note_created": "Книжното одобрение е успешно креирано",
+    "credit_note": "Книжно одобрение",
+    "credit_note_items": "Ставки за сторнирање",
+    "credit_note_quantity_to_credit": "Количина за сторнирање",
+    "credit_note_original_quantity": "Фактурирано",
+    "credit_note_already_credited": "Сторнирано",
+    "credit_note_remaining_quantity": "Преостанато",
+    "credit_note_amount": "Износ",
+    "credit_note_credited_subtotal": "Сторниран меѓузбир",
+    "credit_note_reason": "Причина",
+    "credit_note_reason_placeholder": "Опционално: зошто оваа фактура се сторнира",
+    "credit_note_proportional_note": "Попустите и даноците се сторнираат пропорционално на избраните ставки и количини погоре.",
+    "credit_note_select_at_least_one_item": "Изберете барем една ставка за сторнирање.",
+    "credit_note_quantity_exceeds_remaining": "Количината е поголема од преостанатата количина на оваа ставка.",
+    "credit_note_fully_credited_line": "Целосно сторнирана",
+    "credited_amount": "Сторниран износ",
+    "partially_credited": "Делумно сторнирана",
+    "partially_credited_via_credit_notes": "Делумно сторнирана со книжно одобрение",
+    "original_invoice": "Оригинална фактура",
+    "cancelled": "Сторнирана",
+    "cancelled_via_credit_note": "Сторнирана со книжно одобрение",
     "item": {
       "title": "Наслов на ставка",
       "description": "Опис",
@@ -1090,6 +1112,13 @@
         "disable_on_invoice_sent": "Оневозможи откако фактурата е испратена",
         "retrospective_edits_description": " Врз основа на законите на вашата држава или вашите преференци, можете да им забраните на корисниците да менуваат финализирани фактури."
       },
+      "credit_notes": {
+        "title": "Книжни одобренија",
+        "credit_note_number_format": "Формат на број на книжно одобрение",
+        "credit_note_number_format_description": "Прилагодете како автоматски се генерира бројот на книжното одобрение кога ќе креирате ново книжно одобрение. Книжните одобренија се нумерираат независно од фактурите.",
+        "preview_credit_note_number": "Преглед на број на книжно одобрение",
+        "credit_note_settings_updated": "Поставките за книжно одобрение се ажурирани успешно"
+      },
       "estimates": {
         "title": "Понуди",
         "estimate_number_format": "Формат на број на понуда",
@@ -1664,6 +1693,18 @@
     "estimate_number_used": "Бројот на понудата е веќе зафатен.",
     "invoice_number_used": "Бројот на фактурата е веќе зафатен.",
     "payment_attached": "Оваа фактура веќе има прикачено плаќање. Прво избришете ги прикачените плаќања за да продолжите со отстранувањето.",
+    "credit_note_attached": "Оваа фактура е сторнирана со книжно одобрение. Изберете го и книжното одобрение за да ги избришете двата документа заедно.",
+    "credit_note_cannot_be_created_from_credit_note": "Книжно одобрение не може да се креира од друго книжно одобрение.",
+    "draft_invoice_cannot_be_credited": "Фактура во нацрт не може да се сторнира. Наместо тоа изменете го или избришете го нацртот.",
+    "invoice_already_fully_credited": "На оваа фактура не останало ништо за сторнирање.",
+    "credit_quantity_exceeds_remaining": "Една од количините е поголема од преостанатото за сторнирање на таа ставка.",
+    "credit_amount_exceeds_invoice_balance": "Сторното е поголемо од преостанатото салдо на фактурата.",
+    "credit_note_must_credit_something": "Изберете барем една ставка со количина за сторнирање.",
+    "credit_item_not_on_invoice": "Една од избраните ставки не припаѓа на оваа фактура.",
+    "credit_quantity_invalid": "Внесете важечка количина поголема од нула за секоја избрана ставка.",
+    "credit_note_cannot_be_cloned": "Книжно одобрение не може да се клонира.",
+    "credit_note_cannot_be_converted_to_estimate": "Книжно одобрение не може да се конвертира во понуда.",
+    "payment_amount_exceeds_invoice_due_amount": "Плаќањето е поголемо од преостанатото салдо на фактурата.",
     "payment_number_used": "Бројот на плаќањето е веќе зафатен.",
     "name_already_taken": "Името е веќе зафатено.",
     "receipt_does_not_exist": "Сметката не постои.",
@@ -1692,6 +1733,15 @@
   "pdf_invoice_number": "Број на фактура",
   "pdf_invoice_date": "Датум на фактура",
   "pdf_invoice_due_date": "Датум на доспевање",
+  "pdf_credit_note_label": "Книжно одобрение",
+  "pdf_credit_note_number": "Број на книжно одобрение",
+  "pdf_credit_note_date": "Датум на книжно одобрение",
+  "pdf_credit_note_reference": "Во однос на фактура :number од :date",
+  "pdf_credit_note_reason": "Причина: :reason",
+  "pdf_cancelled_label": "Сторнирана",
+  "pdf_cancelled_via_credit_note": "Сторнирана со книжно одобрение :number",
+  "pdf_partially_credited_label": "Делумно сторнирана",
+  "pdf_partially_credited_via_credit_notes": "Сторнирани :amount со книжно одобрение :numbers",
   "pdf_notes": "Белешки",
   "pdf_items_label": "Ставки",
   "pdf_quantity_label": "Количина",
@@ -1728,6 +1778,7 @@
   "pdf_tax_label": "Данок",
   "pdf_tax_id": "Даночен број",
   "pdf_vat_id": "ДДВ број",
+  "pdf_amount_credited": "Сторниран износ",
   "pdf_amount_paid": "Платен износ",
   "pdf_amount_due": "Доспеан износ",
   "mail_thanks": "Благодарам",
diff --git a/resources/scripts/api/services/invoice.service.ts b/resources/scripts/api/services/invoice.service.ts
index 14e70597..cf260de5 100644
--- a/resources/scripts/api/services/invoice.service.ts
+++ b/resources/scripts/api/services/invoice.service.ts
@@ -1,6 +1,10 @@
 import { client } from '../client'
 import { API } from '../endpoints'
-import type { Invoice, CreateInvoicePayload } from '@/scripts/types/domain/invoice'
+import type {
+  Invoice,
+  CreateInvoicePayload,
+  CreateCreditNotePayload,
+} from '@/scripts/types/domain/invoice'
 import type {
   ApiResponse,
   PaginatedResponse,
@@ -108,6 +112,18 @@ export const invoiceService = {
     return data
   },
 
+  /**
+   * Credit an invoice. Omitting `payload.items` reverses every remaining
+   * quantity; supplying them credits only those lines.
+   */
+  async createCreditNote(
+    id: number,
+    payload?: CreateCreditNotePayload,
+  ): Promise<ApiResponse<Invoice>> {
+    const { data } = await client.post(`${API.INVOICES}/${id}/credit-note`, payload ?? {})
+    return data
+  },
+
   async changeStatus(payload: InvoiceStatusPayload): Promise<ApiResponse<Invoice>> {
     const { data } = await client.post(`${API.INVOICES}/${payload.id}/status`, payload)
     return data
diff --git a/resources/scripts/features/company/dashboard/views/DashboardView.vue b/resources/scripts/features/company/dashboard/views/DashboardView.vue
index 23c004b6..fc9dfe3d 100644
--- a/resources/scripts/features/company/dashboard/views/DashboardView.vue
+++ b/resources/scripts/features/company/dashboard/views/DashboardView.vue
@@ -6,6 +6,7 @@ import DashboardStats from '../components/DashboardStats.vue'
 import DashboardChart from '../components/DashboardChart.vue'
 import DashboardTable from '../components/DashboardTable.vue'
 import SendInvoiceModal from '@/scripts/features/company/invoices/components/SendInvoiceModal.vue'
+import CreditNoteModal from '@/scripts/features/company/invoices/components/CreditNoteModal.vue'
 import SendEstimateModal from '@/scripts/features/company/estimates/components/SendEstimateModal.vue'
 
 const route = useRoute()
@@ -31,5 +32,6 @@ onMounted(() => {
   </BasePage>
 
   <SendInvoiceModal />
+  <CreditNoteModal />
   <SendEstimateModal />
 </template>
diff --git a/resources/scripts/features/company/invoices/components/CreditNoteModal.vue b/resources/scripts/features/company/invoices/components/CreditNoteModal.vue
new file mode 100644
index 00000000..d1b443d5
--- /dev/null
+++ b/resources/scripts/features/company/invoices/components/CreditNoteModal.vue
@@ -0,0 +1,544 @@
+<template>
+  <BaseModal
+    :show="modalActive"
+    @close="closeModal"
+    @open="setInitialData"
+  >
+    <template #header>
+      <div class="flex justify-between w-full">
+        {{ modalStore.title }}
+        <BaseIcon
+          name="XMarkIcon"
+          class="w-6 h-6 text-muted cursor-pointer"
+          @click="closeModal"
+        />
+      </div>
+    </template>
+
+    <form @submit.prevent="submitCreditNote">
+      <div class="px-4 md:px-8 py-4 md:py-6 space-y-6">
+        <div
+          v-if="isFetching"
+          class="flex items-center justify-center py-16"
+        >
+          <LoadingIcon class="h-6 animate-spin text-primary-400" />
+        </div>
+
+        <template v-else>
+          <div>
+            <h6 class="text-sm not-italic font-medium text-heading">
+              {{ $t('invoices.credit_note_items') }}
+            </h6>
+
+            <div
+              class="mt-2 overflow-x-auto rounded-xl border border-line-light bg-surface"
+            >
+              <table class="min-w-full text-center item-table">
+                <colgroup>
+                  <col style="width: 48px" />
+                  <col style="width: 28%; min-width: 200px" />
+                  <col style="width: 12%; min-width: 110px" />
+                  <col style="width: 10%; min-width: 90px" />
+                  <col style="width: 10%; min-width: 90px" />
+                  <col style="width: 10%; min-width: 90px" />
+                  <col style="width: 14%; min-width: 130px" />
+                  <col style="width: 14%; min-width: 110px" />
+                </colgroup>
+
+                <thead class="bg-surface-secondary border-b border-line-light">
+                  <tr>
+                    <th class="px-4 py-3" />
+                    <th
+                      class="px-4 py-3 text-sm not-italic font-medium leading-5 text-left text-body"
+                    >
+                      {{ $t('items.item', 2) }}
+                    </th>
+                    <th
+                      class="px-4 py-3 text-sm not-italic font-medium leading-5 text-right text-body"
+                    >
+                      {{ $t('invoices.item.price') }}
+                    </th>
+                    <th
+                      class="px-4 py-3 text-sm not-italic font-medium leading-5 text-right text-body"
+                    >
+                      {{ $t('invoices.credit_note_original_quantity') }}
+                    </th>
+                    <th
+                      class="px-4 py-3 text-sm not-italic font-medium leading-5 text-right text-body"
+                    >
+                      {{ $t('invoices.credit_note_already_credited') }}
+                    </th>
+                    <th
+                      class="px-4 py-3 text-sm not-italic font-medium leading-5 text-right text-body"
+                    >
+                      {{ $t('invoices.credit_note_remaining_quantity') }}
+                    </th>
+                    <th
+                      class="px-4 py-3 text-sm not-italic font-medium leading-5 text-right text-body"
+                    >
+                      {{ $t('invoices.credit_note_quantity_to_credit') }}
+                    </th>
+                    <th
+                      class="px-4 py-3 text-sm not-italic font-medium leading-5 text-right text-body"
+                    >
+                      {{ $t('invoices.credit_note_amount') }}
+                    </th>
+                  </tr>
+                </thead>
+
+                <tbody>
+                  <tr
+                    v-for="(row, index) in form.rows"
+                    :key="row.id"
+                    class="bg-surface border-b border-line-light last:border-b-0"
+                  >
+                    <td class="px-4 py-4 align-top">
+                      <BaseCheckbox
+                        v-model="row.selected"
+                        :disabled="row.available === 0"
+                        @change="onToggleRow(row)"
+                      />
+                    </td>
+
+                    <td class="px-4 py-4 text-left align-top">
+                      <span class="block text-sm font-medium text-heading">
+                        {{ row.name }}
+                      </span>
+                      <span
+                        v-if="row.description"
+                        class="block mt-0.5 text-xs text-muted"
+                      >
+                        {{ row.description }}
+                      </span>
+                      <span
+                        v-if="row.available === 0"
+                        class="block mt-1 text-xs italic text-subtle"
+                      >
+                        {{ $t('invoices.credit_note_fully_credited_line') }}
+                      </span>
+                    </td>
+
+                    <td class="px-4 py-4 text-sm text-right align-top text-body">
+                      <BaseFormatMoney :amount="row.price" :currency="currency" />
+                    </td>
+
+                    <td class="px-4 py-4 text-sm text-right align-top text-body">
+                      {{ formatQuantity(row.invoiced) }}
+                      <span v-if="row.unitName" class="text-xs text-muted">
+                        {{ row.unitName }}
+                      </span>
+                    </td>
+
+                    <td class="px-4 py-4 text-sm text-right align-top text-body">
+                      {{ formatQuantity(row.credited) }}
+                    </td>
+
+                    <td
+                      class="px-4 py-4 text-sm font-medium text-right align-top text-heading"
+                    >
+                      {{ formatQuantity(row.available) }}
+                    </td>
+
+                    <td class="px-4 py-4 text-right align-top">
+                      <BaseInput
+                        v-model="row.quantity"
+                        :invalid="!!rowError(index)"
+                        :disabled="!row.selected"
+                        type="number"
+                        small
+                        step="0.01"
+                        min="0"
+                        @input="v$.rows.$touch()"
+                      />
+                      <span
+                        v-if="rowError(index)"
+                        class="block mt-1 text-xs text-left text-red-500"
+                      >
+                        {{ rowError(index) }}
+                      </span>
+                    </td>
+
+                    <td
+                      class="px-4 py-4 text-sm text-right align-top text-heading"
+                    >
+                      <BaseFormatMoney
+                        :amount="rowAmount(row)"
+                        :currency="currency"
+                      />
+                    </td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
+
+            <span
+              v-if="selectionError"
+              class="block mt-2 text-sm text-red-500"
+            >
+              {{ selectionError }}
+            </span>
+
+            <div class="flex justify-end mt-4">
+              <div
+                class="flex items-center justify-between w-full text-sm sm:w-80"
+              >
+                <span class="font-medium text-heading">
+                  {{ $t('invoices.credit_note_credited_subtotal') }}
+                </span>
+                <BaseFormatMoney
+                  class="font-semibold text-heading"
+                  :amount="creditedSubtotal"
+                  :currency="currency"
+                />
+              </div>
+            </div>
+
+            <p class="mt-2 text-xs text-right text-muted">
+              {{ $t('invoices.credit_note_proportional_note') }}
+            </p>
+          </div>
+
+          <BaseInputGroup :label="$t('invoices.credit_note_reason')">
+            <BaseTextarea
+              v-model="form.reason"
+              :row="4"
+              rows="4"
+              maxlength="1000"
+              :placeholder="$t('invoices.credit_note_reason_placeholder')"
+            />
+          </BaseInputGroup>
+        </template>
+      </div>
+
+      <div
+        class="z-0 flex justify-end p-4 border-t border-line-default border-solid"
+      >
+        <BaseButton
+          class="mr-3"
+          variant="primary-outline"
+          type="button"
+          @click="closeModal"
+        >
+          {{ $t('general.cancel') }}
+        </BaseButton>
+
+        <BaseButton
+          :loading="isSaving"
+          :disabled="isSaving || isFetching"
+          variant="primary"
+          type="submit"
+        >
+          <template #left="slotProps">
+            <BaseIcon
+              v-if="!isSaving"
+              name="ReceiptRefundIcon"
+              :class="slotProps.class"
+            />
+          </template>
+          {{ $t('invoices.create_credit_note') }}
+        </BaseButton>
+      </div>
+    </form>
+  </BaseModal>
+</template>
+
+<script setup lang="ts">
+import { computed, reactive, ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useRouter } from 'vue-router'
+import useVuelidate from '@vuelidate/core'
+import { helpers } from '@vuelidate/validators'
+import { useModalStore } from '@/scripts/stores/modal.store'
+import { useNotificationStore } from '@/scripts/stores/notification.store'
+import { invoiceService } from '@/scripts/api/services/invoice.service'
+import { calcItemSubtotal } from '@/scripts/features/shared/document-form/use-document-calculations'
+import {
+  handleApiError,
+  getErrorTranslationKey,
+} from '@/scripts/utils/error-handling'
+import LoadingIcon from '@/scripts/components/icons/LoadingIcon.vue'
+import { useInvoiceStore } from '../store'
+import type { Currency } from '@/scripts/types/domain/currency'
+import type { CreditNoteItemPayload } from '@/scripts/types/domain/invoice'
+
+/**
+ * One line of the invoice being credited. Quantities are kept in integer
+ * hundredths so the "is this the last unit?" comparisons never trip over
+ * float drift; `quantity` is the raw string the number input hands back.
+ */
+interface CreditRow {
+  id: number
+  name: string
+  description: string | null
+  unitName: string | null
+  price: number
+  invoiced: number
+  credited: number
+  available: number
+  selected: boolean
+  quantity: string
+}
+
+interface CreditNoteForm {
+  rows: CreditRow[]
+  reason: string
+}
+
+const modalStore = useModalStore()
+const notificationStore = useNotificationStore()
+const invoiceStore = useInvoiceStore()
+const router = useRouter()
+const { t } = useI18n()
+
+const isFetching = ref<boolean>(false)
+const isSaving = ref<boolean>(false)
+const currency = ref<Currency | null>(null)
+
+const form = reactive<CreditNoteForm>({
+  rows: [],
+  reason: '',
+})
+
+const modalActive = computed<boolean>(() => {
+  return modalStore.active && modalStore.componentName === 'CreditNoteModal'
+})
+
+/** Quantity as integer hundredths; NaN when the input is not a number. */
+function toHundredths(value: unknown): number {
+  return Math.round(Number(value) * 100)
+}
+
+function formatQuantity(hundredths: number): string {
+  return String(hundredths / 100)
+}
+
+const rules = computed(() => ({
+  rows: {
+    atLeastOne: helpers.withMessage(
+      t('invoices.credit_note_select_at_least_one_item'),
+      (value: CreditRow[]) =>
+        value.some((row) => row.selected && toHundredths(row.quantity) > 0),
+    ),
+    // Only the selected rows are validated: an unchecked line contributes
+    // nothing to the payload, so whatever is left in its input is irrelevant.
+    $each: helpers.forEach({
+      quantity: {
+        required: helpers.withMessage(
+          t('validation.required'),
+          (value: unknown, row: CreditRow) =>
+            !row.selected || String(value ?? '').trim() !== '',
+        ),
+        numeric: helpers.withMessage(
+          t('validation.numbers_only'),
+          (value: unknown, row: CreditRow) =>
+            !row.selected || Number.isFinite(Number(value)),
+        ),
+        minValue: helpers.withMessage(
+          t('validation.qty_must_greater_than_zero'),
+          (value: unknown, row: CreditRow) =>
+            !row.selected || toHundredths(value) >= 1,
+        ),
+        maxValue: helpers.withMessage(
+          t('invoices.credit_note_quantity_exceeds_remaining'),
+          (value: unknown, row: CreditRow) =>
+            !row.selected || toHundredths(value) <= row.available,
+        ),
+      },
+    }),
+  },
+}))
+
+const v$ = useVuelidate(rules, form)
+
+interface ForEachError {
+  $message: string
+}
+
+/**
+ * Per-row message out of `helpers.forEach`, whose results live under
+ * `$each.$response` rather than on the validation property itself.
+ */
+function rowError(index: number): string {
+  if (!v$.value.rows.$dirty) {
+    return ''
+  }
+
+  const collection = v$.value.rows as unknown as {
+    $each?: { $response?: { $errors?: Record<string, ForEachError[]>[] } }
+  }
+
+  const errors = collection.$each?.$response?.$errors?.[index]?.quantity ?? []
+
+  return errors.length ? String(errors[0].$message) : ''
+}
+
+const selectionError = computed<string>(() => {
+  if (!v$.value.rows.$dirty) {
+    return ''
+  }
+
+  const hasSelection = form.rows.some(
+    (row) => row.selected && toHundredths(row.quantity) > 0,
+  )
+
+  return hasSelection ? '' : t('invoices.credit_note_select_at_least_one_item')
+})
+
+/**
+ * Line amount before document discount and taxes, which is all the client can
+ * honestly show: how those are apportioned is decided by the server.
+ */
+function rowAmount(row: CreditRow): number {
+  if (!row.selected) {
+    return 0
+  }
+
+  const quantity = Number(row.quantity)
+
+  if (!Number.isFinite(quantity) || quantity <= 0) {
+    return 0
+  }
+
+  return calcItemSubtotal(row.price, quantity)
+}
+
+const creditedSubtotal = computed<number>(() => {
+  return form.rows.reduce((sum, row) => sum + rowAmount(row), 0)
+})
+
+/**
+ * Every line credited in full with nothing credited before is exactly what the
+ * server's full-reversal path does, so it is sent as such: no item list at all.
+ */
+const isFullReversal = computed<boolean>(() => {
+  return (
+    form.rows.length > 0 &&
+    form.rows.every(
+      (row) =>
+        row.credited === 0 &&
+        row.selected &&
+        toHundredths(row.quantity) === row.available,
+    )
+  )
+})
+
+function showApiError(err: unknown): void {
+  const normalized = handleApiError(err)
+  const translationKey = getErrorTranslationKey(normalized.message)
+
+  notificationStore.showNotification({
+    type: 'error',
+    message: translationKey ? t(translationKey) : normalized.message,
+  })
+}
+
+/**
+ * Read the invoice straight from the API rather than through the invoice
+ * store: `fetchInvoice` loads the document into the edit form's state, which
+ * would clobber an in-progress edit and rescale its discounts.
+ */
+async function setInitialData(): Promise<void> {
+  resetForm()
+
+  const invoiceId = Number(modalStore.id)
+
+  if (!invoiceId) {
+    return
+  }
+
+  isFetching.value = true
+
+  try {
+    const response = await invoiceService.get(invoiceId)
+    const invoice = response.data
+
+    currency.value = invoice.customer?.currency ?? null
+
+    const creditedQuantities = invoice.credited_quantities ?? {}
+
+    form.rows = (invoice.items ?? []).map((item) => {
+      const invoiced = toHundredths(item.quantity)
+      const credited = toHundredths(creditedQuantities[String(item.id)] ?? 0)
+      const available = Math.max(0, invoiced - credited)
+
+      return {
+        id: Number(item.id),
+        name: item.name,
+        description: item.description,
+        unitName: item.unit_name,
+        price: item.price,
+        invoiced,
+        credited,
+        available,
+        selected: available > 0,
+        quantity: formatQuantity(available),
+      }
+    })
+  } catch (err: unknown) {
+    showApiError(err)
+  } finally {
+    isFetching.value = false
+  }
+}
+
+function onToggleRow(row: CreditRow): void {
+  if (row.selected && !(toHundredths(row.quantity) > 0)) {
+    row.quantity = formatQuantity(row.available)
+  }
+}
+
+async function submitCreditNote(): Promise<void> {
+  v$.value.$touch()
+
+  if (v$.value.$invalid) {
+    return
+  }
+
+  const reason = form.reason.trim() ? form.reason.trim() : null
+
+  isSaving.value = true
+
+  try {
+    const items: CreditNoteItemPayload[] = form.rows
+      .filter((row) => row.selected && toHundredths(row.quantity) > 0)
+      .map((row) => ({
+        id: row.id,
+        quantity: toHundredths(row.quantity) / 100,
+      }))
+
+    const response = await invoiceStore.createCreditNote({
+      id: Number(modalStore.id),
+      reason,
+      ...(isFullReversal.value ? {} : { items }),
+    })
+
+    notificationStore.showNotification({
+      type: 'success',
+      message: t('invoices.credit_note_created'),
+    })
+
+    modalStore.refreshData?.()
+    closeModal()
+
+    router.push(`/admin/invoices/${response.data.data.id}/view`)
+  } catch (err: unknown) {
+    showApiError(err)
+  } finally {
+    isSaving.value = false
+  }
+}
+
+function resetForm(): void {
+  form.rows = []
+  form.reason = ''
+  currency.value = null
+  v$.value.$reset()
+}
+
+function closeModal(): void {
+  modalStore.closeModal()
+  setTimeout(() => {
+    resetForm()
+  }, 300)
+}
+</script>
diff --git a/resources/scripts/features/company/invoices/components/InvoiceDropdown.vue b/resources/scripts/features/company/invoices/components/InvoiceDropdown.vue
index 6a835f03..67048aae 100644
--- a/resources/scripts/features/company/invoices/components/InvoiceDropdown.vue
+++ b/resources/scripts/features/company/invoices/components/InvoiceDropdown.vue
@@ -65,7 +65,12 @@
     <!-- Record Payment -->
     <router-link :to="`/admin/payments/${row.id}/create`">
       <BaseDropdownItem
-        v-if="row.status === 'SENT' && !isDetailView && canCreatePayment"
+        v-if="
+          row.status === 'SENT' &&
+          row.due_amount > 0 &&
+          !isDetailView &&
+          canCreatePayment
+        "
       >
         <BaseIcon
           name="CreditCardIcon"
@@ -102,6 +107,15 @@
       {{ $t('invoices.convert_to_estimate') }}
     </BaseDropdownItem>
 
+    <!-- Create Credit Note (Stornorechnung) -->
+    <BaseDropdownItem v-if="canCreateCreditNote" @click="createCreditNote">
+      <BaseIcon
+        name="ReceiptRefundIcon"
+        class="w-5 h-5 mr-3 text-subtle group-hover:text-muted"
+      />
+      {{ $t('invoices.create_credit_note') }}
+    </BaseDropdownItem>
+
     <!-- Delete Invoice -->
     <BaseDropdownItem v-if="canDelete" @click="removeInvoice">
       <BaseIcon
@@ -121,6 +135,10 @@ import { useInvoiceStore } from '../store'
 import { useDialogStore } from '../../../../stores/dialog.store'
 import { useModalStore } from '../../../../stores/modal.store'
 import { useNotificationStore } from '../../../../stores/notification.store'
+import {
+  handleApiError,
+  getErrorTranslationKey,
+} from '../../../../utils/error-handling'
 import type { Invoice } from '../../../../types/domain/invoice'
 
 interface TableRef {
@@ -177,6 +195,31 @@ const canSendInvoice = computed<boolean>(() => {
   )
 })
 
+// A credit note can only be created from a real invoice (never from another
+// credit note), only while something is left to credit, never from a draft
+// (nothing was issued yet), and only by users allowed to create invoices.
+const canCreateCreditNote = computed<boolean>(() => {
+  return (
+    props.canCreate &&
+    props.row.type !== 'CREDIT_NOTE' &&
+    props.row.credited_status !== 'FULL' &&
+    props.row.status !== 'DRAFT'
+  )
+})
+
+/**
+ * Turn an API failure into a toast, translating the server's message key when
+ * it is one we know about so the user never sees a raw snake_case key.
+ */
+function showApiErrorNotification(err: unknown): void {
+  const normalized = handleApiError(err)
+  const translationKey = getErrorTranslationKey(normalized.message)
+  notificationStore.showNotification({
+    type: 'error',
+    message: translationKey ? t(translationKey) : normalized.message,
+  })
+}
+
 function removeInvoice(): void {
   dialogStore.openDialog({
     title: t('general.are_you_sure'),
@@ -212,8 +255,14 @@ function cloneInvoiceData(): void {
     size: 'lg',
   }).then(async (res: boolean) => {
     if (res) {
-      const response = await invoiceStore.cloneInvoice({ id: props.row.id })
-      router.push(`/admin/invoices/${response.data.data.id}/edit`)
+      // Cloning a credit note is refused by the server (422), so the reason
+      // has to reach the user instead of failing silently.
+      try {
+        const response = await invoiceStore.cloneInvoice({ id: props.row.id })
+        router.push(`/admin/invoices/${response.data.data.id}/edit`)
+      } catch (err: unknown) {
+        showApiErrorNotification(err)
+      }
     }
   })
 }
@@ -229,12 +278,32 @@ function convertToEstimate(): void {
     size: 'lg',
   }).then(async (res: boolean) => {
     if (res) {
-      const response = await invoiceStore.convertToEstimate({ id: props.row.id })
-      router.push(`/admin/estimates/${response.data.data.id}/edit`)
+      // Same as clone(): converting a credit note is refused by the server.
+      try {
+        const response = await invoiceStore.convertToEstimate({ id: props.row.id })
+        router.push(`/admin/estimates/${response.data.data.id}/edit`)
+      } catch (err: unknown) {
+        showApiErrorNotification(err)
+      }
     }
   })
 }
 
+// Crediting is a form, not a confirmation: which lines and how much of each
+// has to be chosen, so the modal owns the whole flow including its errors.
+function createCreditNote(): void {
+  modalStore.openModal({
+    title: t('invoices.create_credit_note'),
+    componentName: 'CreditNoteModal',
+    id: props.row.id,
+    size: 'lg',
+    refreshData: () => {
+      props.loadData?.()
+      props.table?.refresh()
+    },
+  })
+}
+
 function onMarkAsSent(): void {
   dialogStore.openDialog({
     title: t('general.are_you_sure'),
diff --git a/resources/scripts/features/company/invoices/store.ts b/resources/scripts/features/company/invoices/store.ts
index 2d1508e6..4e841b30 100644
--- a/resources/scripts/features/company/invoices/store.ts
+++ b/resources/scripts/features/company/invoices/store.ts
@@ -10,7 +10,12 @@ import type {
   InvoiceStatusPayload,
   InvoiceTemplate,
 } from '../../../api/services/invoice.service'
-import type { Invoice, InvoiceItem, DiscountType } from '../../../types/domain/invoice'
+import type {
+  Invoice,
+  InvoiceItem,
+  DiscountType,
+  CreateCreditNotePayload,
+} from '../../../types/domain/invoice'
 import type { Tax, TaxType } from '../../../types/domain/tax'
 import type { Currency } from '../../../types/domain/currency'
 import type { Customer } from '../../../types/domain/customer'
@@ -367,6 +372,14 @@ export const useInvoiceStore = defineStore('invoice', {
       return { data: response }
     },
 
+    async createCreditNote(
+      data: { id: number } & CreateCreditNotePayload,
+    ): Promise<{ data: { data: Invoice } }> {
+      const { id, ...payload } = data
+      const response = await invoiceService.createCreditNote(id, payload)
+      return { data: response }
+    },
+
     async markAsSent(data: InvoiceStatusPayload): Promise<unknown> {
       const response = await invoiceService.changeStatus(data)
       const pos = this.invoices.findIndex((inv) => inv.id === data.id)
diff --git a/resources/scripts/features/company/invoices/views/InvoiceDetailView.vue b/resources/scripts/features/company/invoices/views/InvoiceDetailView.vue
index 613dc0cd..6da51dd3 100644
--- a/resources/scripts/features/company/invoices/views/InvoiceDetailView.vue
+++ b/resources/scripts/features/company/invoices/views/InvoiceDetailView.vue
@@ -28,7 +28,11 @@
           :to="`/admin/payments/${$route.params.id}/create`"
         >
           <BaseButton
-            v-if="invoiceData.status === 'SENT' || invoiceData.status === 'VIEWED'"
+            v-if="
+              (invoiceData.status === 'SENT' ||
+                invoiceData.status === 'VIEWED') &&
+              invoiceData.due_amount > 0
+            "
             variant="primary"
           >
             {{ $t('invoices.record_payment') }}
@@ -39,7 +43,7 @@
         <InvoiceDropdown
           class="ml-3"
           :row="invoiceData"
-          :load-data="() => loadInvoices()"
+          :load-data="refreshInvoiceList"
           :can-edit="canEdit"
           :can-view="canView"
           :can-create="canCreate"
@@ -51,6 +55,65 @@
       </template>
     </BasePageHeader>
 
+    <!-- Credit note banner + link to the reversed invoice -->
+    <div
+      v-if="invoiceData.type === 'CREDIT_NOTE'"
+      class="px-4 py-2 mb-4 text-sm rounded bg-red-50 text-red-700 border border-red-200"
+    >
+      <div class="flex items-center gap-2">
+        <span class="px-2 py-0.5 text-xs font-semibold rounded bg-red-100">
+          {{ $t('invoices.credit_note') }}
+        </span>
+        <span v-if="invoiceData.related_invoice">
+          {{ $t('invoices.original_invoice') }}:
+          <router-link
+            :to="`/admin/invoices/${invoiceData.related_invoice.id}/view`"
+            class="font-medium underline"
+          >
+            {{ invoiceData.related_invoice.invoice_number }}
+          </router-link>
+        </span>
+      </div>
+      <p v-if="invoiceData.credit_reason" class="mt-1 text-xs">
+        {{ $t('invoices.credit_note_reason') }}: {{ invoiceData.credit_reason }}
+      </p>
+    </div>
+
+    <!-- Credited banner + links to the reversing credit notes (mirror of the
+         credit-note banner above, shown on the ORIGINAL invoice's side). A
+         partial credit gets a softer headline than a full reversal, since the
+         invoice is still live for the remainder. -->
+    <div
+      v-if="invoiceData.type !== 'CREDIT_NOTE' && isCredited"
+      class="flex flex-wrap items-center gap-2 px-4 py-2 mb-4 text-sm rounded bg-amber-50 text-amber-800 border border-amber-300"
+    >
+      <span class="px-2 py-0.5 text-xs font-semibold rounded bg-amber-100">
+        {{ isFullyCredited ? $t('invoices.cancelled') : $t('invoices.partially_credited') }}
+      </span>
+      <span>
+        {{
+          isFullyCredited
+            ? $t('invoices.cancelled_via_credit_note')
+            : $t('invoices.partially_credited_via_credit_notes')
+        }}:
+        <router-link
+          v-for="creditNote in invoiceData.credit_notes"
+          :key="creditNote.id"
+          :to="`/admin/invoices/${creditNote.id}/view`"
+          class="ml-1 font-medium underline"
+        >
+          {{ creditNote.invoice_number }}
+        </router-link>
+      </span>
+      <span v-if="invoiceData.credited_total" class="font-medium">
+        {{ $t('invoices.credited_amount') }}:
+        <BaseFormatMoney
+          :amount="invoiceData.credited_total"
+          :currency="invoiceData.customer?.currency"
+        />
+      </span>
+    </div>
+
     <!-- Sidebar -->
     <div
       class="fixed top-0 left-0 hidden h-full pt-16 pb-[6.4rem] ml-56 bg-surface xl:ml-64 w-88 xl:block"
@@ -169,6 +232,23 @@
               >
                 <BaseInvoiceStatusLabel :status="invoice.status" />
               </BaseEstimateStatusBadge>
+
+              <!-- An invoice reversed by credit notes is cancelled (in full)
+                   or partly credited: show a distinct badge so it's clear at a
+                   glance in the list, mirroring InvoiceIndexView.vue's
+                   cell-due_amount badges. -->
+              <span
+                v-if="invoice.type !== 'CREDIT_NOTE' && invoice.credited_status === 'FULL'"
+                class="inline-block px-1 py-0.5 ml-1 text-xs font-medium rounded bg-amber-100 text-amber-800 whitespace-nowrap"
+              >
+                {{ $t('invoices.cancelled') }}
+              </span>
+              <span
+                v-else-if="invoice.type !== 'CREDIT_NOTE' && invoice.credited_status === 'PARTIAL'"
+                class="inline-block px-1 py-0.5 ml-1 text-[10px] font-medium rounded bg-amber-100 text-amber-800 whitespace-nowrap"
+              >
+                {{ $t('invoices.partially_credited') }}
+              </span>
             </div>
 
             <div class="flex-1 whitespace-nowrap right">
@@ -202,6 +282,7 @@
     <BasePdfPreview :src="shareableLink" />
 
     <SendInvoiceModal />
+    <CreditNoteModal />
   </BasePage>
 </template>
 
@@ -212,6 +293,7 @@ import { useI18n } from 'vue-i18n'
 import { useInvoiceStore } from '../store'
 import InvoiceDropdown from '../components/InvoiceDropdown.vue'
 import SendInvoiceModal from '../components/SendInvoiceModal.vue'
+import CreditNoteModal from '../components/CreditNoteModal.vue'
 import LoadingIcon from '@/scripts/components/icons/LoadingIcon.vue'
 import { useUserStore } from '../../../../stores/user.store'
 import { useDialogStore } from '../../../../stores/dialog.store'
@@ -305,6 +387,22 @@ const searchData = reactive<SearchData>({
 
 const pageTitle = computed<string>(() => invoiceData.value?.invoice_number ?? '')
 
+// credited_status is only emitted where the creditNotes relation was loaded,
+// so fall back to the relation itself rather than hiding the banner outright.
+const isCredited = computed<boolean>(() => {
+  const status = invoiceData.value?.credited_status
+
+  if (status) {
+    return status !== 'NONE'
+  }
+
+  return !!invoiceData.value?.credit_notes?.length
+})
+
+const isFullyCredited = computed<boolean>(() => {
+  return invoiceData.value?.credited_status !== 'PARTIAL'
+})
+
 const getOrderBy = computed<boolean>(() => {
   return searchData.orderBy === 'asc' || searchData.orderBy === null
 })
@@ -445,6 +543,15 @@ function onSearched(): void {
   }, 500)
 }
 
+// Reset-and-refetch the sidebar list from page 1. Used after actions that
+// change which invoices exist or their status (e.g. creating a credit
+// note), since `loadInvoices()` alone only appends (it's built for
+// infinite-scroll pagination) and would duplicate already-loaded rows.
+function refreshInvoiceList(): void {
+  invoiceList.value = []
+  loadInvoices()
+}
+
 function sortData(): void {
   if (searchData.orderBy === 'asc') {
     searchData.orderBy = 'desc'
diff --git a/resources/scripts/features/company/invoices/views/InvoiceIndexView.vue b/resources/scripts/features/company/invoices/views/InvoiceIndexView.vue
index 585c704f..a8fd4caf 100644
--- a/resources/scripts/features/company/invoices/views/InvoiceIndexView.vue
+++ b/resources/scripts/features/company/invoices/views/InvoiceIndexView.vue
@@ -276,6 +276,12 @@
             >
               {{ row.data.invoice_number }}
             </router-link>
+            <span
+              v-if="row.data.type === 'CREDIT_NOTE'"
+              class="inline-block ml-2 px-2 py-0.5 text-xs font-medium rounded bg-red-100 text-red-700"
+            >
+              {{ $t('invoices.credit_note') }}
+            </span>
           </template>
 
           <template #cell-invoice_date="{ row }">
@@ -310,12 +316,33 @@
                 {{ $t('invoices.overdue') }}
               </BasePaidStatusBadge>
 
+              <!-- An invoice reversed in full by credit notes is settled but
+                   NOT genuinely paid: show a distinct "Cancelled" badge
+                   instead of the generic paid badge so the two can't be
+                   confused. -->
+              <span
+                v-if="row.data.type !== 'CREDIT_NOTE' && row.data.credited_status === 'FULL'"
+                class="inline-block px-1 py-0.5 ml-2 text-xs font-medium rounded bg-amber-100 text-amber-800 whitespace-nowrap"
+              >
+                {{ $t('invoices.cancelled') }}
+              </span>
+
               <BasePaidStatusBadge
+                v-else
                 :status="row.data.paid_status"
                 class="px-1 py-0.5 ml-2"
               >
                 <BaseInvoiceStatusLabel :status="row.data.paid_status" />
               </BasePaidStatusBadge>
+
+              <!-- A partly credited invoice still has a real paid status, so
+                   this badge sits ALONGSIDE it rather than replacing it. -->
+              <span
+                v-if="row.data.type !== 'CREDIT_NOTE' && row.data.credited_status === 'PARTIAL'"
+                class="inline-block px-1 py-0.5 ml-1 text-[10px] font-medium rounded bg-amber-100 text-amber-800 whitespace-nowrap"
+              >
+                {{ $t('invoices.partially_credited') }}
+              </span>
             </div>
           </template>
 
@@ -472,6 +499,7 @@
   </BasePage>
 
   <SendInvoiceModal />
+  <CreditNoteModal />
 </template>
 
 <script setup lang="ts">
@@ -483,6 +511,7 @@ import { useInvoiceStore } from '../store'
 import { useRecurringInvoiceStore } from '../../recurring-invoices/store'
 import InvoiceDropdown from '../components/InvoiceDropdown.vue'
 import SendInvoiceModal from '../components/SendInvoiceModal.vue'
+import CreditNoteModal from '../components/CreditNoteModal.vue'
 import RecurringInvoiceDropdown from '../../recurring-invoices/components/RecurringInvoiceDropdown.vue'
 import { useUserStore } from '../../../../stores/user.store'
 import { useDialogStore } from '../../../../stores/dialog.store'
diff --git a/resources/scripts/features/company/payments/views/PaymentCreateView.vue b/resources/scripts/features/company/payments/views/PaymentCreateView.vue
index 1bf328e6..1ace0ff8 100644
--- a/resources/scripts/features/company/payments/views/PaymentCreateView.vue
+++ b/resources/scripts/features/company/payments/views/PaymentCreateView.vue
@@ -191,6 +191,11 @@ import { useI18n } from 'vue-i18n'
 import cloneDeep from 'lodash/cloneDeep'
 import { usePaymentStore } from '../store'
 import { useCompanyStore } from '../../../../stores/company.store'
+import { useNotificationStore } from '../../../../stores/notification.store'
+import {
+  handleApiError,
+  getErrorTranslationKey,
+} from '../../../../utils/error-handling'
 import { invoiceService } from '../../../../api/services/invoice.service'
 import { customerService } from '../../../../api/services/customer.service'
 import { ExchangeRateConverter } from '../../../shared/document-form'
@@ -201,6 +206,7 @@ const router = useRouter()
 const { t } = useI18n()
 const paymentStore = usePaymentStore()
 const companyStore = useCompanyStore()
+const notificationStore = useNotificationStore()
 
 const isSaving = ref<boolean>(false)
 const isLoadingInvoices = ref<boolean>(false)
@@ -367,8 +373,19 @@ async function submitPaymentData(): Promise<void> {
 
     const response = await action(data)
     router.push(`/admin/payments/${response.data.data.id}/view`)
-  } catch {
+  } catch (err) {
+    // Surface the failure instead of stalling silently. The server now caps
+    // the amount at the invoice's remaining balance, so a rejected save has
+    // a message worth showing.
     isSaving.value = false
+
+    const normalized = handleApiError(err)
+    const translationKey = getErrorTranslationKey(normalized.message)
+
+    notificationStore.showNotification({
+      type: 'error',
+      message: translationKey ? t(translationKey) : normalized.message,
+    })
   }
 }
 
diff --git a/resources/scripts/features/company/settings/components/InvoicesTab.vue b/resources/scripts/features/company/settings/components/InvoicesTab.vue
index edfb05a9..5317f470 100644
--- a/resources/scripts/features/company/settings/components/InvoicesTab.vue
+++ b/resources/scripts/features/company/settings/components/InvoicesTab.vue
@@ -50,6 +50,14 @@ const sendAsAttachmentField = computed<boolean>({
 
   <BaseDivider class="mt-6 mb-2" />
 
+  <NumberCustomizer
+    type="credit_note"
+    :type-store="invoiceStore"
+    default-series="CN"
+  />
+
+  <BaseDivider class="mt-6 mb-2" />
+
   <InvoicesTabDueDate />
 
   <BaseDivider class="mt-6 mb-2" />
diff --git a/resources/scripts/types/domain/invoice.ts b/resources/scripts/types/domain/invoice.ts
index b720ee5d..976677e7 100644
--- a/resources/scripts/types/domain/invoice.ts
+++ b/resources/scripts/types/domain/invoice.ts
@@ -20,6 +20,28 @@ export enum InvoicePaidStatus {
 
 export type DiscountType = 'fixed' | 'percentage'
 
+export type InvoiceType = 'INVOICE' | 'CREDIT_NOTE'
+
+export interface CreditNoteRef {
+  id: number
+  invoice_number: string
+}
+
+/**
+ * How much of an invoice has been reversed by credit notes: nothing, some of
+ * it, or all of it. Emitted by the API alongside `credited_total`.
+ */
+export type CreditedStatus = 'NONE' | 'PARTIAL' | 'FULL'
+
+export interface RelatedInvoice {
+  id: number
+  invoice_number: string
+  invoice_date: string
+  formatted_invoice_date: string
+  total: number
+  unique_hash: string
+}
+
 export interface InvoiceItem {
   id: number | string
   name: string
@@ -51,6 +73,16 @@ export interface Invoice {
   due_date: string
   invoice_number: string
   reference_number: string | null
+  type: InvoiceType
+  related_invoice_id: number | null
+  related_invoice?: RelatedInvoice | null
+  credit_notes?: CreditNoteRef[]
+  credit_reason?: string | null
+  /** Amount already credited off this invoice, as a positive number of cents. */
+  credited_total?: number
+  credited_status?: CreditedStatus
+  /** Credited quantity per original invoice item, keyed by invoice_items.id. */
+  credited_quantities?: Record<string, number>
   status: InvoiceStatus
   paid_status: InvoicePaidStatus
   tax_per_item: string | null
@@ -119,6 +151,21 @@ export interface CreateInvoicePayload {
   fields?: CustomFieldValue[]
 }
 
+export interface CreditNoteItemPayload {
+  /** id of the ORIGINAL invoice item being credited. */
+  id: number
+  quantity: number
+}
+
+/**
+ * Payload for POST /invoices/{id}/credit-note. An absent or empty `items` list
+ * credits every remaining quantity, which is the full reversal.
+ */
+export interface CreateCreditNotePayload {
+  items?: CreditNoteItemPayload[]
+  reason?: string | null
+}
+
 export interface CreateInvoiceItemPayload {
   item_id?: number | null
   name: string
diff --git a/resources/scripts/utils/error-handling.ts b/resources/scripts/utils/error-handling.ts
index cfaccb89..dd2f285f 100644
--- a/resources/scripts/utils/error-handling.ts
+++ b/resources/scripts/utils/error-handling.ts
@@ -48,6 +48,21 @@ const ERROR_TRANSLATION_MAP: Record<string, string> = {
   'Relation invoiceItems exists.': 'items.item_attached_message',
   'Relation taxes exists.': 'settings.tax_types.already_in_use',
   'Relation payments exists.': 'errors.payment_attached',
+  'Credit note exists.': 'errors.credit_note_attached',
+  'a_credit_note_cannot_be_created_from_a_credit_note':
+    'errors.credit_note_cannot_be_created_from_credit_note',
+  'a_draft_invoice_cannot_be_credited': 'errors.draft_invoice_cannot_be_credited',
+  'invoice_already_fully_credited': 'errors.invoice_already_fully_credited',
+  'credit_quantity_exceeds_remaining': 'errors.credit_quantity_exceeds_remaining',
+  'credit_amount_exceeds_invoice_balance': 'errors.credit_amount_exceeds_invoice_balance',
+  'credit_note_must_credit_something': 'errors.credit_note_must_credit_something',
+  'payment_amount_exceeds_invoice_due_amount':
+    'errors.payment_amount_exceeds_invoice_due_amount',
+  'credit_item_not_on_invoice': 'errors.credit_item_not_on_invoice',
+  'credit_quantity_invalid': 'errors.credit_quantity_invalid',
+  'a_credit_note_cannot_be_cloned': 'errors.credit_note_cannot_be_cloned',
+  'a_credit_note_cannot_be_converted_to_an_estimate':
+    'errors.credit_note_cannot_be_converted_to_estimate',
   'The estimate number has already been taken.': 'errors.estimate_number_used',
   'The payment number has already been taken.': 'errors.estimate_number_used',
   'The invoice number has already been taken.': 'errors.invoice_number_used',
diff --git a/resources/views/app/pdf/invoice/invoice1.blade.php b/resources/views/app/pdf/invoice/invoice1.blade.php
index c1e1e18f..2c7a84fd 100644
--- a/resources/views/app/pdf/invoice/invoice1.blade.php
+++ b/resources/views/app/pdf/invoice/invoice1.blade.php
@@ -2,7 +2,7 @@
 <html>
 
 <head>
-    <title>@lang('pdf_invoice_label') - {{ $invoice->invoice_number }}</title>
+    <title>@lang($invoice->isCreditNote() ? 'pdf_credit_note_label' : 'pdf_invoice_label') - {{ $invoice->invoice_number }}</title>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 
 @include("app.pdf.partials.fonts")
@@ -378,6 +378,8 @@
 
     <div class="content-wrapper">
         <div style="padding-top: 30px">
+            @include('app.pdf.partials.credit-note-banner')
+
             <div class="company-address-container company-address">
                 {!! $company_address !!}
             </div>
@@ -385,17 +387,19 @@
             <div class="invoice-details-container">
                 <table>
                     <tr>
-                        <td class="attribute-label">@lang('pdf_invoice_number')</td>
+                        <td class="attribute-label">@lang($invoice->isCreditNote() ? 'pdf_credit_note_number' : 'pdf_invoice_number')</td>
                         <td class="attribute-value"> &nbsp;{{ $invoice->invoice_number }}</td>
                     </tr>
                     <tr>
-                        <td class="attribute-label">@lang('pdf_invoice_date')</td>
+                        <td class="attribute-label">@lang($invoice->isCreditNote() ? 'pdf_credit_note_date' : 'pdf_invoice_date')</td>
                         <td class="attribute-value"> &nbsp;{{ $invoice->formattedInvoiceDate }}</td>
                     </tr>
-                    <tr>
-                        <td class="attribute-label">@lang('pdf_invoice_due_date')</td>
-                        <td class="attribute-value"> &nbsp;{{ $invoice->formattedDueDate }}</td>
-                    </tr>
+                    @unless ($invoice->isCreditNote())
+                        <tr>
+                            <td class="attribute-label">@lang('pdf_invoice_due_date')</td>
+                            <td class="attribute-value"> &nbsp;{{ $invoice->formattedDueDate }}</td>
+                        </tr>
+                    @endunless
                 </table>
             </div>
 
diff --git a/resources/views/app/pdf/invoice/invoice2.blade.php b/resources/views/app/pdf/invoice/invoice2.blade.php
index 2ff4937e..a526ef6c 100644
--- a/resources/views/app/pdf/invoice/invoice2.blade.php
+++ b/resources/views/app/pdf/invoice/invoice2.blade.php
@@ -2,7 +2,7 @@
 <html>
 
 <head>
-    <title>@lang('pdf_invoice_label') - {{ $invoice->invoice_number }}</title>
+    <title>@lang($invoice->isCreditNote() ? 'pdf_credit_note_label' : 'pdf_invoice_label') - {{ $invoice->invoice_number }}</title>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 @include("app.pdf.partials.fonts")
 
@@ -417,7 +417,7 @@
                 </td>
 
                 <td width="40%" class="header-section-right invoice-details-container">
-                    <h1>@lang('pdf_invoice_label')</h1>
+                    <h1>@lang($invoice->isCreditNote() ? 'pdf_credit_note_label' : 'pdf_invoice_label')</h1>
                     <h4>{{ $invoice->invoice_number }}</h4>
                     <h4>{{ $invoice->formattedInvoiceDate }}</h4>
                 </td>
@@ -428,6 +428,8 @@
     <hr>
 
     <div class="content-wrapper">
+        @include('app.pdf.partials.credit-note-banner')
+
         <div class="address-container">
             <div class="company-address-container company-address">
                 {!! $company_address !!}
diff --git a/resources/views/app/pdf/invoice/invoice3.blade.php b/resources/views/app/pdf/invoice/invoice3.blade.php
index bfd12ba1..884aa9ad 100644
--- a/resources/views/app/pdf/invoice/invoice3.blade.php
+++ b/resources/views/app/pdf/invoice/invoice3.blade.php
@@ -2,7 +2,7 @@
 <html>
 
 <head>
-    <title>@lang('pdf_invoice_label') - {{ $invoice->invoice_number }}</title>
+    <title>@lang($invoice->isCreditNote() ? 'pdf_credit_note_label' : 'pdf_invoice_label') - {{ $invoice->invoice_number }}</title>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 
 @include("app.pdf.partials.fonts")
@@ -356,6 +356,8 @@
     <hr class="header-bottom-divider">
 
     <div class="content-wrapper">
+        @include('app.pdf.partials.credit-note-banner')
+
         <div class="main-content">
             <div class="customer-address-container">
                 <div class="billing-address-container billing-address">
@@ -377,17 +379,19 @@
             <div class="invoice-details-container">
                 <table>
                     <tr>
-                        <td class="attribute-label">@lang('pdf_invoice_number')</td>
+                        <td class="attribute-label">@lang($invoice->isCreditNote() ? 'pdf_credit_note_number' : 'pdf_invoice_number')</td>
                         <td class="attribute-value"> &nbsp;{{ $invoice->invoice_number }}</td>
                     </tr>
                     <tr>
-                        <td class="attribute-label">@lang('pdf_invoice_date')</td>
+                        <td class="attribute-label">@lang($invoice->isCreditNote() ? 'pdf_credit_note_date' : 'pdf_invoice_date')</td>
                         <td class="attribute-value"> &nbsp;{{ $invoice->formattedInvoiceDate }}</td>
                     </tr>
-                    <tr>
-                        <td class="attribute-label">@lang('pdf_invoice_due_date')</td>
-                        <td class="attribute-value"> &nbsp;{{ $invoice->formattedDueDate }}</td>
-                    </tr>
+                    @unless ($invoice->isCreditNote())
+                        <tr>
+                            <td class="attribute-label">@lang('pdf_invoice_due_date')</td>
+                            <td class="attribute-value"> &nbsp;{{ $invoice->formattedDueDate }}</td>
+                        </tr>
+                    @endunless
                 </table>
             </div>
             <div style="clear: both;"></div>
diff --git a/resources/views/app/pdf/invoice/partials/table.blade.php b/resources/views/app/pdf/invoice/partials/table.blade.php
index 85704087..3c21dac3 100644
--- a/resources/views/app/pdf/invoice/partials/table.blade.php
+++ b/resources/views/app/pdf/invoice/partials/table.blade.php
@@ -186,15 +186,43 @@
             </td>
         </tr>
 
-        @if($invoice->paid_status === App\Models\Invoice::STATUS_PARTIALLY_PAID || $invoice->paid_status === App\Models\Invoice::STATUS_PAID)
+        @php
+            // What settled the invoice is split between money and credit, because
+            // paid_status alone cannot tell them apart: a credited invoice reads as
+            // paid without a cent having been received. The credited figure is the
+            // negated sum of the credit notes (they store negative totals), and
+            // whatever the balance dropped by beyond that was actually paid.
+            //
+            // For an invoice with no credit notes this is the old expression: the
+            // credited figure is zero and "paid > 0" holds exactly when paid_status
+            // is PARTIALLY_PAID or PAID.
+            $creditedTotal = $invoice->relationLoaded('creditNotes') ? -(int) $invoice->creditNotes->sum('total') : 0;
+            $amountPaid = (int) $invoice->total - (int) $invoice->due_amount - $creditedTotal;
+        @endphp
+
+        @if($creditedTotal > 0)
+            <tr>
+                <td class="border-0 total-border-left total-table-attribute-label">
+                    @lang('pdf_amount_credited')
+                </td>
+                <td class="py-8 border-0 total-border-right item-cell total-table-attribute-value">
+                    {!! format_money_pdf($creditedTotal, $invoice->customer->currency)!!}
+                </td>
+            </tr>
+        @endif
+
+        @if($amountPaid > 0)
             <tr>
                 <td class="border-0 total-border-left total-table-attribute-label">
                     @lang('pdf_amount_paid')
                 </td>
                 <td class="py-8 border-0 total-border-right item-cell total-table-attribute-value">
-                    {!! format_money_pdf($invoice->total - $invoice->due_amount, $invoice->customer->currency)!!}
+                    {!! format_money_pdf($amountPaid, $invoice->customer->currency)!!}
                 </td>
             </tr>
+        @endif
+
+        @if($creditedTotal > 0 || $amountPaid > 0)
             <tr>
                 <td class="border-0 total-border-left total-table-attribute-label">
                     @lang('pdf_amount_due')
diff --git a/resources/views/app/pdf/partials/credit-note-banner.blade.php b/resources/views/app/pdf/partials/credit-note-banner.blade.php
new file mode 100644
index 00000000..d9e47a45
--- /dev/null
+++ b/resources/views/app/pdf/partials/credit-note-banner.blade.php
@@ -0,0 +1,78 @@
+{{--
+    Credit-note / cancellation banner, shared by the three stock invoice
+    templates. Custom templates published into the pdf_templates namespace opt
+    in by including "app.pdf.partials.credit-note-banner" at the top of their
+    content area; they render exactly as before if they do not.
+
+    Renders nothing at all for a regular invoice that has not been reversed, and
+    reads only relations the caller already eager-loaded (getPdfData loads
+    relatedInvoice + creditNotes), so it never issues a query of its own.
+
+    Every style is inline: a body-included partial cannot add rules to <head>,
+    and inline styles are the one thing dompdf and Chromium honour identically.
+--}}
+@if (isset($invoice) && $invoice instanceof \App\Models\Invoice)
+    @php
+        $bannerRelatedInvoice = $invoice->relationLoaded('relatedInvoice') ? $invoice->getRelation('relatedInvoice') : null;
+        $bannerCreditNotes = $invoice->relationLoaded('creditNotes') ? $invoice->getRelation('creditNotes') : null;
+        $bannerCreditNote = $bannerCreditNotes ? $bannerCreditNotes->first() : null;
+    @endphp
+
+    @if ($invoice->isCreditNote())
+        <div style="clear: both; margin: 16px 30px; padding: 8px 12px; border: 1px solid #D64545; line-height: 1.3;">
+            <div style="font-size: 13px; line-height: 1.3; font-weight: bold; text-transform: uppercase; letter-spacing: 0.08em; color: #B22222;">
+                @lang('pdf_credit_note_label')
+            </div>
+            @if ($bannerRelatedInvoice)
+                <div style="font-size: 10px; line-height: 1.3; color: #595959; padding-top: 4px;">
+                    @lang('pdf_credit_note_reference', [
+                        'number' => $bannerRelatedInvoice->invoice_number,
+                        'date' => $bannerRelatedInvoice->formattedInvoiceDate,
+                    ])
+                </div>
+            @endif
+            @if ($invoice->credit_reason)
+                {{-- Free text written by an operator, so it is echoed escaped
+                     rather than through @lang, which does not escape. --}}
+                <div style="font-size: 10px; line-height: 1.3; color: #595959; padding-top: 4px;">
+                    {{ __('pdf_credit_note_reason', ['reason' => $invoice->credit_reason]) }}
+                </div>
+            @endif
+        </div>
+    @elseif ($bannerCreditNote)
+        @php
+            // Credit notes store negative totals, so the credited amount is the
+            // negated sum. An invoice may carry several of them, and the banner
+            // names every one: the reader has to be able to match the figure to
+            // the documents it came from.
+            $bannerCredited = -(int) $bannerCreditNotes->sum('total');
+            $bannerCreditNumbers = $bannerCreditNotes->pluck('invoice_number')->implode(', ');
+        @endphp
+
+        @if ($bannerCredited >= (int) $invoice->total)
+            <div style="clear: both; margin: 16px 30px; padding: 8px 12px; border: 1px solid #F59E0B; background-color: #FFFBEB; line-height: 1.3;">
+                <div style="font-size: 13px; line-height: 1.3; font-weight: bold; text-transform: uppercase; letter-spacing: 0.08em; color: #92400E;">
+                    @lang('pdf_cancelled_label')
+                </div>
+                <div style="font-size: 10px; line-height: 1.3; color: #595959; padding-top: 4px;">
+                    @lang('pdf_cancelled_via_credit_note', ['number' => $bannerCreditNumbers])
+                </div>
+            </div>
+        @else
+            <div style="clear: both; margin: 16px 30px; padding: 8px 12px; border: 1px solid #F59E0B; background-color: #FFFBEB; line-height: 1.3;">
+                <div style="font-size: 13px; line-height: 1.3; font-weight: bold; text-transform: uppercase; letter-spacing: 0.08em; color: #92400E;">
+                    @lang('pdf_partially_credited_label')
+                </div>
+                {{-- format_money_pdf returns markup (the symbol carries its own
+                     font-family), so this line is echoed unescaped and the
+                     document numbers are escaped individually. --}}
+                <div style="font-size: 10px; line-height: 1.3; color: #595959; padding-top: 4px;">
+                    @lang('pdf_partially_credited_via_credit_notes', [
+                        'amount' => format_money_pdf($bannerCredited, $invoice->customer->currency),
+                        'numbers' => e($bannerCreditNumbers),
+                    ])
+                </div>
+            </div>
+        @endif
+    @endif
+@endif
diff --git a/resources/views/emails/send/credit-note.blade.php b/resources/views/emails/send/credit-note.blade.php
new file mode 100644
index 00000000..c1a3a7e5
--- /dev/null
+++ b/resources/views/emails/send/credit-note.blade.php
@@ -0,0 +1,34 @@
+    @component('mail::layout')
+    {{-- Header --}}
+    @slot('header')
+        @component('mail::header', ['url' => ''])
+        @if($data['company']['logo'])
+            <img class="header-logo" src="{{asset($data['company']['logo'])}}" alt="{{$data['company']['name']}}">
+        @else
+            {{$data['company']['name']}}
+        @endif
+        @endcomponent
+    @endslot
+
+    {{-- Body --}}
+    <!-- Body here -->
+
+    {{-- Subcopy --}}
+    @slot('subcopy')
+        @component('mail::subcopy')
+            {!! $data['body'] !!}
+            @if(!$data['attach']['data'])
+                @component('mail::button', ['url' => $data['url']])
+                    @lang('mail_view_invoice')
+                @endcomponent
+            @endif
+        @endcomponent
+    @endslot
+
+    {{-- Footer --}}
+    @slot('footer')
+        @component('mail::footer')
+            Powered by <a class="footer-link" href="https://invoiceshelf.com" target="_blank">InvoiceShelf</a>
+        @endcomponent
+    @endslot
+@endcomponent
diff --git a/routes/api.php b/routes/api.php
index c4a8f02b..e2fbef30 100644
--- a/routes/api.php
+++ b/routes/api.php
@@ -281,6 +281,8 @@ Route::prefix('/v1')->group(function () {
 
             Route::post('/invoices/{invoice}/convert-to-estimate', [InvoicesController::class, 'convertToEstimate']);
 
+            Route::post('/invoices/{invoice}/credit-note', [InvoicesController::class, 'createCreditNote']);
+
             Route::post('/invoices/{invoice}/status', [InvoicesController::class, 'changeStatus']);
 
             Route::post('/invoices/delete', [InvoicesController::class, 'delete']);
diff --git a/tests/Feature/Admin/CreditNoteSchemaTest.php b/tests/Feature/Admin/CreditNoteSchemaTest.php
new file mode 100644
index 00000000..0d539bab
--- /dev/null
+++ b/tests/Feature/Admin/CreditNoteSchemaTest.php
@@ -0,0 +1,95 @@
+<?php
+
+use App\Models\Company;
+use App\Models\CompanySetting;
+use App\Models\Invoice;
+use App\Models\InvoiceItem;
+use App\Models\Tax;
+use Illuminate\Support\Facades\Artisan;
+use Illuminate\Support\Facades\Schema;
+
+beforeEach(function () {
+    Artisan::call('db:seed', ['--class' => 'DatabaseSeeder', '--force' => true]);
+    Artisan::call('db:seed', ['--class' => 'DemoSeeder', '--force' => true]);
+});
+
+/**
+ * Resolve a column definition from the information schema so nullability can
+ * be asserted without reaching for driver-specific SQL.
+ */
+function creditNoteColumn(string $table, string $column): array
+{
+    $definition = collect(Schema::getColumns($table))
+        ->firstWhere('name', $column);
+
+    expect($definition)->not->toBeNull();
+
+    return $definition;
+}
+
+test('the credit note columns exist with the expected nullability', function () {
+    expect(Schema::hasColumn('invoices', 'type'))->toBeTrue();
+    expect(Schema::hasColumn('invoices', 'related_invoice_id'))->toBeTrue();
+    expect(Schema::hasColumn('invoices', 'credit_reason'))->toBeTrue();
+    expect(Schema::hasColumn('invoice_items', 'source_invoice_item_id'))->toBeTrue();
+
+    // "type" is non-nullable and defaults to INVOICE so pre-existing rows fall
+    // inside the type-scoped serial-number queries.
+    expect(creditNoteColumn('invoices', 'type')['nullable'])->toBeFalse();
+
+    expect(creditNoteColumn('invoices', 'related_invoice_id')['nullable'])->toBeTrue();
+    expect(creditNoteColumn('invoices', 'credit_reason')['nullable'])->toBeTrue();
+    expect(creditNoteColumn('invoice_items', 'source_invoice_item_id')['nullable'])->toBeTrue();
+});
+
+test('invoices created without a type default to INVOICE', function () {
+    $invoice = Invoice::factory()->create();
+
+    expect($invoice->fresh()->type)->toBe(Invoice::TYPE_INVOICE);
+});
+
+test('a tax row persists a negative base amount', function () {
+    $tax = Tax::factory()->create([
+        'amount' => -2500,
+        'base_amount' => -2500,
+    ]);
+
+    $this->assertDatabaseHas('taxes', [
+        'id' => $tax->id,
+        'amount' => -2500,
+        'base_amount' => -2500,
+    ]);
+
+    expect((int) $tax->fresh()->base_amount)->toBe(-2500);
+});
+
+test('an invoice item persists a negative price and links its source line', function () {
+    $invoice = Invoice::factory()->hasItems(1)->create();
+    $sourceItem = $invoice->items()->first();
+
+    $creditLine = InvoiceItem::factory()->create([
+        'invoice_id' => $invoice->id,
+        'source_invoice_item_id' => $sourceItem->id,
+        'price' => -1500,
+        'base_price' => -1500,
+        'total' => -1500,
+    ]);
+
+    $this->assertDatabaseHas('invoice_items', [
+        'id' => $creditLine->id,
+        'source_invoice_item_id' => $sourceItem->id,
+        'price' => -1500,
+        'base_price' => -1500,
+    ]);
+});
+
+test('every seeded company has a credit note number format', function () {
+    $companies = Company::all();
+
+    expect($companies)->not->toBeEmpty();
+
+    $companies->each(function ($company) {
+        expect(CompanySetting::getSetting('credit_note_number_format', $company->id))
+            ->toBe('{{SERIES:CN}}{{DELIMITER:-}}{{SEQUENCE:6}}');
+    });
+});
diff --git a/tests/Feature/Admin/CreditNoteTest.php b/tests/Feature/Admin/CreditNoteTest.php
new file mode 100644
index 00000000..ed38911e
--- /dev/null
+++ b/tests/Feature/Admin/CreditNoteTest.php
@@ -0,0 +1,1486 @@
+<?php
+
+use App\Mail\SendCreditNoteMail;
+use App\Mail\SendInvoiceMail;
+use App\Models\Company;
+use App\Models\CompanySetting;
+use App\Models\Invoice;
+use App\Models\InvoiceItem;
+use App\Models\Payment;
+use App\Models\Tax;
+use App\Models\User;
+use App\Services\Document\CreditNoteService;
+use App\Services\Document\InvoiceService;
+use Illuminate\Support\Facades\Artisan;
+use Illuminate\Support\Facades\Mail;
+use Illuminate\Support\Facades\View;
+use Laravel\Sanctum\Sanctum;
+
+use function Pest\Laravel\get;
+use function Pest\Laravel\getJson;
+use function Pest\Laravel\postJson;
+use function Pest\Laravel\putJson;
+
+beforeEach(function () {
+    Artisan::call('db:seed', ['--class' => 'DatabaseSeeder', '--force' => true]);
+    Artisan::call('db:seed', ['--class' => 'DemoSeeder', '--force' => true]);
+
+    $user = User::find(1);
+    $this->withHeaders([
+        'company' => $user->companies()->first()->id,
+    ]);
+    Sanctum::actingAs($user, ['*']);
+});
+
+/**
+ * Create an invoice whose stored document totals agree with its line items.
+ *
+ * That agreement is what every invoice the app writes has and what the
+ * credit-note calculator reads: it derives the credit from the ORIGINAL
+ * invoice's stored figures, so a fixture whose total has nothing to do with its
+ * items describes an invoice that could not exist and produces credit notes to
+ * match.
+ *
+ * @param  array  $lines  [['price' => int, 'quantity' => float, 'taxes' => [['amount' => int, 'percent' => float]]], ...]
+ * @param  array  $attributes  invoice overrides (status, exchange_rate, discount_val, tax_per_item, tax_included, ...)
+ * @param  array  $documentTaxes  document-level tax rows: [['amount' => int, 'percent' => float], ...]
+ */
+function creditableInvoice(array $lines = [['price' => 10000, 'quantity' => 1]], array $attributes = [], array $documentTaxes = []): Invoice
+{
+    $rate = $attributes['exchange_rate'] ?? 1;
+    $taxPerItem = $attributes['tax_per_item'] ?? 'NO';
+    $taxIncluded = $attributes['tax_included'] ?? false;
+    $discountVal = $attributes['discount_val'] ?? 0;
+
+    $subTotal = 0;
+    $itemTaxTotal = 0;
+
+    foreach ($lines as $line) {
+        $subTotal += (int) round($line['price'] * $line['quantity']);
+        $itemTaxTotal += array_sum(array_column($line['taxes'] ?? [], 'amount'));
+    }
+
+    $documentTaxTotal = array_sum(array_column($documentTaxes, 'amount'));
+    $tax = $taxPerItem === 'YES' ? $itemTaxTotal : $documentTaxTotal;
+    $total = $taxIncluded ? $subTotal - $discountVal : $subTotal - $discountVal + $tax;
+
+    $invoice = Invoice::factory()->create(array_merge([
+        'status' => Invoice::STATUS_SENT,
+        'sent' => true,
+        'paid_status' => Invoice::STATUS_UNPAID,
+        'tax_per_item' => 'NO',
+        'discount_per_item' => 'NO',
+        'tax_included' => false,
+        'discount' => 0,
+        'discount_type' => 'fixed',
+    ], $attributes, [
+        'sub_total' => $subTotal,
+        'discount_val' => $discountVal,
+        'tax' => $tax,
+        'total' => $total,
+        'due_amount' => $total,
+        'exchange_rate' => $rate,
+        'base_sub_total' => (int) round($subTotal * $rate),
+        'base_discount_val' => (int) round($discountVal * $rate),
+        'base_tax' => (int) round($tax * $rate),
+        'base_total' => (int) round($total * $rate),
+        'base_due_amount' => (int) round($total * $rate),
+    ]));
+
+    foreach ($lines as $index => $line) {
+        $amount = (int) round($line['price'] * $line['quantity']);
+        $lineTax = array_sum(array_column($line['taxes'] ?? [], 'amount'));
+
+        $item = $invoice->items()->create([
+            'name' => $line['name'] ?? 'Line '.($index + 1),
+            'quantity' => $line['quantity'],
+            'price' => $line['price'],
+            'discount_type' => 'fixed',
+            'discount' => 0,
+            'discount_val' => 0,
+            'tax' => $lineTax,
+            'total' => $amount,
+            'company_id' => $invoice->company_id,
+            'exchange_rate' => $rate,
+            'base_price' => (int) round($line['price'] * $rate),
+            'base_discount_val' => 0,
+            'base_tax' => (int) round($lineTax * $rate),
+            'base_total' => (int) round($amount * $rate),
+        ]);
+
+        foreach ($line['taxes'] ?? [] as $taxRow) {
+            creditableTax($invoice, $taxRow, ['invoice_item_id' => $item->id]);
+        }
+    }
+
+    foreach ($documentTaxes as $taxRow) {
+        creditableTax($invoice, $taxRow, ['invoice_id' => $invoice->id]);
+    }
+
+    return $invoice->fresh();
+}
+
+function creditableTax(Invoice $invoice, array $tax, array $owner): Tax
+{
+    return Tax::factory()->create(array_merge($owner, [
+        'company_id' => $invoice->company_id,
+        'amount' => $tax['amount'],
+        'base_amount' => (int) round($tax['amount'] * $invoice->exchange_rate),
+        'percent' => $tax['percent'] ?? 0,
+        'exchange_rate' => $invoice->exchange_rate,
+    ]));
+}
+
+/**
+ * Record a payment against an invoice and settle its balance the way the
+ * payment flow would.
+ */
+function creditablePayment(Invoice $invoice, int $amount): Payment
+{
+    $payment = Payment::factory()->create([
+        'invoice_id' => $invoice->id,
+        'customer_id' => $invoice->customer_id,
+        'amount' => $amount,
+    ]);
+
+    $due = (int) $invoice->due_amount - $amount;
+
+    $invoice->due_amount = $due;
+    $invoice->base_due_amount = (int) round($due * $invoice->exchange_rate);
+    $invoice->paid_status = $due === 0 ? Invoice::STATUS_PAID : Invoice::STATUS_PARTIALLY_PAID;
+    $invoice->save();
+
+    return $payment;
+}
+
+/**
+ * The ids of an invoice's line items, in creation order.
+ */
+function creditableItemIds(Invoice $invoice): array
+{
+    return $invoice->items()->orderBy('id')->pluck('id')->all();
+}
+
+test('creates a credit note from an invoice with negated totals', function () {
+    $invoice = creditableInvoice([['price' => 10000, 'quantity' => 1]]);
+
+    $response = postJson("api/v1/invoices/{$invoice->id}/credit-note");
+
+    $response->assertStatus(201);
+
+    $creditNoteId = $response->json('data.id');
+
+    $this->assertDatabaseHas('invoices', [
+        'id' => $creditNoteId,
+        'type' => Invoice::TYPE_CREDIT_NOTE,
+        'related_invoice_id' => $invoice->id,
+    ]);
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    // Money stays integer cents and is negated.
+    expect($creditNote->total)->toBe(-10000);
+    expect($creditNote->sub_total)->toBe(-10000);
+    // creator_id is set from the authenticated user (issue #7 from PR #536).
+    expect($creditNote->creator_id)->toBe(1);
+    // The credit note gets its own document number, distinct from the source.
+    expect($creditNote->invoice_number)->not->toBe($invoice->invoice_number);
+});
+
+test('negates the line item amounts of the source invoice', function () {
+    $invoice = creditableInvoice([['price' => 5000, 'quantity' => 2]]);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $item = Invoice::find($creditNoteId)->items->first();
+
+    // Unit price and computed total are negative; amounts remain integer cents.
+    expect($item->price)->toBe(-5000);
+    expect($item->total)->toBe(-10000);
+    expect($item->base_price)->toBeLessThan(0);
+    // Every credit-note line names the invoice line it credits.
+    expect((int) $item->source_invoice_item_id)->toBe($invoice->items->first()->id);
+    // The quantity itself stays positive: the negative price is what makes the
+    // line a credit.
+    expect((float) $item->quantity)->toBe(2.0);
+});
+
+test('an empty request body reverses the whole invoice to the cent', function () {
+    $invoice = creditableInvoice(
+        [['price' => 2500, 'quantity' => 4]],
+        ['discount_val' => 1000],
+        [['amount' => 630, 'percent' => 7]]
+    );
+
+    expect($invoice->total)->toBe(9630);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNote = Invoice::with('items', 'taxes')->find($creditNoteId);
+
+    // Field for field the negation of the invoice, which is what a full
+    // reversal has always produced and must keep producing.
+    expect($creditNote->sub_total)->toBe(-10000)
+        ->and($creditNote->discount_val)->toBe(-1000)
+        ->and($creditNote->tax)->toBe(-630)
+        ->and($creditNote->total)->toBe(-9630)
+        ->and((int) $creditNote->base_sub_total)->toBe(-10000)
+        ->and((int) $creditNote->base_discount_val)->toBe(-1000)
+        ->and((int) $creditNote->base_tax)->toBe(-630)
+        ->and((int) $creditNote->base_total)->toBe(-9630);
+
+    $item = $creditNote->items->first();
+
+    expect($item->price)->toBe(-2500)
+        ->and($item->total)->toBe(-10000)
+        ->and((int) $item->base_total)->toBe(-10000)
+        ->and((float) $item->quantity)->toBe(4.0)
+        ->and((int) $item->source_invoice_item_id)->toBe($invoice->items->first()->id);
+
+    expect((int) $creditNote->taxes->first()->amount)->toBe(-630);
+});
+
+test('credits a single line of a three line invoice', function () {
+    $invoice = creditableInvoice(
+        [
+            ['price' => 1000, 'quantity' => 1],
+            ['price' => 1000, 'quantity' => 1],
+            ['price' => 1000, 'quantity' => 1],
+        ],
+        ['discount_val' => 300],
+        [['amount' => 189, 'percent' => 7]]
+    );
+
+    expect($invoice->total)->toBe(2889);
+
+    [$first] = creditableItemIds($invoice);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $first, 'quantity' => 1]],
+    ])->assertStatus(201)->json('data.id');
+
+    $creditNote = Invoice::with('items')->find($creditNoteId);
+
+    // One third of the lines credited, so one third of the document-level
+    // discount and tax come back with it.
+    expect($creditNote->sub_total)->toBe(-1000)
+        ->and($creditNote->discount_val)->toBe(-100)
+        ->and($creditNote->tax)->toBe(-63)
+        ->and($creditNote->total)->toBe(-963)
+        ->and((int) $creditNote->base_total)->toBe(-963);
+
+    expect($creditNote->items)->toHaveCount(1);
+    expect((int) $creditNote->items->first()->source_invoice_item_id)->toBe($first);
+
+    $invoice->refresh();
+
+    // The balance drops by exactly the credited amount and no more.
+    expect((int) $invoice->due_amount)->toBe(1926)
+        ->and((int) $invoice->base_due_amount)->toBe(1926)
+        // A credit is not a payment: nothing was paid, so the invoice is still
+        // unpaid, just for less.
+        ->and($invoice->paid_status)->toBe(Invoice::STATUS_UNPAID)
+        ->and($invoice->status)->toBe(Invoice::STATUS_SENT);
+});
+
+test('a second credit note credits the remaining quantity', function () {
+    $invoice = creditableInvoice(
+        [
+            ['price' => 1000, 'quantity' => 1],
+            ['price' => 1000, 'quantity' => 1],
+            ['price' => 1000, 'quantity' => 1],
+        ],
+        ['discount_val' => 300],
+        [['amount' => 189, 'percent' => 7]]
+    );
+
+    [$first, $second, $third] = creditableItemIds($invoice);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $first, 'quantity' => 1]],
+    ])->assertStatus(201);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [
+            ['id' => $second, 'quantity' => 1],
+            ['id' => $third, 'quantity' => 1],
+        ],
+    ])->assertStatus(201);
+
+    // Telescoping: the chain of credits sums to exactly the invoice, to the
+    // cent, in every field.
+    expect((int) $invoice->creditNotes()->sum('total'))->toBe(-$invoice->total)
+        ->and((int) $invoice->creditNotes()->sum('sub_total'))->toBe(-$invoice->sub_total)
+        ->and((int) $invoice->creditNotes()->sum('tax'))->toBe(-$invoice->tax)
+        ->and((int) $invoice->creditNotes()->sum('discount_val'))->toBe(-$invoice->discount_val);
+
+    $invoice->refresh();
+
+    expect((int) $invoice->due_amount)->toBe(0)
+        ->and($invoice->paid_status)->toBe(Invoice::STATUS_PAID)
+        ->and($invoice->status)->toBe(Invoice::STATUS_COMPLETED);
+
+    getJson("api/v1/invoices/{$invoice->id}")
+        ->assertOk()
+        ->assertJsonPath('data.credited_status', 'FULL')
+        ->assertJsonPath('data.credited_total', 2889);
+});
+
+test('a credit note may not exceed the unpaid balance of the invoice', function () {
+    // 100 units at 1.00 each: crediting n units credits exactly n cents.
+    $invoice = creditableInvoice([['price' => 100, 'quantity' => 100]]);
+
+    creditablePayment($invoice, 4000);
+
+    [$line] = creditableItemIds($invoice);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 50]],
+    ])->assertStatus(201);
+
+    $invoice->refresh();
+
+    expect((int) $invoice->due_amount)->toBe(1000)
+        // Money was received, so the invoice stays partially paid even though
+        // part of it was credited away.
+        ->and($invoice->paid_status)->toBe(Invoice::STATUS_PARTIALLY_PAID);
+
+    // One cent past the unpaid balance: the invoice would end up owing the
+    // customer money it was never paid.
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 10.01]],
+    ])
+        ->assertStatus(422)
+        ->assertJsonPath('errors.invoice.0', 'credit_amount_exceeds_invoice_balance');
+
+    // Exactly the unpaid balance is fine.
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 10]],
+    ])->assertStatus(201);
+
+    $invoice->refresh();
+
+    expect((int) $invoice->due_amount)->toBe(0)
+        ->and($invoice->paid_status)->toBe(Invoice::STATUS_PAID)
+        ->and($invoice->status)->toBe(Invoice::STATUS_COMPLETED);
+});
+
+test('a line cannot be credited beyond the quantity that was invoiced', function () {
+    $invoice = creditableInvoice([['price' => 1000, 'quantity' => 3]]);
+
+    [$line] = creditableItemIds($invoice);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 4]],
+    ])
+        ->assertStatus(422)
+        ->assertJsonPath('errors.invoice.0', 'credit_quantity_exceeds_remaining');
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 2]],
+    ])->assertStatus(201);
+
+    // Two of the three units are gone, so only one is still creditable.
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 2]],
+    ])
+        ->assertStatus(422)
+        ->assertJsonPath('errors.invoice.0', 'credit_quantity_exceeds_remaining');
+
+    expect($invoice->creditNotes()->count())->toBe(1);
+});
+
+test('cannot credit a line that belongs to another invoice', function () {
+    $invoice = creditableInvoice([['price' => 1000, 'quantity' => 1]]);
+    $other = creditableInvoice([['price' => 1000, 'quantity' => 1]]);
+
+    [$foreign] = creditableItemIds($other);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $foreign, 'quantity' => 1]],
+    ])
+        ->assertStatus(422)
+        ->assertJsonValidationErrors(['items.0.id']);
+
+    expect($invoice->creditNotes()->count())->toBe(0);
+});
+
+test('a credit note must credit something', function () {
+    $invoice = creditableInvoice([['price' => 1000, 'quantity' => 1]]);
+
+    [$line] = creditableItemIds($invoice);
+
+    // Quantities are carried in hundredths, so anything below half a hundredth
+    // credits nothing at all and must not mint an empty document.
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 0.001]],
+    ])
+        ->assertStatus(422)
+        ->assertJsonPath('errors.invoice.0', 'credit_note_must_credit_something');
+
+    // A zero or negative quantity does not even reach the service.
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 0]],
+    ])
+        ->assertStatus(422)
+        ->assertJsonValidationErrors(['items.0.quantity']);
+
+    expect($invoice->creditNotes()->count())->toBe(0);
+});
+
+test('a fully credited invoice cannot be credited again', function () {
+    $invoice = creditableInvoice([['price' => 1000, 'quantity' => 2]]);
+
+    [$line] = creditableItemIds($invoice);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note")->assertStatus(201);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(422)
+        ->assertJsonPath('errors.invoice.0', 'invoice_already_fully_credited');
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 1]],
+    ])
+        ->assertStatus(422)
+        ->assertJsonPath('errors.invoice.0', 'invoice_already_fully_credited');
+
+    expect($invoice->creditNotes()->count())->toBe(1);
+});
+
+test('stores the reason a credit note was issued and returns it', function () {
+    $invoice = creditableInvoice([['price' => 1000, 'quantity' => 1]]);
+
+    $response = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'reason' => 'Goods returned damaged',
+    ])->assertStatus(201);
+
+    $response->assertJsonPath('data.credit_reason', 'Goods returned damaged');
+
+    expect(Invoice::find($response->json('data.id'))->credit_reason)
+        ->toBe('Goods returned damaged');
+});
+
+test('the credit reason cannot be set through the invoice endpoints', function () {
+    $payload = Invoice::factory()->raw([
+        'credit_reason' => 'Written by a client',
+        'taxes' => [Tax::factory()->raw()],
+        'items' => [InvoiceItem::factory()->raw()],
+    ]);
+
+    $created = Invoice::find(postJson('api/v1/invoices', $payload)->assertOk()->json('data.id'));
+
+    // The reason belongs to the credit-note flow; the invoice form must not be
+    // able to write it.
+    expect($created->credit_reason)->toBeNull();
+
+    putJson("api/v1/invoices/{$created->id}", array_merge($payload, [
+        'invoice_number' => $payload['invoice_number'].'-B',
+        'credit_reason' => 'Written by a client',
+    ]))->assertOk();
+
+    expect($created->fresh()->credit_reason)->toBeNull();
+});
+
+test('a credited invoice can no longer be edited', function () {
+    $invoice = creditableInvoice([['price' => 1000, 'quantity' => 2]]);
+
+    getJson("api/v1/invoices/{$invoice->id}")
+        ->assertOk()
+        ->assertJsonPath('data.allow_edit', true);
+
+    [$line] = creditableItemIds($invoice);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 1]],
+    ])->assertStatus(201);
+
+    // The credit note's lines are anchored to this invoice's item ids, so the
+    // invoice is frozen from the first credit note on, partial or not.
+    getJson("api/v1/invoices/{$invoice->id}")
+        ->assertOk()
+        ->assertJsonPath('data.allow_edit', false);
+
+    $payload = Invoice::factory()->raw([
+        'taxes' => [Tax::factory()->raw()],
+        'items' => [InvoiceItem::factory()->raw()],
+    ]);
+
+    putJson("api/v1/invoices/{$invoice->id}", $payload)->assertStatus(403);
+});
+
+test('exposes how much of an invoice and of each line has been credited', function () {
+    $invoice = creditableInvoice([
+        ['price' => 1000, 'quantity' => 2],
+        ['price' => 500, 'quantity' => 4],
+    ]);
+
+    [$first] = creditableItemIds($invoice);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $first, 'quantity' => 1.5]],
+    ])->assertStatus(201);
+
+    getJson("api/v1/invoices/{$invoice->id}")
+        ->assertOk()
+        ->assertJsonPath('data.credited_total', 1500)
+        ->assertJsonPath('data.credited_status', 'PARTIAL')
+        ->assertJsonPath("data.credited_quantities.{$first}", 1.5);
+
+    // The list carries the totals for the badge, but not the per-line
+    // quantities: those need the credit notes' items and the list does not pay
+    // for them.
+    $row = collect(getJson("api/v1/invoices?invoice_id={$invoice->id}")->assertOk()->json('data'))
+        ->firstWhere('id', $invoice->id);
+
+    expect($row['credited_total'])->toBe(1500)
+        ->and($row['credited_status'])->toBe('PARTIAL')
+        ->and($row)->not->toHaveKey('credited_quantities');
+});
+
+test('reports an uncredited invoice as uncredited', function () {
+    $invoice = creditableInvoice([['price' => 1000, 'quantity' => 1]]);
+
+    getJson("api/v1/invoices/{$invoice->id}")
+        ->assertOk()
+        ->assertJsonPath('data.credited_total', 0)
+        ->assertJsonPath('data.credited_status', 'NONE')
+        ->assertJsonPath('data.credit_reason', null)
+        ->assertJsonPath('data.allow_edit', true);
+});
+
+test('pro-rates per item taxes and writes no document level tax', function () {
+    $invoice = creditableInvoice(
+        [['price' => 1000, 'quantity' => 2, 'taxes' => [['amount' => 140, 'percent' => 7]]]],
+        ['tax_per_item' => 'YES']
+    );
+
+    expect($invoice->total)->toBe(2140);
+
+    [$line] = creditableItemIds($invoice);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 1]],
+    ])->assertStatus(201)->json('data.id');
+
+    $creditNote = Invoice::with('items.taxes', 'taxes')->find($creditNoteId);
+
+    expect($creditNote->sub_total)->toBe(-1000)
+        ->and($creditNote->tax)->toBe(-70)
+        ->and($creditNote->total)->toBe(-1070);
+
+    $item = $creditNote->items->first();
+
+    expect($item->tax)->toBe(-70)
+        ->and($item->taxes)->toHaveCount(1)
+        ->and((int) $item->taxes->first()->amount)->toBe(-70)
+        ->and((int) $item->taxes->first()->base_amount)->toBe(-70)
+        // The descriptive fields travel with the amount so the credit note can
+        // be read on its own.
+        ->and((float) $item->taxes->first()->percent)->toBe(7.0)
+        ->and($item->taxes->first()->tax_type_id)->toBe($invoice->items->first()->taxes->first()->tax_type_id);
+
+    // Per-item tax means no document-level tax row exists to credit.
+    expect($creditNote->taxes)->toHaveCount(0);
+});
+
+test('follows the tax inclusive total when crediting part of an invoice', function () {
+    $invoice = creditableInvoice(
+        [['price' => 1000, 'quantity' => 2]],
+        ['tax_included' => true],
+        [['amount' => 140, 'percent' => 7]]
+    );
+
+    // Tax included: the total is the sub total, the tax is already inside it.
+    expect($invoice->total)->toBe(2000);
+
+    [$line] = creditableItemIds($invoice);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 1]],
+    ])->assertStatus(201)->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    expect($creditNote->sub_total)->toBe(-1000)
+        ->and($creditNote->tax)->toBe(-70)
+        // Not -1070: the credited tax is inside the credited total.
+        ->and($creditNote->total)->toBe(-1000);
+});
+
+test('pro-rates the base amounts of a foreign currency invoice and telescopes exactly', function () {
+    $invoice = creditableInvoice(
+        [['price' => 1000, 'quantity' => 3]],
+        ['exchange_rate' => 1.37],
+        [['amount' => 210, 'percent' => 7]]
+    );
+
+    expect($invoice->total)->toBe(3210)
+        ->and((int) $invoice->base_total)->toBe(4398)
+        ->and((int) $invoice->base_tax)->toBe(288);
+
+    [$line] = creditableItemIds($invoice);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 1]],
+    ])->assertStatus(201)->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    // Pro-rated from the STORED base amounts, not recomputed through the rate:
+    // 4398 / 3 is 1466, while round(1070 * 1.37) would be 1466 by luck and
+    // round(70 * 1.37) would be 96 here but not everywhere.
+    expect($creditNote->total)->toBe(-1070)
+        ->and((int) $creditNote->base_sub_total)->toBe(-1370)
+        ->and((int) $creditNote->base_tax)->toBe(-96)
+        ->and((int) $creditNote->base_total)->toBe(-1466);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 2]],
+    ])->assertStatus(201);
+
+    // Two chunks, and the books balance to the cent in the company currency
+    // just as they do in the document currency.
+    expect((int) $invoice->creditNotes()->sum('total'))->toBe(-3210)
+        ->and((int) $invoice->creditNotes()->sum('base_total'))->toBe(-4398)
+        ->and((int) $invoice->creditNotes()->sum('base_tax'))->toBe(-288)
+        ->and((int) $invoice->creditNotes()->sum('base_sub_total'))->toBe(-4110);
+
+    expect((int) $invoice->fresh()->due_amount)->toBe(0);
+});
+
+test('sets the related invoice relationship on the credit note', function () {
+    $invoice = creditableInvoice();
+
+    $response = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201);
+
+    $creditNote = Invoice::find($response->json('data.id'));
+
+    expect($creditNote->relatedInvoice->id)->toBe($invoice->id);
+    expect($invoice->fresh()->creditNotes->pluck('id'))->toContain($creditNote->id);
+
+    // The resource exposes the original invoice reference.
+    $response->assertJsonPath('data.related_invoice.id', $invoice->id);
+    $response->assertJsonPath('data.related_invoice.invoice_number', $invoice->invoice_number);
+    $response->assertJsonPath('data.type', Invoice::TYPE_CREDIT_NOTE);
+});
+
+test('cannot create a credit note from another credit note', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    // Reversing a credit note is a domain rule violation, not an auth failure.
+    postJson("api/v1/invoices/{$creditNoteId}/credit-note")
+        ->assertStatus(422);
+});
+
+test('cannot create a credit note for an invoice of another company', function () {
+    $invoice = Invoice::factory()
+        ->hasItems(1)
+        ->create(['company_id' => Company::factory()->create()->id]);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(403);
+});
+
+test('generates a pdf for a credit note', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    $pdf = $creditNote->getPDFData();
+    $output = $pdf->output();
+
+    // A real PDF document was produced by the credit-note template.
+    expect(substr($output, 0, 4))->toBe('%PDF');
+});
+
+test('settles the original invoice when a credit note is created', function () {
+    $invoice = creditableInvoice();
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note")->assertStatus(201);
+
+    $invoice->refresh();
+
+    // A full reversal nets the original invoice's balance to exactly zero, so
+    // it drops out of every "awaiting payment" view (issue #317 community ask;
+    // same behavior sevDesk applies and @gdarko praised in PR #536).
+    expect((int) $invoice->due_amount)->toBe(0);
+    expect((int) $invoice->base_due_amount)->toBe(0);
+    expect($invoice->paid_status)->toBe(Invoice::STATUS_PAID);
+    expect($invoice->status)->toBe(Invoice::STATUS_COMPLETED);
+});
+
+test('the credit note itself is created settled but still a draft', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    // The credit note pairs with the original invoice and nothing is owed on
+    // it, so it must never appear as an open (negative) balance anywhere.
+    expect((int) $creditNote->due_amount)->toBe(0);
+    expect((int) $creditNote->base_due_amount)->toBe(0);
+    expect($creditNote->paid_status)->toBe(Invoice::STATUS_PAID);
+    // A reversal is never owed, so it carries no due date at all.
+    expect($creditNote->due_date)->toBeNull();
+    // Settled is not the same as finished: the credit note still has to be
+    // reviewed and emailed, so it is born DRAFT and gets the ordinary Send
+    // affordances. send() promotes it to SENT.
+    expect($creditNote->status)->toBe(Invoice::STATUS_DRAFT);
+    // Totals stay fully negated, though.
+    expect($creditNote->total)->toBe(-10000);
+});
+
+test('the original invoice exposes its credit notes for the UI banner', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNoteNumber = Invoice::find($creditNoteId)->invoice_number;
+
+    // Mirror of the credit note's related_invoice back-link: the original
+    // invoice must reference the storno document ("Storniert via ST-XXXX").
+    getJson("api/v1/invoices/{$invoice->id}")
+        ->assertOk()
+        ->assertJsonPath('data.credit_notes.0.id', $creditNoteId)
+        ->assertJsonPath('data.credit_notes.0.invoice_number', $creditNoteNumber);
+});
+
+test('deleting a credit note restores the original invoice balance', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    expect((int) $invoice->fresh()->due_amount)->toBe(0);
+
+    postJson('api/v1/invoices/delete', ['ids' => [$creditNoteId]])
+        ->assertOk()
+        ->assertJson(['success' => true]);
+
+    $invoice->refresh();
+
+    // Mirror of the create-side adjustment (PR #536's delete reversal).
+    expect((int) $invoice->due_amount)->toBe(10000);
+    expect((int) $invoice->base_due_amount)->toBe(10000);
+    expect($invoice->paid_status)->toBe(Invoice::STATUS_UNPAID);
+    expect($invoice->status)->toBe(Invoice::STATUS_SENT);
+});
+
+test('deleting a credit note restores a partially paid balance from payments', function () {
+    $invoice = creditableInvoice([['price' => 100, 'quantity' => 100]]);
+
+    creditablePayment($invoice, 4000);
+
+    [$line] = creditableItemIds($invoice);
+
+    // Crediting the whole unpaid balance settles the invoice.
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 60]],
+    ])->assertStatus(201)->json('data.id');
+
+    expect((int) $invoice->fresh()->due_amount)->toBe(0);
+
+    postJson('api/v1/invoices/delete', ['ids' => [$creditNoteId]])
+        ->assertOk();
+
+    $invoice->refresh();
+
+    // due = total - recorded payments - surviving credit notes, never a stale
+    // pre-storno snapshot.
+    expect((int) $invoice->due_amount)->toBe(6000);
+    expect($invoice->paid_status)->toBe(Invoice::STATUS_PARTIALLY_PAID);
+});
+
+test('deleting one of two credit notes gives back only that credit', function () {
+    $invoice = creditableInvoice([['price' => 100, 'quantity' => 100]]);
+
+    creditablePayment($invoice, 1000);
+
+    [$line] = creditableItemIds($invoice);
+
+    $first = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 20]],
+    ])->assertStatus(201)->json('data.id');
+
+    $second = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 30]],
+    ])->assertStatus(201)->json('data.id');
+
+    expect((int) $invoice->fresh()->due_amount)->toBe(4000);
+
+    postJson('api/v1/invoices/delete', ['ids' => [$first]])->assertOk();
+
+    // 10000 - 1000 paid - 3000 still credited.
+    expect((int) $invoice->fresh()->due_amount)->toBe(6000);
+
+    postJson('api/v1/invoices/delete', ['ids' => [$second]])->assertOk();
+
+    expect((int) $invoice->fresh()->due_amount)->toBe(9000);
+    expect($invoice->fresh()->paid_status)->toBe(Invoice::STATUS_PARTIALLY_PAID);
+});
+
+test('deleting two credit notes of one invoice in a single request settles it once', function () {
+    $invoice = creditableInvoice([['price' => 100, 'quantity' => 100]]);
+
+    [$line] = creditableItemIds($invoice);
+
+    $first = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 20]],
+    ])->assertStatus(201)->json('data.id');
+
+    $second = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $line, 'quantity' => 30]],
+    ])->assertStatus(201)->json('data.id');
+
+    postJson('api/v1/invoices/delete', ['ids' => [$first, $second]])->assertOk();
+
+    $invoice->refresh();
+
+    expect((int) $invoice->due_amount)->toBe(10000)
+        ->and($invoice->paid_status)->toBe(Invoice::STATUS_UNPAID)
+        ->and($invoice->status)->toBe(Invoice::STATUS_SENT);
+});
+
+test('deleting the original invoice and its credit note together succeeds', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    postJson('api/v1/invoices/delete', ['ids' => [$invoice->id, $creditNoteId]])
+        ->assertOk()
+        ->assertJson(['success' => true]);
+
+    $this->assertDatabaseMissing('invoices', ['id' => $invoice->id]);
+    $this->assertDatabaseMissing('invoices', ['id' => $creditNoteId]);
+});
+
+test('cannot delete an invoice while a credit note still reverses it', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    // Deleting only the original would leave the credit note pointing at a row
+    // that no longer exists.
+    postJson('api/v1/invoices/delete', ['ids' => [$invoice->id]])
+        ->assertStatus(422);
+
+    $this->assertDatabaseHas('invoices', ['id' => $invoice->id]);
+    $this->assertDatabaseHas('invoices', ['id' => $creditNoteId]);
+});
+
+test('no surviving row keeps a dangling related invoice reference', function () {
+    $invoice = creditableInvoice();
+
+    $creditNote = app(CreditNoteService::class)->create($invoice, [], null);
+
+    // There is no DB foreign key, so the cascade is the service's job. Deleting
+    // the original directly (the request layer blocks this) must still not
+    // leave the credit note pointing at a missing invoice.
+    app(InvoiceService::class)->delete(collect([$invoice->id]));
+
+    expect(Invoice::find($creditNote->id)->related_invoice_id)->toBeNull();
+});
+
+test('completing an uncredited invoice still zeroes its balance', function () {
+    $invoice = creditableInvoice();
+
+    postJson("api/v1/invoices/{$invoice->id}/status", ['status' => Invoice::STATUS_COMPLETED])
+        ->assertOk();
+
+    $invoice->refresh();
+
+    // The credit-note bookkeeping must not touch the manual status change.
+    expect((int) $invoice->due_amount)->toBe(0)
+        ->and($invoice->status)->toBe(Invoice::STATUS_COMPLETED)
+        ->and($invoice->paid_status)->toBe(Invoice::STATUS_PAID);
+});
+
+test('renders a credit note pdf through the original invoice template family, not a hardcoded layout', function () {
+    // Regression for: credit notes always rendered through one hardcoded
+    // generic layout regardless of which of the 3 invoice templates the
+    // company actually uses. invoice2 has a distinctive purple header
+    // markup ("header-section-right") that the old standalone
+    // credit-note.blade.php never contained.
+    $invoice = creditableInvoice([['price' => 10000, 'quantity' => 1]], ['template_name' => 'invoice2']);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    $response = get("/invoices/pdf/{$creditNote->unique_hash}?preview=1");
+
+    $response->assertOk();
+    $response->assertSee('header-section-right', false);
+    $response->assertSee('Credit Note');
+    $response->assertSee($invoice->invoice_number);
+});
+
+test('renders a credit note pdf under the invoice3 template family', function () {
+    $invoice = creditableInvoice([['price' => 10000, 'quantity' => 1]], ['template_name' => 'invoice3']);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    $response = get("/invoices/pdf/{$creditNote->unique_hash}?preview=1");
+
+    $response->assertOk();
+    // "main-content" is a structural marker unique to invoice3.blade.php.
+    $response->assertSee('main-content', false);
+    $response->assertSee('Credit Note');
+});
+
+test('shows a cancellation banner on the original invoice pdf under a non-default template', function () {
+    // Regression for: the actual generated/printed/emailed PDF of a
+    // cancelled invoice showed zero indication it had been reversed by a
+    // credit note (only the Vue UI banner existed).
+    $invoice = creditableInvoice([['price' => 10000, 'quantity' => 1]], ['template_name' => 'invoice3']);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    $response = get("/invoices/pdf/{$invoice->unique_hash}?preview=1");
+
+    $response->assertOk();
+    $response->assertSee('Cancelled');
+    $response->assertSee($creditNote->invoice_number);
+});
+
+test('shows a cancellation banner on the original invoice pdf under the default template', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    $response = get("/invoices/pdf/{$invoice->unique_hash}?preview=1");
+
+    $response->assertOk();
+    $response->assertSee('Cancelled');
+    $response->assertSee($creditNote->invoice_number);
+});
+
+test('prints the credit reason on the credit note pdf and escapes it', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'reason' => 'Goods returned <b>damaged</b>',
+    ])->assertStatus(201)->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    $response = get("/invoices/pdf/{$creditNote->unique_hash}?preview=1");
+
+    $response->assertOk();
+    // assertSee escapes by default, so this is the escaped rendering.
+    $response->assertSee('Reason: Goods returned <b>damaged</b>');
+    // The operator's text is data, never markup: the raw tags must not reach
+    // the document, where Chromium would happily render them as bold.
+    $response->assertDontSee('Goods returned <b>damaged</b>', false);
+});
+
+test('omits the reason line from a credit note pdf that has no reason', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    get("/invoices/pdf/{$creditNote->unique_hash}?preview=1")
+        ->assertOk()
+        ->assertDontSee('Reason:');
+});
+
+test('shows a partially credited banner naming the amount and the credit note', function () {
+    $invoice = creditableInvoice([
+        ['price' => 1000, 'quantity' => 1],
+        ['price' => 1000, 'quantity' => 1],
+    ]);
+
+    [$first] = creditableItemIds($invoice);
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $first, 'quantity' => 1]],
+    ])->assertStatus(201)->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    $response = get("/invoices/pdf/{$invoice->unique_hash}?preview=1");
+
+    $response->assertOk();
+    $response->assertSee('Partially Credited');
+    $response->assertSee($creditNote->invoice_number);
+    $response->assertSee(format_money_pdf(1000, $invoice->customer->currency), false);
+    // Half an invoice is not a cancelled invoice.
+    $response->assertDontSee('Cancelled via credit note');
+});
+
+test('lists every credit note on the cancelled banner once the invoice is fully credited', function () {
+    $invoice = creditableInvoice([
+        ['price' => 1000, 'quantity' => 1],
+        ['price' => 1000, 'quantity' => 1],
+    ]);
+
+    [$first, $second] = creditableItemIds($invoice);
+
+    $firstNote = Invoice::find(
+        postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+            'items' => [['id' => $first, 'quantity' => 1]],
+        ])->assertStatus(201)->json('data.id')
+    );
+
+    $secondNote = Invoice::find(
+        postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+            'items' => [['id' => $second, 'quantity' => 1]],
+        ])->assertStatus(201)->json('data.id')
+    );
+
+    $response = get("/invoices/pdf/{$invoice->unique_hash}?preview=1");
+
+    $response->assertOk();
+    $response->assertSee('Cancelled');
+    // Naming only the first credit note would leave the reader unable to tie
+    // the reversal to the documents that produced it.
+    $response->assertSee($firstNote->invoice_number);
+    $response->assertSee($secondNote->invoice_number);
+    $response->assertDontSee('Partially Credited');
+});
+
+test('a partially credited invoice pdf reports a credit, not a payment', function () {
+    // The hazard this pins: crediting an invoice moves its balance, so a totals
+    // block driven by paid_status alone announces "Amount Paid" for money that
+    // was never received.
+    $invoice = creditableInvoice([
+        ['price' => 1000, 'quantity' => 1],
+        ['price' => 1000, 'quantity' => 1],
+    ]);
+
+    [$first] = creditableItemIds($invoice);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $first, 'quantity' => 1]],
+    ])->assertStatus(201);
+
+    $response = get("/invoices/pdf/{$invoice->unique_hash}?preview=1");
+
+    $response->assertOk();
+    $response->assertSee('Amount Credited');
+    $response->assertSee('Amount Due');
+    $response->assertDontSee('Amount Paid');
+});
+
+test('an invoice both paid and credited pdf reports the two separately', function () {
+    $invoice = creditableInvoice([
+        ['price' => 1000, 'quantity' => 1],
+        ['price' => 1000, 'quantity' => 1],
+    ]);
+
+    creditablePayment($invoice, 500);
+
+    [$first] = creditableItemIds($invoice);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $first, 'quantity' => 1]],
+    ])->assertStatus(201);
+
+    $invoice->refresh();
+
+    $response = get("/invoices/pdf/{$invoice->unique_hash}?preview=1");
+
+    $response->assertOk();
+    $response->assertSee('Amount Credited');
+    $response->assertSee('Amount Paid');
+    $response->assertSee(format_money_pdf(1000, $invoice->customer->currency), false);
+    $response->assertSee(format_money_pdf(500, $invoice->customer->currency), false);
+});
+
+test('an ordinary partially paid invoice pdf still shows the amount paid', function () {
+    $invoice = creditableInvoice([['price' => 10000, 'quantity' => 1]]);
+
+    creditablePayment($invoice, 4000);
+
+    $invoice->refresh();
+
+    $response = get("/invoices/pdf/{$invoice->unique_hash}?preview=1");
+
+    $response->assertOk();
+    $response->assertSee('Amount Paid');
+    $response->assertSee('Amount Due');
+    $response->assertDontSee('Amount Credited');
+    $response->assertSee(format_money_pdf(4000, $invoice->customer->currency), false);
+    $response->assertSee(format_money_pdf(6000, $invoice->customer->currency), false);
+});
+
+test('an unpaid invoice pdf shows neither a paid nor a credited row', function () {
+    $invoice = creditableInvoice([['price' => 10000, 'quantity' => 1]]);
+
+    $response = get("/invoices/pdf/{$invoice->unique_hash}?preview=1");
+
+    $response->assertOk();
+    $response->assertDontSee('Amount Paid');
+    $response->assertDontSee('Amount Credited');
+    $response->assertDontSee('Amount Due');
+});
+
+test('a credit note pdf shows no amount paid row', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $creditNote = Invoice::find($creditNoteId);
+
+    $response = get("/invoices/pdf/{$creditNote->unique_hash}?preview=1");
+
+    $response->assertOk();
+    // A credit note settles nothing: its own totals block is the negated
+    // document, and a paid line there would be read as a refund.
+    $response->assertDontSee('Amount Paid');
+    $response->assertDontSee('Amount Credited');
+});
+
+test('every credit note phrase is translated in all five maintained locales', function () {
+    $locales = ['en', 'de', 'fr', 'it', 'mk'];
+
+    $catalogues = [];
+
+    foreach ($locales as $locale) {
+        $catalogues[$locale] = json_decode(file_get_contents(base_path("lang/{$locale}.json")), true);
+    }
+
+    $english = $catalogues['en'];
+
+    $expected = [];
+
+    foreach (array_keys($english['invoices']) as $key) {
+        if (str_contains($key, 'credit')) {
+            $expected[] = ['invoices', $key];
+        }
+    }
+
+    foreach (array_keys($english['errors']) as $key) {
+        if (str_starts_with($key, 'credit_') || $key === 'invoice_already_fully_credited') {
+            $expected[] = ['errors', $key];
+        }
+    }
+
+    foreach (array_keys($english) as $key) {
+        if (str_starts_with($key, 'pdf_') && (str_contains($key, 'credit') || str_contains($key, 'cancelled'))) {
+            $expected[] = [null, $key];
+        }
+    }
+
+    expect($expected)->not->toBeEmpty();
+
+    $missing = [];
+
+    foreach ($expected as [$section, $key]) {
+        foreach ($locales as $locale) {
+            $bag = $section === null ? $catalogues[$locale] : ($catalogues[$locale][$section] ?? []);
+
+            if (! array_key_exists($key, $bag)) {
+                $missing[] = $locale.': '.($section === null ? $key : $section.'.'.$key);
+            }
+        }
+    }
+
+    expect($missing)->toBe([]);
+
+    // Guards that partial crediting removed: one credit note per invoice, and
+    // no crediting an invoice with payments. A stale string in any catalogue
+    // would still be shown by a translated install.
+    $retired = [
+        ['invoices', 'confirm_create_credit_note'],
+        ['errors', 'invoice_already_has_credit_note'],
+        ['errors', 'invoice_with_payments_cannot_be_credited'],
+    ];
+
+    $leftovers = [];
+
+    foreach ($retired as [$section, $key]) {
+        foreach ($locales as $locale) {
+            if (array_key_exists($key, $catalogues[$locale][$section] ?? [])) {
+                $leftovers[] = $locale.': '.$section.'.'.$key;
+            }
+        }
+    }
+
+    expect($leftovers)->toBe([]);
+});
+
+test('sends a credit note to the customer through the normal send endpoint', function () {
+    Mail::fake();
+
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $data = [
+        'from' => 'john@example.com',
+        'to' => 'doe@example.com',
+        'subject' => 'Your credit note',
+        'body' => 'Please find your credit note attached.',
+    ];
+
+    // There is no separate credit-note send endpoint: a credit note goes out
+    // through the invoice send channel, which picks the mailable by type.
+    postJson("api/v1/invoices/{$creditNoteId}/send", $data)
+        ->assertOk()
+        ->assertJson(['success' => true]);
+
+    Mail::assertSent(SendCreditNoteMail::class);
+    Mail::assertNotSent(SendInvoiceMail::class);
+
+    // Sending promotes the draft credit note the same way it promotes an
+    // invoice.
+    $creditNote = Invoice::find($creditNoteId);
+    expect($creditNote->status)->toBe(Invoice::STATUS_SENT);
+    expect((bool) $creditNote->sent)->toBeTrue();
+});
+
+test('sending a regular invoice still uses the invoice mailable', function () {
+    Mail::fake();
+
+    $invoice = Invoice::factory()->hasItems(1)->create();
+
+    postJson("api/v1/invoices/{$invoice->id}/send", [
+        'from' => 'john@example.com',
+        'to' => 'doe@example.com',
+        'subject' => 'Your invoice',
+        'body' => 'Please find your invoice attached.',
+    ])->assertOk();
+
+    Mail::assertSent(SendInvoiceMail::class);
+    Mail::assertNotSent(SendCreditNoteMail::class);
+});
+
+test('previews the credit note email template, not the invoice one', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    // The two templates render near-identical markup, so the assertion hooks
+    // the view that actually gets composed rather than its output.
+    $rendered = [];
+    View::composer(['emails.send.credit-note', 'emails.send.invoice'], function ($view) use (&$rendered) {
+        $rendered[] = $view->name();
+    });
+
+    getJson("api/v1/invoices/{$creditNoteId}/send/preview?".http_build_query([
+        'subject' => 'Your credit note',
+        'body' => 'Please find your credit note attached.',
+        'from' => 'john@example.com',
+        'to' => 'doe@example.com',
+    ]))->assertOk();
+
+    expect($rendered)->toContain('emails.send.credit-note');
+    expect($rendered)->not->toContain('emails.send.invoice');
+});
+
+test('a credit note cannot be edited', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    $payload = Invoice::factory()->raw([
+        'taxes' => [Tax::factory()->raw()],
+        'items' => [InvoiceItem::factory()->raw()],
+    ]);
+
+    // A reversal document is immutable: editing it would recompute its totals
+    // positive through the ordinary invoice payload.
+    putJson("api/v1/invoices/{$creditNoteId}", $payload)->assertStatus(403);
+});
+
+test('a client cannot mint a credit note through the invoice create endpoint', function () {
+    $payload = Invoice::factory()->raw([
+        'type' => Invoice::TYPE_CREDIT_NOTE,
+        'related_invoice_id' => 1,
+        'taxes' => [Tax::factory()->raw()],
+        'items' => [InvoiceItem::factory()->raw()],
+    ]);
+
+    $response = postJson('api/v1/invoices', $payload)->assertOk();
+
+    // Credit notes are minted only by CreditNoteService::create(); the request
+    // payload must not be able to declare one.
+    $created = Invoice::find($response->json('data.id'));
+
+    expect($created->type)->toBe(Invoice::TYPE_INVOICE);
+    expect($created->related_invoice_id)->toBeNull();
+});
+
+test('cannot credit a draft invoice', function () {
+    $invoice = creditableInvoice([['price' => 10000, 'quantity' => 1]], [
+        'status' => Invoice::STATUS_DRAFT,
+        'sent' => false,
+    ]);
+
+    // A draft was never issued, so there is nothing to reverse.
+    postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(422);
+
+    expect($invoice->creditNotes()->count())->toBe(0);
+});
+
+test('a credit note cannot be cloned or converted to an estimate', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    // Both copy the amounts unnegated, so either would mint a positive
+    // document out of a reversal.
+    postJson("api/v1/invoices/{$creditNoteId}/clone")->assertStatus(422);
+    postJson("api/v1/invoices/{$creditNoteId}/convert-to-estimate")->assertStatus(422);
+});
+
+test('a credit note is never marked overdue by the status command', function () {
+    $invoice = creditableInvoice();
+
+    $creditNoteId = postJson("api/v1/invoices/{$invoice->id}/credit-note")
+        ->assertStatus(201)
+        ->json('data.id');
+
+    // Force the credit note into the shape the command looks for: sent, not
+    // completed, with a due date in the past.
+    Invoice::where('id', $creditNoteId)->update([
+        'status' => Invoice::STATUS_SENT,
+        'due_date' => now()->subMonth()->format('Y-m-d'),
+    ]);
+
+    Artisan::call('check:invoices:status');
+
+    expect((bool) Invoice::find($creditNoteId)->overdue)->toBeFalse();
+});
+
+test('a real invoice is still marked overdue by the status command', function () {
+    $invoice = Invoice::factory()->hasItems(1)->create([
+        'status' => Invoice::STATUS_SENT,
+        'due_date' => now()->subMonth()->format('Y-m-d'),
+        'overdue' => false,
+    ]);
+
+    Artisan::call('check:invoices:status');
+
+    expect((bool) $invoice->fresh()->overdue)->toBeTrue();
+});
+
+describe('credit note numbering', function () {
+    test('numbers credit notes in their own sequence, independent of invoices', function () {
+        $first = creditableInvoice();
+        $second = creditableInvoice();
+
+        expect($first->invoice_number)->toBe('INV-000001');
+        expect($first->sequence_number)->toBe(1);
+        expect($second->invoice_number)->toBe('INV-000002');
+        expect($second->sequence_number)->toBe(2);
+
+        $firstCreditNote = Invoice::find(
+            postJson("api/v1/invoices/{$first->id}/credit-note")
+                ->assertStatus(201)
+                ->json('data.id')
+        );
+
+        $secondCreditNote = Invoice::find(
+            postJson("api/v1/invoices/{$second->id}/credit-note")
+                ->assertStatus(201)
+                ->json('data.id')
+        );
+
+        // Credit notes live in the invoices table but count from 1 on their own
+        // format, so the two document series never interleave.
+        expect($firstCreditNote->invoice_number)->toBe('CN-000001');
+        expect($firstCreditNote->sequence_number)->toBe(1);
+        expect($secondCreditNote->invoice_number)->toBe('CN-000002');
+        expect($secondCreditNote->sequence_number)->toBe(2);
+
+        // And the invoice sequence is untouched by the two credit notes: the
+        // next invoice is 3, not 5.
+        $third = creditableInvoice();
+
+        expect($third->invoice_number)->toBe('INV-000003');
+        expect($third->sequence_number)->toBe(3);
+    });
+
+    test('generates the credit note number from the credit_note_number_format setting', function () {
+        $companyId = User::find(1)->companies()->first()->id;
+
+        CompanySetting::setSettings([
+            'credit_note_number_format' => '{{SERIES:STORNO}}{{DELIMITER:/}}{{SEQUENCE:4}}',
+        ], $companyId);
+
+        $invoice = creditableInvoice();
+
+        $creditNote = Invoice::find(
+            postJson("api/v1/invoices/{$invoice->id}/credit-note")
+                ->assertStatus(201)
+                ->json('data.id')
+        );
+
+        expect($creditNote->invoice_number)->toBe('STORNO/0001');
+    });
+
+    test('returns the next credit note number from the next-number endpoint', function () {
+        getJson('api/v1/next-number?key=credit_note')
+            ->assertStatus(200)
+            ->assertJson([
+                'success' => true,
+                'nextNumber' => 'CN-000001',
+            ]);
+
+        $invoice = creditableInvoice();
+
+        postJson("api/v1/invoices/{$invoice->id}/credit-note")->assertStatus(201);
+
+        // The preview advances with the credit note sequence, not the invoice one.
+        getJson('api/v1/next-number?key=credit_note')
+            ->assertStatus(200)
+            ->assertJson([
+                'nextNumber' => 'CN-000002',
+            ]);
+    });
+});
diff --git a/tests/Feature/Admin/DashboardTest.php b/tests/Feature/Admin/DashboardTest.php
index 6f0d70de..9107ce2b 100644
--- a/tests/Feature/Admin/DashboardTest.php
+++ b/tests/Feature/Admin/DashboardTest.php
@@ -1,10 +1,12 @@
 <?php
 
+use App\Models\Invoice;
 use App\Models\User;
 use Illuminate\Support\Facades\Artisan;
 use Laravel\Sanctum\Sanctum;
 
 use function Pest\Laravel\getJson;
+use function Pest\Laravel\postJson;
 
 beforeEach(function () {
     Artisan::call('db:seed', ['--class' => 'DatabaseSeeder', '--force' => true]);
@@ -23,3 +25,98 @@ beforeEach(function () {
 getJson('api/v1/dashboard')->assertOk();
 
 getJson('api/v1/search?name=ab')->assertOk();
+
+test('the invoice count excludes credit notes while the sales total nets them out', function () {
+    $before = getJson('api/v1/dashboard')->assertOk();
+
+    $baselineCount = $before->json('total_invoice_count');
+    $baselineSales = (int) $before->json('total_sales');
+
+    // The line item carries the whole invoice: a credit note is derived from
+    // the invoice's own figures, so its total only nets the sale out when the
+    // items agree with the document totals, as they do on a real invoice.
+    $invoice = Invoice::factory()
+        ->hasItems(1, [
+            'price' => 10000,
+            'quantity' => 1,
+            'total' => 10000,
+            'tax' => 0,
+            'discount_val' => 0,
+            'exchange_rate' => 1,
+            'base_price' => 10000,
+            'base_total' => 10000,
+            'base_tax' => 0,
+            'base_discount_val' => 0,
+        ])
+        ->create([
+            'status' => Invoice::STATUS_SENT,
+            'invoice_date' => now()->format('Y-m-d'),
+            'sub_total' => 10000,
+            'total' => 10000,
+            'base_total' => 10000,
+            'tax' => 0,
+            'discount_val' => 0,
+            'due_amount' => 10000,
+            'base_due_amount' => 10000,
+            'exchange_rate' => 1,
+        ]);
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note")->assertStatus(201);
+
+    $after = getJson('api/v1/dashboard')->assertOk();
+
+    // One invoice was issued, and one reversal of it exists. "Invoices" counts
+    // the issued document only.
+    expect($after->json('total_invoice_count'))->toBe($baselineCount + 1);
+
+    // The sums deliberately keep credit notes: the negated total is exactly
+    // what takes the reversed sale back out of the figure.
+    expect((int) $after->json('total_sales'))->toBe($baselineSales);
+});
+
+test('the dashboard renders while a partially credited invoice is among the recent due', function () {
+    // Regression: the recent-due list serializes raw Invoice models, so every
+    // loaded relation runs the full $appends set. A column-limited creditNotes
+    // eager load left the credit-note children without company_id and the date
+    // accessors exploded on a null format, taking the whole endpoint down with
+    // a 500. A partially credited invoice is the trigger: it still has a due
+    // amount, so it is the one credited document the recent-due list shows.
+    $invoice = Invoice::factory()
+        ->hasItems(1, [
+            'price' => 5000,
+            'quantity' => 2,
+            'total' => 10000,
+            'tax' => 0,
+            'discount_val' => 0,
+            'exchange_rate' => 1,
+            'base_price' => 5000,
+            'base_total' => 10000,
+            'base_tax' => 0,
+            'base_discount_val' => 0,
+        ])
+        ->create([
+            'status' => Invoice::STATUS_SENT,
+            'invoice_date' => now()->format('Y-m-d'),
+            'sub_total' => 10000,
+            'total' => 10000,
+            'base_total' => 10000,
+            'tax' => 0,
+            'discount_val' => 0,
+            'due_amount' => 10000,
+            'base_due_amount' => 10000,
+            'exchange_rate' => 1,
+        ]);
+
+    $item = $invoice->items()->first();
+
+    postJson("api/v1/invoices/{$invoice->id}/credit-note", [
+        'items' => [['id' => $item->id, 'quantity' => 1]],
+    ])->assertStatus(201);
+
+    expect((int) $invoice->fresh()->due_amount)->toBe(5000);
+
+    $response = getJson('api/v1/dashboard')->assertOk();
+
+    expect(collect($response->json('recent_due_invoices'))->pluck('id'))
+        ->toContain($invoice->id);
+});
diff --git a/tests/Feature/Admin/PaymentTest.php b/tests/Feature/Admin/PaymentTest.php
index 7277b323..6a5c3b14 100644
--- a/tests/Feature/Admin/PaymentTest.php
+++ b/tests/Feature/Admin/PaymentTest.php
@@ -6,6 +6,7 @@ use App\Mail\SendPaymentMail;
 use App\Models\Invoice;
 use App\Models\Payment;
 use App\Models\User;
+use App\Services\Document\CreditNoteService;
 use Illuminate\Support\Facades\Artisan;
 use Laravel\Sanctum\Sanctum;
 
@@ -27,6 +28,77 @@ beforeEach(function () {
     );
 });
 
+/**
+ * An unpaid invoice whose stored totals agree with its line items.
+ *
+ * The credit-note calculator derives everything from the original invoice's
+ * stored figures, so a fixture whose total has nothing to do with its items
+ * describes an invoice that could not exist. The amounts are pinned rather than
+ * drawn from the factory because the payment cap is now compared against them.
+ */
+function payableInvoice(int $lines = 2, int $price = 10000): Invoice
+{
+    $total = $lines * $price;
+
+    $invoice = Invoice::factory()->create([
+        'status' => Invoice::STATUS_SENT,
+        'sent' => true,
+        'paid_status' => Invoice::STATUS_UNPAID,
+        'tax_per_item' => 'NO',
+        'discount_per_item' => 'NO',
+        'tax_included' => false,
+        'discount' => 0,
+        'discount_type' => 'fixed',
+        'discount_val' => 0,
+        'tax' => 0,
+        'sub_total' => $total,
+        'total' => $total,
+        'due_amount' => $total,
+        'exchange_rate' => 1,
+        'base_sub_total' => $total,
+        'base_discount_val' => 0,
+        'base_tax' => 0,
+        'base_total' => $total,
+        'base_due_amount' => $total,
+    ]);
+
+    for ($index = 0; $index < $lines; $index++) {
+        $invoice->items()->create([
+            'name' => 'Line '.($index + 1),
+            'quantity' => 1,
+            'price' => $price,
+            'discount_type' => 'fixed',
+            'discount' => 0,
+            'discount_val' => 0,
+            'tax' => 0,
+            'total' => $price,
+            'company_id' => $invoice->company_id,
+            'exchange_rate' => 1,
+            'base_price' => $price,
+            'base_discount_val' => 0,
+            'base_tax' => 0,
+            'base_total' => $price,
+        ]);
+    }
+
+    return $invoice->fresh();
+}
+
+/**
+ * A payment payload aimed at an invoice, with everything the cap depends on
+ * pinned so the request is decided by the amount alone.
+ */
+function paymentPayloadFor(Invoice $invoice, int $amount): array
+{
+    return Payment::factory()->raw([
+        'invoice_id' => $invoice->id,
+        'customer_id' => $invoice->customer_id,
+        'currency_id' => $invoice->currency_id,
+        'exchange_rate' => 1,
+        'amount' => $amount,
+    ]);
+}
+
 test('get payments', function () {
     $response = getJson('api/v1/payments?page=1');
 
@@ -75,17 +147,33 @@ test('store validates using a form request', function () {
 });
 
 test('update payment', function () {
-    $invoice = Invoice::factory()->create();
+    // Every amount here is pinned. The factories draw random single-digit
+    // amounts, and a payment is now capped at the invoice's due amount plus the
+    // edited payment's own amount, so a random invoice total paired with two
+    // random payment amounts overpays the invoice at random.
+    $invoice = Invoice::factory()->create([
+        'sub_total' => 10000,
+        'total' => 10000,
+        'due_amount' => 4000,
+        'exchange_rate' => 1,
+        'base_sub_total' => 10000,
+        'base_total' => 10000,
+        'base_due_amount' => 4000,
+    ]);
 
     $payment = Payment::factory()->create([
         'payment_date' => '1988-08-18',
         'invoice_id' => $invoice->id,
         'exchange_rate' => 1,
+        'amount' => 6000,
     ]);
 
+    // The edited payment's own amount returns to the pool, so the whole invoice
+    // total is payable again.
     $payment2 = Payment::factory()->raw([
         'invoice_id' => $invoice->id,
         'exchange_rate' => 1,
+        'amount' => 10000,
     ]);
 
     putJson("api/v1/payments/{$payment->id}", $payment2)
@@ -239,3 +327,78 @@ test('create payment with partially paid', function () {
         'paid_status' => $response['data']['invoice']['paid_status'],
     ]);
 });
+
+test('rejects a payment worth more than the invoice due amount', function () {
+    // Regression: an overpayment used to be accepted and then silently lost.
+    // PaymentService hands the amount to Invoice::subtractInvoicePayment(),
+    // which drives the balance negative, and getInvoiceStatusByAmount() returns
+    // nothing for a negative amount, so the invoice was left with a stale
+    // balance and a status that never reflected the money taken.
+    $invoice = payableInvoice();
+
+    postJson('api/v1/payments', paymentPayloadFor($invoice, 20001))
+        ->assertStatus(422)
+        ->assertJsonPath('errors.amount.0', 'payment_amount_exceeds_invoice_due_amount');
+
+    $invoice->refresh();
+
+    expect((int) $invoice->due_amount)->toBe(20000)
+        ->and($invoice->paid_status)->toBe(Invoice::STATUS_UNPAID);
+});
+
+test('accepts a payment worth exactly the invoice due amount', function () {
+    $invoice = payableInvoice();
+
+    postJson('api/v1/payments', paymentPayloadFor($invoice, 20000))
+        ->assertOk();
+
+    $invoice->refresh();
+
+    expect((int) $invoice->due_amount)->toBe(0)
+        ->and($invoice->paid_status)->toBe(Invoice::STATUS_PAID)
+        ->and($invoice->status)->toBe(Invoice::STATUS_COMPLETED);
+});
+
+test('rejects a payment worth more than the balance a partial credit note left', function () {
+    $invoice = payableInvoice();
+    $creditedItem = $invoice->items()->first();
+
+    app(CreditNoteService::class)->create(
+        $invoice,
+        [['id' => $creditedItem->id, 'quantity' => 1]],
+        null
+    );
+
+    $invoice->refresh();
+
+    // Half the invoice was reversed, so half of it is still payable.
+    expect((int) $invoice->due_amount)->toBe(10000);
+
+    postJson('api/v1/payments', paymentPayloadFor($invoice, 10001))
+        ->assertStatus(422)
+        ->assertJsonPath('errors.amount.0', 'payment_amount_exceeds_invoice_due_amount');
+
+    $invoice->refresh();
+
+    expect((int) $invoice->due_amount)->toBe(10000);
+});
+
+test('accepts a payment worth exactly the balance a partial credit note left', function () {
+    $invoice = payableInvoice();
+    $creditedItem = $invoice->items()->first();
+
+    app(CreditNoteService::class)->create(
+        $invoice,
+        [['id' => $creditedItem->id, 'quantity' => 1]],
+        null
+    );
+
+    postJson('api/v1/payments', paymentPayloadFor($invoice->fresh(), 10000))
+        ->assertOk();
+
+    $invoice->refresh();
+
+    expect((int) $invoice->due_amount)->toBe(0)
+        ->and($invoice->paid_status)->toBe(Invoice::STATUS_PAID)
+        ->and($invoice->status)->toBe(Invoice::STATUS_COMPLETED);
+});
diff --git a/tests/Unit/CreditNoteAmountsTest.php b/tests/Unit/CreditNoteAmountsTest.php
new file mode 100644
index 00000000..2a447436
--- /dev/null
+++ b/tests/Unit/CreditNoteAmountsTest.php
@@ -0,0 +1,490 @@
+<?php
+
+use App\Support\CreditNoteAmounts;
+
+/**
+ * Builds a snapshot the way production stores an invoice: every figure is a
+ * pre-rounded integer derived the same way the client + DocumentTotals derive
+ * it, and the base_* columns are the pre-rounded product of the amount and the
+ * exchange rate.
+ */
+function creditSnapshot(array $options = []): array
+{
+    $taxPerItem = $options['tax_per_item'] ?? 'NO';
+    $discountPerItem = $options['discount_per_item'] ?? 'NO';
+    $taxIncluded = $options['tax_included'] ?? false;
+    $rate = $options['exchange_rate'] ?? 1.0;
+    $discountMode = $options['discount_mode'] ?? 'fixed';
+    $lines = $options['lines'] ?? [
+        11 => ['price' => 1234, 'quantity' => 3.0],
+        12 => ['price' => 999, 'quantity' => 2.5],
+    ];
+
+    $perItemDiscount = $discountPerItem === 'YES';
+    $perItemTax = $taxPerItem === 'YES';
+
+    $items = [];
+    $subTotal = 0;
+    $itemTaxTotal = 0;
+    $taxRowId = 100;
+
+    foreach ($lines as $id => $line) {
+        $amount = (int) round($line['price'] * $line['quantity']);
+
+        $discount = 0;
+        if ($perItemDiscount) {
+            $discount = $discountMode === 'percentage'
+                ? (int) round($amount * 10 / 100)
+                : ($line['discount_fixed'] ?? 500);
+        }
+
+        $total = $amount - $discount;
+
+        $taxes = [];
+        $itemTax = 0;
+        if ($perItemTax) {
+            $percentage = (int) round($total * 7 / 100);
+            $taxes[$taxRowId++] = ['amount' => $percentage, 'base_amount' => (int) round($percentage * $rate)];
+            $taxes[$taxRowId++] = ['amount' => 150, 'base_amount' => (int) round(150 * $rate)];
+            $itemTax = $percentage + 150;
+        }
+
+        $items[$id] = [
+            'price' => $line['price'],
+            'quantity' => (float) $line['quantity'],
+            'discount_val' => $discount,
+            'tax' => $itemTax,
+            'total' => $total,
+            'base_price' => (int) round($line['price'] * $rate),
+            'base_discount_val' => (int) round($discount * $rate),
+            'base_tax' => (int) round($itemTax * $rate),
+            'base_total' => (int) round($total * $rate),
+            'taxes' => $taxes,
+        ];
+
+        $subTotal += $total;
+        $itemTaxTotal += $itemTax;
+    }
+
+    $discountVal = 0;
+    if (! $perItemDiscount) {
+        $discountVal = $discountMode === 'percentage'
+            ? (int) round($subTotal * 5 / 100)
+            : ($options['discount_fixed'] ?? 750);
+    }
+
+    $documentTaxes = [];
+    $documentTaxTotal = 0;
+    if (! $perItemTax) {
+        $percentage = (int) round(($subTotal - $discountVal) * 7 / 100);
+        $documentTaxes[900] = ['amount' => $percentage, 'base_amount' => (int) round($percentage * $rate)];
+        $documentTaxes[901] = ['amount' => 150, 'base_amount' => (int) round(150 * $rate)];
+        $documentTaxTotal = $percentage + 150;
+    }
+
+    $tax = $perItemTax ? $itemTaxTotal : $documentTaxTotal;
+    $total = $taxIncluded ? $subTotal - $discountVal : $subTotal - $discountVal + $tax;
+
+    return [
+        'sub_total' => $subTotal,
+        'discount_val' => $discountVal,
+        'tax' => $tax,
+        'total' => $total,
+        'base_sub_total' => (int) round($subTotal * $rate),
+        'base_discount_val' => (int) round($discountVal * $rate),
+        'base_tax' => (int) round($tax * $rate),
+        'base_total' => (int) round($total * $rate),
+        'discount_per_item' => $discountPerItem,
+        'tax_per_item' => $taxPerItem,
+        'tax_included' => $taxIncluded,
+        'items' => $items,
+        'taxes' => $documentTaxes,
+    ];
+}
+
+/**
+ * The credited quantities that reverse the whole invoice.
+ */
+function creditFullQuantities(array $snapshot): array
+{
+    $quantities = [];
+
+    foreach ($snapshot['items'] as $id => $item) {
+        $quantities[$id] = CreditNoteAmounts::toHundredths($item['quantity']);
+    }
+
+    return $quantities;
+}
+
+function creditZeroQuantities(array $snapshot): array
+{
+    return array_fill_keys(array_keys($snapshot['items']), 0);
+}
+
+/**
+ * Strict, recursive comparison that reports which field diverged.
+ */
+function expectSameAmounts(array $expected, array $actual, string $path = ''): void
+{
+    expect(array_keys($actual))->toBe(array_keys($expected));
+
+    foreach ($expected as $key => $value) {
+        $at = $path === '' ? (string) $key : $path.'.'.$key;
+
+        if (is_array($value)) {
+            expectSameAmounts($value, $actual[$key], $at);
+
+            continue;
+        }
+
+        expect([$at => $actual[$key]])->toBe([$at => $value]);
+    }
+}
+
+/**
+ * The snapshot without the configuration flags, which is exactly the shape
+ * cumulative() returns.
+ */
+function creditExpectedIdentity(array $snapshot): array
+{
+    unset($snapshot['discount_per_item'], $snapshot['tax_per_item'], $snapshot['tax_included']);
+
+    return $snapshot;
+}
+
+dataset('credit note configurations', function () {
+    foreach (['YES', 'NO'] as $taxPerItem) {
+        foreach (['YES', 'NO'] as $discountPerItem) {
+            foreach ([true, false] as $taxIncluded) {
+                foreach (['fixed', 'percentage'] as $discountMode) {
+                    foreach ([1.0, 1.37] as $rate) {
+                        yield "tax_per_item=$taxPerItem discount_per_item=$discountPerItem tax_included=".
+                            ($taxIncluded ? 'yes' : 'no')." discount=$discountMode rate=$rate" => [[
+                                'tax_per_item' => $taxPerItem,
+                                'discount_per_item' => $discountPerItem,
+                                'tax_included' => $taxIncluded,
+                                'discount_mode' => $discountMode,
+                                'exchange_rate' => $rate,
+                            ]];
+                    }
+                }
+            }
+        }
+    }
+});
+
+test('crediting the full quantities reproduces the original invoice field for field', function (array $options) {
+    $snapshot = creditSnapshot($options);
+
+    $cumulative = CreditNoteAmounts::cumulative($snapshot, creditFullQuantities($snapshot));
+
+    expectSameAmounts(creditExpectedIdentity($snapshot), $cumulative);
+})->with('credit note configurations');
+
+test('crediting nothing is zero in every field', function (array $options) {
+    $snapshot = creditSnapshot($options);
+
+    $cumulative = CreditNoteAmounts::cumulative($snapshot, creditZeroQuantities($snapshot));
+
+    expect($cumulative['sub_total'])->toBe(0)
+        ->and($cumulative['discount_val'])->toBe(0)
+        ->and($cumulative['tax'])->toBe(0)
+        ->and($cumulative['total'])->toBe(0)
+        ->and($cumulative['base_sub_total'])->toBe(0)
+        ->and($cumulative['base_discount_val'])->toBe(0)
+        ->and($cumulative['base_tax'])->toBe(0)
+        ->and($cumulative['base_total'])->toBe(0);
+
+    foreach ($cumulative['items'] as $item) {
+        expect($item['total'])->toBe(0)->and($item['tax'])->toBe(0)->and($item['base_total'])->toBe(0);
+    }
+
+    foreach ($cumulative['taxes'] as $tax) {
+        expect($tax['amount'])->toBe(0)->and($tax['base_amount'])->toBe(0);
+    }
+})->with('credit note configurations');
+
+test('a line credited one unit at a time sums back to the original invoice', function () {
+    $snapshot = creditSnapshot([
+        'lines' => [21 => ['price' => 333, 'quantity' => 3.0]],
+        'discount_mode' => 'percentage',
+        'exchange_rate' => 1.37,
+    ]);
+
+    $credits = [
+        CreditNoteAmounts::forCredit($snapshot, [21 => 0], [21 => 100]),
+        CreditNoteAmounts::forCredit($snapshot, [21 => 100], [21 => 200]),
+        CreditNoteAmounts::forCredit($snapshot, [21 => 200], [21 => 300]),
+    ];
+
+    $documentFields = [
+        'sub_total', 'discount_val', 'tax', 'total',
+        'base_sub_total', 'base_discount_val', 'base_tax', 'base_total',
+    ];
+
+    foreach ($documentFields as $field) {
+        $sum = array_sum(array_column($credits, $field));
+
+        expect([$field => $sum])->toBe([$field => $snapshot[$field]]);
+    }
+
+    foreach (array_keys($snapshot['taxes']) as $taxId) {
+        $amount = array_sum(array_map(fn ($credit) => $credit['taxes'][$taxId]['amount'], $credits));
+        $baseAmount = array_sum(array_map(fn ($credit) => $credit['taxes'][$taxId]['base_amount'], $credits));
+
+        expect(["tax.$taxId.amount" => $amount])->toBe(["tax.$taxId.amount" => $snapshot['taxes'][$taxId]['amount']])
+            ->and(["tax.$taxId.base_amount" => $baseAmount])
+            ->toBe(["tax.$taxId.base_amount" => $snapshot['taxes'][$taxId]['base_amount']]);
+    }
+
+    $quantity = array_sum(array_map(fn ($credit) => $credit['items'][21]['quantity'], $credits));
+    $lineTotal = array_sum(array_map(fn ($credit) => $credit['items'][21]['total'], $credits));
+
+    expect($quantity)->toBe(3.0)
+        ->and($lineTotal)->toBe($snapshot['items'][21]['total'])
+        ->and($credits[0]['items'][21]['source_invoice_item_id'])->toBe(21)
+        ->and($credits[0]['items'][21]['price'])->toBe(333);
+});
+
+test('per-item tax rows also telescope back to the original amounts', function () {
+    $snapshot = creditSnapshot([
+        'tax_per_item' => 'YES',
+        'discount_per_item' => 'YES',
+        'discount_mode' => 'percentage',
+        'lines' => [31 => ['price' => 333, 'quantity' => 3.0]],
+        'exchange_rate' => 1.37,
+    ]);
+
+    $credits = [
+        CreditNoteAmounts::forCredit($snapshot, [31 => 0], [31 => 100]),
+        CreditNoteAmounts::forCredit($snapshot, [31 => 100], [31 => 200]),
+        CreditNoteAmounts::forCredit($snapshot, [31 => 200], [31 => 300]),
+    ];
+
+    foreach (array_keys($snapshot['items'][31]['taxes']) as $taxId) {
+        $amount = array_sum(array_map(fn ($credit) => $credit['items'][31]['taxes'][$taxId]['amount'], $credits));
+        $baseAmount = array_sum(array_map(fn ($credit) => $credit['items'][31]['taxes'][$taxId]['base_amount'], $credits));
+
+        expect(["item.tax.$taxId.amount" => $amount])
+            ->toBe(["item.tax.$taxId.amount" => $snapshot['items'][31]['taxes'][$taxId]['amount']])
+            ->and(["item.tax.$taxId.base_amount" => $baseAmount])
+            ->toBe(["item.tax.$taxId.base_amount" => $snapshot['items'][31]['taxes'][$taxId]['base_amount']]);
+    }
+
+    expect(array_sum(array_column($credits, 'tax')))->toBe($snapshot['tax'])
+        ->and(array_sum(array_column($credits, 'total')))->toBe($snapshot['total'])
+        ->and(array_sum(array_column($credits, 'base_tax')))->toBe($snapshot['base_tax'])
+        ->and(array_sum(array_column($credits, 'discount_val')))->toBe($snapshot['discount_val']);
+});
+
+test('the order the chunks are credited in does not change the result', function () {
+    $snapshot = creditSnapshot([
+        'lines' => [41 => ['price' => 333, 'quantity' => 3.0]],
+        'discount_mode' => 'percentage',
+        'exchange_rate' => 1.37,
+    ]);
+
+    $oneThenTwo = [
+        CreditNoteAmounts::forCredit($snapshot, [41 => 0], [41 => 100]),
+        CreditNoteAmounts::forCredit($snapshot, [41 => 100], [41 => 300]),
+    ];
+
+    $twoThenOne = [
+        CreditNoteAmounts::forCredit($snapshot, [41 => 0], [41 => 200]),
+        CreditNoteAmounts::forCredit($snapshot, [41 => 200], [41 => 300]),
+    ];
+
+    $atOnce = [CreditNoteAmounts::forCredit($snapshot, [41 => 0], [41 => 300])];
+
+    $documentFields = [
+        'sub_total', 'discount_val', 'tax', 'total',
+        'base_sub_total', 'base_discount_val', 'base_tax', 'base_total',
+    ];
+
+    foreach ($documentFields as $field) {
+        $a = array_sum(array_column($oneThenTwo, $field));
+        $b = array_sum(array_column($twoThenOne, $field));
+        $c = array_sum(array_column($atOnce, $field));
+
+        expect([$field => $a])->toBe([$field => $c])
+            ->and([$field => $b])->toBe([$field => $c]);
+    }
+});
+
+test('fractional quantities are exact in hundredths', function () {
+    $snapshot = creditSnapshot([
+        'lines' => [51 => ['price' => 4500, 'quantity' => 7.25]],
+        'discount_mode' => 'percentage',
+    ]);
+
+    expect($snapshot['sub_total'])->toBe(32625);
+
+    $credit = CreditNoteAmounts::forCredit($snapshot, [51 => 0], [51 => 250]);
+
+    expect($credit['items'][51]['quantity'])->toBe(2.5)
+        ->and($credit['items'][51]['total'])->toBe(11250)
+        ->and($credit['sub_total'])->toBe(11250);
+
+    $rest = CreditNoteAmounts::forCredit($snapshot, [51 => 250], [51 => 725]);
+
+    expect($rest['items'][51]['quantity'])->toBe(4.75)
+        ->and($credit['sub_total'] + $rest['sub_total'])->toBe($snapshot['sub_total'])
+        ->and($credit['total'] + $rest['total'])->toBe($snapshot['total'])
+        ->and($credit['tax'] + $rest['tax'])->toBe($snapshot['tax']);
+});
+
+test('zero sub totals, discounts and taxes never divide by zero', function () {
+    $snapshot = [
+        'sub_total' => 0,
+        'discount_val' => 0,
+        'tax' => 0,
+        'total' => 0,
+        'base_sub_total' => 0,
+        'base_discount_val' => 0,
+        'base_tax' => 0,
+        'base_total' => 0,
+        'discount_per_item' => 'YES',
+        'tax_per_item' => 'NO',
+        'tax_included' => false,
+        'items' => [
+            61 => [
+                'price' => 0,
+                'quantity' => 2.0,
+                'discount_val' => 0,
+                'tax' => 0,
+                'total' => 0,
+                'base_price' => 0,
+                'base_discount_val' => 0,
+                'base_tax' => 0,
+                'base_total' => 0,
+                'taxes' => [700 => ['amount' => 0, 'base_amount' => 0]],
+            ],
+            62 => [
+                'price' => 1000,
+                'quantity' => 0.0,
+                'discount_val' => 0,
+                'tax' => 0,
+                'total' => 0,
+                'base_price' => 1000,
+                'base_discount_val' => 0,
+                'base_tax' => 0,
+                'base_total' => 0,
+                'taxes' => [],
+            ],
+        ],
+        'taxes' => [800 => ['amount' => 0, 'base_amount' => 0]],
+    ];
+
+    set_error_handler(function (int $severity, string $message) {
+        throw new ErrorException($message, 0, $severity);
+    });
+
+    try {
+        $credit = CreditNoteAmounts::forCredit($snapshot, [61 => 0, 62 => 0], [61 => 200, 62 => 0]);
+    } finally {
+        restore_error_handler();
+    }
+
+    expect($credit['sub_total'])->toBe(0)
+        ->and($credit['discount_val'])->toBe(0)
+        ->and($credit['tax'])->toBe(0)
+        ->and($credit['total'])->toBe(0)
+        ->and($credit['base_sub_total'])->toBe(0)
+        ->and($credit['base_discount_val'])->toBe(0)
+        ->and($credit['base_tax'])->toBe(0)
+        ->and($credit['base_total'])->toBe(0)
+        ->and($credit['taxes'][800])->toBe(['amount' => 0, 'base_amount' => 0])
+        ->and($credit['items'][61]['total'])->toBe(0)
+        ->and($credit['items'][61]['quantity'])->toBe(2.0)
+        ->and($credit['items'])->not->toHaveKey(62);
+});
+
+test('every base amount equals its counterpart at exchange rate 1', function () {
+    $snapshot = creditSnapshot([
+        'tax_per_item' => 'YES',
+        'discount_per_item' => 'YES',
+        'discount_mode' => 'percentage',
+        'exchange_rate' => 1.0,
+    ]);
+
+    $credit = CreditNoteAmounts::forCredit($snapshot, [11 => 0, 12 => 0], [11 => 100, 12 => 150]);
+
+    expect($credit['base_sub_total'])->toBe($credit['sub_total'])
+        ->and($credit['base_discount_val'])->toBe($credit['discount_val'])
+        ->and($credit['base_tax'])->toBe($credit['tax'])
+        ->and($credit['base_total'])->toBe($credit['total']);
+
+    foreach ($credit['items'] as $item) {
+        expect($item['base_price'])->toBe($item['price'])
+            ->and($item['base_discount_val'])->toBe($item['discount_val'])
+            ->and($item['base_tax'])->toBe($item['tax'])
+            ->and($item['base_total'])->toBe($item['total']);
+
+        foreach ($item['taxes'] as $tax) {
+            expect($tax['base_amount'])->toBe($tax['amount']);
+        }
+    }
+});
+
+test('halves round away from zero rather than truncating', function () {
+    $snapshot = creditSnapshot([
+        'discount_per_item' => 'YES',
+        'lines' => [71 => ['price' => 333, 'quantity' => 3.0, 'discount_fixed' => 5]],
+    ]);
+
+    // 333 * 1.5 = 499.5: truncation would credit 499 cents.
+    $half = CreditNoteAmounts::cumulative($snapshot, [71 => 150]);
+
+    expect($half['items'][71]['total'] + $half['items'][71]['discount_val'])->toBe(500);
+
+    // The 5 cent line discount at ratio 1/2 is 2.5: truncation would credit 2.
+    expect($half['items'][71]['discount_val'])->toBe(3);
+});
+
+test('a first credit note against an untouched invoice equals the cumulative credit', function () {
+    $snapshot = creditSnapshot([
+        'tax_per_item' => 'YES',
+        'discount_per_item' => 'YES',
+        'discount_mode' => 'percentage',
+        'exchange_rate' => 1.37,
+    ]);
+
+    $after = [11 => 200, 12 => 0];
+
+    $credit = CreditNoteAmounts::forCredit($snapshot, [11 => 0, 12 => 0], $after);
+    $cumulative = CreditNoteAmounts::cumulative($snapshot, $after);
+
+    $documentFields = [
+        'sub_total', 'discount_val', 'tax', 'total',
+        'base_sub_total', 'base_discount_val', 'base_tax', 'base_total',
+    ];
+
+    foreach ($documentFields as $field) {
+        expect([$field => $credit[$field]])->toBe([$field => $cumulative[$field]]);
+    }
+
+    expect($credit['taxes'])->toBe($cumulative['taxes'])
+        ->and(array_keys($credit['items']))->toBe([11]);
+
+    foreach ($credit['items'] as $itemId => $item) {
+        foreach (['price', 'base_price', 'quantity', 'discount_val', 'tax', 'total', 'base_discount_val', 'base_tax', 'base_total', 'taxes'] as $field) {
+            expect([$field => $item[$field]])->toBe([$field => $cumulative['items'][$itemId][$field]]);
+        }
+    }
+});
+
+test('a full reversal built from forCredit matches the original invoice', function (array $options) {
+    $snapshot = creditSnapshot($options);
+
+    $credit = CreditNoteAmounts::forCredit($snapshot, creditZeroQuantities($snapshot), creditFullQuantities($snapshot));
+
+    expect($credit['sub_total'])->toBe($snapshot['sub_total'])
+        ->and($credit['discount_val'])->toBe($snapshot['discount_val'])
+        ->and($credit['tax'])->toBe($snapshot['tax'])
+        ->and($credit['total'])->toBe($snapshot['total'])
+        ->and($credit['base_sub_total'])->toBe($snapshot['base_sub_total'])
+        ->and($credit['base_discount_val'])->toBe($snapshot['base_discount_val'])
+        ->and($credit['base_tax'])->toBe($snapshot['base_tax'])
+        ->and($credit['base_total'])->toBe($snapshot['base_total'])
+        ->and($credit['taxes'])->toBe($snapshot['taxes']);
+})->with('credit note configurations');