diff --git a/app/Http/Controllers/Company/Customer/CustomerStatementController.php b/app/Http/Controllers/Company/Customer/CustomerStatementController.php
new file mode 100644
index 00000000..6dd011d2
--- /dev/null
+++ b/app/Http/Controllers/Company/Customer/CustomerStatementController.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Http\Controllers\Company\Customer;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\CustomerStatementRequest;
+use App\Http\Resources\CustomerStatementResource;
+use App\Models\Customer;
+use App\Services\CustomerStatementService;
+use Carbon\Carbon;
+
+class CustomerStatementController extends Controller
+{
+    public function __construct(
+        private readonly CustomerStatementService $customerStatementService,
+    ) {}
+
+    public function __invoke(CustomerStatementRequest $request, Customer $customer): CustomerStatementResource
+    {
+        $this->authorize('view', $customer);
+        $this->authorize('view report', $customer->company);
+
+        $type = $request->validated('type');
+
+        $statement = $this->customerStatementService->statement(
+            $customer,
+            $type,
+            Carbon::createFromFormat('Y-m-d', $request->validated('from_date')),
+            Carbon::createFromFormat('Y-m-d', $request->validated($type === CustomerStatementService::TYPE_OUTSTANDING ? 'as_of' : 'to_date')),
+            (int) $request->validated('per_page', 50),
+            (int) $request->validated('page', 1),
+        );
+
+        return new CustomerStatementResource($statement);
+    }
+}
diff --git a/app/Http/Controllers/Company/Customer/CustomerStatsController.php b/app/Http/Controllers/Company/Customer/CustomerStatsController.php
index 10b8e2f6..c646ee20 100644
--- a/app/Http/Controllers/Company/Customer/CustomerStatsController.php
+++ b/app/Http/Controllers/Company/Customer/CustomerStatsController.php
@@ -6,12 +6,14 @@ use App\Http\Controllers\Controller;
 use App\Http\Resources\CustomerResource;
 use App\Models\Customer;
 use App\Services\CustomerService;
+use App\Services\CustomerStatementService;
 use Illuminate\Http\Request;
 
 class CustomerStatsController extends Controller
 {
     public function __construct(
         private readonly CustomerService $customerService,
+        private readonly CustomerStatementService $customerStatementService,
     ) {}
 
     public function __invoke(Request $request, Customer $customer)
@@ -25,6 +27,7 @@ class CustomerStatsController extends Controller
         );
 
         $customer = Customer::find($customer->id);
+        $this->customerStatementService->hydrateAccountSummaries([$customer]);
 
         return (new CustomerResource($customer))
             ->additional(['meta' => [
diff --git a/app/Http/Controllers/Company/Customer/CustomersController.php b/app/Http/Controllers/Company/Customer/CustomersController.php
index 9b010d3b..3caa4240 100644
--- a/app/Http/Controllers/Company/Customer/CustomersController.php
+++ b/app/Http/Controllers/Company/Customer/CustomersController.php
@@ -8,13 +8,16 @@ use App\Http\Requests\DeleteCustomersRequest;
 use App\Http\Resources\CustomerResource;
 use App\Models\Customer;
 use App\Services\CustomerService;
+use App\Services\CustomerStatementService;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
+use Illuminate\Pagination\LengthAwarePaginator;
 
 class CustomersController extends Controller
 {
     public function __construct(
         private readonly CustomerService $customerService,
+        private readonly CustomerStatementService $customerStatementService,
     ) {}
 
     /**
@@ -31,10 +34,12 @@ class CustomersController extends Controller
         $customers = Customer::with('creator')
             ->whereCompany()
             ->applyFilters($request->all())
-            ->withSum('invoices as base_due_amount', 'base_due_amount')
-            ->withSum('invoices as due_amount', 'due_amount')
             ->paginateData($limit);
 
+        $this->customerStatementService->hydrateAccountSummaries(
+            $customers instanceof LengthAwarePaginator ? $customers->getCollection() : $customers
+        );
+
         return CustomerResource::collection($customers)
             ->additional(['meta' => [
                 'customer_total_count' => Customer::whereCompany()->count(),
@@ -52,6 +57,7 @@ class CustomersController extends Controller
         $this->authorize('create', Customer::class);
 
         $customer = $this->customerService->create($request);
+        $this->customerStatementService->hydrateAccountSummaries([$customer]);
 
         return new CustomerResource($customer);
     }
@@ -65,6 +71,8 @@ class CustomersController extends Controller
     {
         $this->authorize('view', $customer);
 
+        $this->customerStatementService->hydrateAccountSummaries([$customer]);
+
         return new CustomerResource($customer);
     }
 
@@ -79,6 +87,7 @@ class CustomersController extends Controller
         $this->authorize('update', $customer);
 
         $customer = $this->customerService->update($request, $customer);
+        $this->customerStatementService->hydrateAccountSummaries([$customer]);
 
         return new CustomerResource($customer);
     }
diff --git a/app/Http/Controllers/Company/Customer/SendCustomerStatementController.php b/app/Http/Controllers/Company/Customer/SendCustomerStatementController.php
new file mode 100644
index 00000000..4bf7b434
--- /dev/null
+++ b/app/Http/Controllers/Company/Customer/SendCustomerStatementController.php
@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Http\Controllers\Company\Customer;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\SendCustomerStatementRequest;
+use App\Mail\SendCustomerStatementMail;
+use App\Models\Customer;
+use App\Services\CustomerStatementPdfService;
+use App\Services\CustomerStatementService;
+use App\Services\Mail\CompanyMailConfigService;
+use Carbon\Carbon;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Support\Facades\Mail;
+
+class SendCustomerStatementController extends Controller
+{
+    public function __construct(
+        private readonly CustomerStatementService $customerStatementService,
+        private readonly CustomerStatementPdfService $customerStatementPdfService,
+    ) {}
+
+    public function __invoke(SendCustomerStatementRequest $request, Customer $customer): JsonResponse
+    {
+        $this->authorize('view', $customer);
+        $this->authorize('view report', $customer->company);
+
+        $type = $request->validated('type');
+
+        $statement = $this->customerStatementService->statement(
+            $customer,
+            $type,
+            Carbon::createFromFormat('Y-m-d', $request->validated('from_date')),
+            Carbon::createFromFormat('Y-m-d', $request->validated($type === CustomerStatementService::TYPE_OUTSTANDING ? 'as_of' : 'to_date')),
+            PHP_INT_MAX,
+        );
+        $pdf = $this->customerStatementPdfService->render($statement);
+
+        CompanyMailConfigService::apply($customer->company_id);
+
+        $mail = Mail::to($request->validated('to'));
+        if ($request->filled('cc')) {
+            $mail->cc($request->validated('cc'));
+        }
+        if ($request->filled('bcc')) {
+            $mail->bcc($request->validated('bcc'));
+        }
+
+        $mail->send(new SendCustomerStatementMail([
+            ...$request->safe()->only(['to', 'cc', 'bcc', 'subject', 'body']),
+            'from' => config('mail.from.address'),
+            'from_name' => config('mail.from.name'),
+            'customer' => $customer,
+            'pdf' => $pdf,
+            'filename' => __('Customer Statement').' '.$customer->name.'.pdf',
+        ]));
+
+        return response()->json(['success' => true]);
+    }
+}
diff --git a/app/Http/Controllers/Company/Invoice/InvoicesController.php b/app/Http/Controllers/Company/Invoice/InvoicesController.php
index ee0d1f9d..92a95c66 100644
--- a/app/Http/Controllers/Company/Invoice/InvoicesController.php
+++ b/app/Http/Controllers/Company/Invoice/InvoicesController.php
@@ -93,6 +93,7 @@ class InvoicesController extends Controller
         return new InvoiceResource($invoice->load([
             'creditNotes:id,related_invoice_id,invoice_number,total',
             'creditNotes.items:id,invoice_id,source_invoice_item_id,quantity',
+            'allocations.payment',
         ]));
     }
 
diff --git a/app/Http/Controllers/Company/Payment/CreditAllocationsController.php b/app/Http/Controllers/Company/Payment/CreditAllocationsController.php
new file mode 100644
index 00000000..f717741b
--- /dev/null
+++ b/app/Http/Controllers/Company/Payment/CreditAllocationsController.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Http\Controllers\Company\Payment;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\CreditAllocationRequest;
+use App\Models\Customer;
+use App\Models\Payment;
+use App\Services\Document\PaymentAllocationService;
+
+class CreditAllocationsController extends Controller
+{
+    public function __construct(
+        private readonly PaymentAllocationService $paymentAllocationService,
+    ) {}
+
+    public function store(CreditAllocationRequest $request, Customer $customer)
+    {
+        $this->authorize('view', $customer);
+
+        abort_unless((int) $customer->company_id === (int) $request->header('company'), 404);
+
+        $payments = Payment::query()
+            ->where('company_id', $customer->company_id)
+            ->where('customer_id', $customer->id)
+            ->whereIn('id', collect($request->validated('allocations'))->pluck('payment_id')->unique())
+            ->get();
+
+        foreach ($payments as $payment) {
+            $this->authorize('update', $payment);
+        }
+
+        $this->paymentAllocationService->applyCustomerCredits(
+            (int) $request->header('company'),
+            $customer->id,
+            $request->validated('allocations'),
+        );
+
+        return response()->json(['success' => true]);
+    }
+}
diff --git a/app/Http/Controllers/Company/Payment/PaymentsController.php b/app/Http/Controllers/Company/Payment/PaymentsController.php
index 473ef6ca..2a1eb325 100644
--- a/app/Http/Controllers/Company/Payment/PaymentsController.php
+++ b/app/Http/Controllers/Company/Payment/PaymentsController.php
@@ -5,9 +5,11 @@ namespace App\Http\Controllers\Company\Payment;
 use App\Http\Controllers\Controller;
 use App\Http\Requests\DeletePaymentsRequest;
 use App\Http\Requests\PaymentRequest;
+use App\Http\Requests\ReplacePaymentAllocationsRequest;
 use App\Http\Requests\SendPaymentRequest;
 use App\Http\Resources\PaymentResource;
 use App\Models\Payment;
+use App\Services\Document\PaymentAllocationService;
 use App\Services\Document\PaymentService;
 use Illuminate\Http\Request;
 use Illuminate\Http\Response;
@@ -16,6 +18,7 @@ use Illuminate\Mail\Markdown;
 class PaymentsController extends Controller
 {
     public function __construct(
+        private readonly PaymentAllocationService $paymentAllocationService,
         private readonly PaymentService $paymentService,
     ) {}
 
@@ -30,12 +33,12 @@ class PaymentsController extends Controller
 
         $limit = $request->has('limit') ? $request->limit : 10;
 
-        $payments = Payment::whereCompany()
+        $payments = Payment::with(['allocations.invoice'])
+            ->whereCompany()
             ->join('customers', 'customers.id', '=', 'payments.customer_id')
-            ->leftJoin('invoices', 'invoices.id', '=', 'payments.invoice_id')
             ->leftJoin('payment_methods', 'payment_methods.id', '=', 'payments.payment_method_id')
             ->applyFilters($request->all())
-            ->select('payments.*', 'customers.name', 'invoices.invoice_number', 'payment_methods.name as payment_mode')
+            ->select('payments.*', 'customers.name', 'payment_methods.name as payment_mode')
             ->latest()
             ->paginateData($limit);
 
@@ -64,7 +67,7 @@ class PaymentsController extends Controller
     {
         $this->authorize('view', $payment);
 
-        return new PaymentResource($payment);
+        return new PaymentResource($payment->load(['allocations.invoice']));
     }
 
     public function update(PaymentRequest $request, Payment $payment)
@@ -76,6 +79,17 @@ class PaymentsController extends Controller
         return new PaymentResource($payment);
     }
 
+    public function replaceAllocations(ReplacePaymentAllocationsRequest $request, Payment $payment)
+    {
+        $this->authorize('update', $payment);
+
+        abort_unless((int) $payment->company_id === (int) $request->header('company'), 404);
+
+        $payment = $this->paymentAllocationService->replace($payment, $request->validated('allocations'));
+
+        return new PaymentResource($payment->load(['allocations.invoice']));
+    }
+
     public function delete(DeletePaymentsRequest $request)
     {
         $this->authorize('delete multiple payments');
diff --git a/app/Http/Controllers/Company/Report/CustomerStatementReportController.php b/app/Http/Controllers/Company/Report/CustomerStatementReportController.php
new file mode 100644
index 00000000..1d45dc52
--- /dev/null
+++ b/app/Http/Controllers/Company/Report/CustomerStatementReportController.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Http\Controllers\Company\Report;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\CustomerStatementRequest;
+use App\Models\Customer;
+use App\Services\CustomerStatementPdfService;
+use App\Services\CustomerStatementService;
+use Carbon\Carbon;
+use Silber\Bouncer\BouncerFacade;
+
+class CustomerStatementReportController extends Controller
+{
+    public function __construct(
+        private readonly CustomerStatementService $customerStatementService,
+        private readonly CustomerStatementPdfService $customerStatementPdfService,
+    ) {}
+
+    public function __invoke(CustomerStatementRequest $request, Customer $customer)
+    {
+        BouncerFacade::scope()->to($customer->company_id);
+
+        $this->authorize('view', $customer);
+        $this->authorize('view report', $customer->company);
+
+        $type = $request->validated('type');
+
+        $statement = $this->customerStatementService->statement(
+            $customer,
+            $type,
+            Carbon::createFromFormat('Y-m-d', $request->validated('from_date')),
+            Carbon::createFromFormat('Y-m-d', $request->validated($type === CustomerStatementService::TYPE_OUTSTANDING ? 'as_of' : 'to_date')),
+            PHP_INT_MAX,
+        );
+        $pdf = $this->customerStatementPdfService->render($statement);
+
+        if ($request->boolean('preview')) {
+            return view('app.pdf.reports.customer-statement', [
+                'statement' => $statement,
+                'customer' => $customer,
+                'company' => $customer->company,
+                'currency' => $statement['currency'],
+                'logo' => $customer->company->logo_path,
+            ]);
+        }
+
+        if ($request->boolean('download')) {
+            return $pdf->download(__('Customer Statement').' '.$customer->name.'.pdf');
+        }
+
+        return $pdf->stream();
+    }
+}
diff --git a/app/Http/Controllers/CustomerPortal/Payment/PaymentsController.php b/app/Http/Controllers/CustomerPortal/Payment/PaymentsController.php
index 4ba36cc3..e9e19ae7 100644
--- a/app/Http/Controllers/CustomerPortal/Payment/PaymentsController.php
+++ b/app/Http/Controllers/CustomerPortal/Payment/PaymentsController.php
@@ -21,16 +21,15 @@ class PaymentsController extends Controller
     {
         $limit = $request->has('limit') ? $request->limit : 10;
 
-        $payments = Payment::with(['customer', 'invoice', 'paymentMethod', 'creator'])
+        $payments = Payment::with(['customer', 'allocations.invoice', 'paymentMethod', 'creator'])
             ->whereCustomer(Auth::guard('customer')->id())
-            ->leftJoin('invoices', 'invoices.id', '=', 'payments.invoice_id')
             ->applyFilters($request->only([
                 'payment_number',
                 'payment_method_id',
                 'orderByField',
                 'orderBy',
             ]))
-            ->select('payments.*', 'invoices.invoice_number')
+            ->select('payments.*')
             ->latest()
             ->paginateData($limit);
 
@@ -57,6 +56,6 @@ class PaymentsController extends Controller
             return response()->json(['error' => 'payment_not_found'], 404);
         }
 
-        return new PaymentResource($payment);
+        return new PaymentResource($payment->load(['allocations.invoice']));
     }
 }
diff --git a/app/Http/Requests/CreditAllocationRequest.php b/app/Http/Requests/CreditAllocationRequest.php
new file mode 100644
index 00000000..a1a20aa8
--- /dev/null
+++ b/app/Http/Requests/CreditAllocationRequest.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class CreditAllocationRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, array<int, string>>
+     */
+    public function rules(): array
+    {
+        return [
+            'allocations' => ['required', 'array', 'min:1'],
+            'allocations.*.payment_id' => ['required', 'integer'],
+            'allocations.*.invoice_id' => ['required', 'integer'],
+            'allocations.*.amount' => ['required', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/CustomerStatementRequest.php b/app/Http/Requests/CustomerStatementRequest.php
new file mode 100644
index 00000000..2c009a6a
--- /dev/null
+++ b/app/Http/Requests/CustomerStatementRequest.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Http\Requests;
+
+use App\Services\CustomerStatementService;
+use Carbon\Carbon;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class CustomerStatementRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, mixed>
+     */
+    public function rules(): array
+    {
+        return [
+            'type' => ['required', Rule::in([CustomerStatementService::TYPE_ACTIVITY, CustomerStatementService::TYPE_OUTSTANDING])],
+            'from_date' => ['nullable', 'date_format:Y-m-d', 'required_if:type,activity'],
+            'to_date' => ['nullable', 'date_format:Y-m-d', 'required_if:type,activity', 'after_or_equal:from_date'],
+            'as_of' => ['nullable', 'date_format:Y-m-d', 'required_if:type,outstanding'],
+            'per_page' => ['nullable', 'integer', 'min:1', 'max:100'],
+            'page' => ['nullable', 'integer', 'min:1'],
+        ];
+    }
+
+    protected function prepareForValidation(): void
+    {
+        $type = $this->input('type', CustomerStatementService::TYPE_ACTIVITY);
+        $today = Carbon::today();
+
+        $this->merge([
+            'type' => $type,
+            'from_date' => $this->input('from_date', $today->copy()->startOfMonth()->toDateString()),
+            'to_date' => $this->input('to_date', $today->toDateString()),
+            'as_of' => $this->input('as_of', $today->toDateString()),
+        ]);
+    }
+}
diff --git a/app/Http/Requests/PaymentRequest.php b/app/Http/Requests/PaymentRequest.php
index 78692859..3080d504 100644
--- a/app/Http/Requests/PaymentRequest.php
+++ b/app/Http/Requests/PaymentRequest.php
@@ -4,10 +4,9 @@ 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;
+use Illuminate\Validation\Validator;
 
 class PaymentRequest extends FormRequest
 {
@@ -30,20 +29,21 @@ class PaymentRequest extends FormRequest
             ],
             'customer_id' => [
                 'required',
+                Rule::exists('customers', 'id')->where('company_id', $this->header('company')),
             ],
             'exchange_rate' => [
                 'nullable',
+                'numeric',
+                'gt:0',
             ],
-            'amount' => [
-                'required',
-            ],
+            'amount' => ['required', 'integer', 'min:1'],
             'payment_number' => [
                 'required',
                 Rule::unique('payments')->where('company_id', $this->header('company')),
             ],
-            'invoice_id' => [
-                'nullable',
-            ],
+            'allocations' => ['sometimes', 'array'],
+            'allocations.*.invoice_id' => ['required', 'integer', 'distinct'],
+            'allocations.*.amount' => ['required', 'integer', 'min:1'],
             'payment_method_id' => [
                 'nullable',
             ],
@@ -61,16 +61,6 @@ 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);
@@ -79,6 +69,8 @@ class PaymentRequest extends FormRequest
             if ((string) $customer->currency_id !== $companyCurrency) {
                 $rules['exchange_rate'] = [
                     'required',
+                    'numeric',
+                    'gt:0',
                 ];
             }
         }
@@ -87,68 +79,36 @@ class PaymentRequest extends FormRequest
     }
 
     /**
-     * The message string IS the translation key here, as everywhere else in the
-     * app: the front end maps it to a localized string.
+     * Reject the retired field without advertising it in the generated API
+     * schema. Payment-to-invoice links now exist only inside allocations.
      */
-    public function messages(): array
+    public function withValidator(Validator $validator): void
     {
-        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;
+        $validator->after(function (Validator $validator): void {
+            if ($this->exists('invoice_id')) {
+                $validator->errors()->add(
+                    'invoice_id',
+                    __('validation.prohibited', ['attribute' => 'invoice id'])
+                );
+            }
+        });
     }
 
     public function getPaymentPayload()
     {
         $company_currency = CompanySetting::getSetting('currency', $this->header('company'));
-        $current_currency = $this->currency_id;
-        $exchange_rate = $company_currency != $current_currency ? $this->exchange_rate : 1;
         $currency = Customer::find($this->customer_id)->currency_id;
+        $exchange_rate = (string) $company_currency !== (string) $currency
+            ? (float) $this->exchange_rate
+            : 1;
 
         return collect($this->validated())
+            ->except('allocations')
             ->merge([
                 'creator_id' => $this->user()->id,
                 'company_id' => $this->header('company'),
                 'exchange_rate' => $exchange_rate,
-                'base_amount' => $this->amount * $exchange_rate,
+                'base_amount' => (int) round($this->amount * $exchange_rate),
                 'currency_id' => $currency,
             ])
             ->toArray();
diff --git a/app/Http/Requests/ReplacePaymentAllocationsRequest.php b/app/Http/Requests/ReplacePaymentAllocationsRequest.php
new file mode 100644
index 00000000..33fdd137
--- /dev/null
+++ b/app/Http/Requests/ReplacePaymentAllocationsRequest.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class ReplacePaymentAllocationsRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, array<int, string>>
+     */
+    public function rules(): array
+    {
+        return [
+            'allocations' => ['present', 'array'],
+            'allocations.*.invoice_id' => ['required', 'integer', 'distinct'],
+            'allocations.*.amount' => ['required', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/SendCustomerStatementRequest.php b/app/Http/Requests/SendCustomerStatementRequest.php
new file mode 100644
index 00000000..42fc82fa
--- /dev/null
+++ b/app/Http/Requests/SendCustomerStatementRequest.php
@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Http\Requests;
+
+use App\Services\CustomerStatementService;
+use Carbon\Carbon;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class SendCustomerStatementRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, mixed>
+     */
+    public function rules(): array
+    {
+        return [
+            'type' => ['required', Rule::in([CustomerStatementService::TYPE_ACTIVITY, CustomerStatementService::TYPE_OUTSTANDING])],
+            'from_date' => ['nullable', 'date_format:Y-m-d', 'required_if:type,activity'],
+            'to_date' => ['nullable', 'date_format:Y-m-d', 'required_if:type,activity', 'after_or_equal:from_date'],
+            'as_of' => ['nullable', 'date_format:Y-m-d', 'required_if:type,outstanding'],
+            'subject' => ['required', 'string'],
+            'body' => ['required', 'string'],
+            'to' => ['required', 'email'],
+            'cc' => ['nullable', 'email'],
+            'bcc' => ['nullable', 'email'],
+        ];
+    }
+
+    protected function prepareForValidation(): void
+    {
+        $type = $this->input('type', CustomerStatementService::TYPE_ACTIVITY);
+        $today = Carbon::today();
+
+        $this->merge([
+            'type' => $type,
+            'from_date' => $this->input('from_date', $today->copy()->startOfMonth()->toDateString()),
+            'to_date' => $this->input('to_date', $today->toDateString()),
+            'as_of' => $this->input('as_of', $today->toDateString()),
+        ]);
+    }
+}
diff --git a/app/Http/Resources/Customer/PaymentResource.php b/app/Http/Resources/Customer/PaymentResource.php
index 3cf3b688..b1ffbddc 100644
--- a/app/Http/Resources/Customer/PaymentResource.php
+++ b/app/Http/Resources/Customer/PaymentResource.php
@@ -14,6 +14,15 @@ class PaymentResource extends JsonResource
      */
     public function toArray($request): array
     {
+        $allocations = $this->relationLoaded('allocations')
+            ? $this->allocations
+            : $this->allocations()->with('invoice')->get();
+        $allocatedAmount = (int) $allocations->sum('amount');
+        $baseAllocatedAmount = (int) $allocations->sum('base_amount');
+        $baseAmount = $this->base_amount === null
+            ? (int) round($this->amount * ($this->exchange_rate ?: 1))
+            : (int) $this->base_amount;
+
         return [
             'id' => $this->id,
             'payment_number' => $this->payment_number,
@@ -21,12 +30,22 @@ class PaymentResource extends JsonResource
             'notes' => $this->notes,
             'amount' => $this->amount,
             'unique_hash' => $this->unique_hash,
-            'invoice_id' => $this->invoice_id,
             'company_id' => $this->company_id,
             'payment_method_id' => $this->payment_method_id,
             'customer_id' => $this->customer_id,
             'exchange_rate' => $this->exchange_rate,
-            'base_amount' => $this->base_amount,
+            'base_amount' => $baseAmount,
+            'allocations' => $allocations->map(fn ($allocation) => [
+                'id' => $allocation->id,
+                'invoice_id' => $allocation->invoice_id,
+                'amount' => $allocation->amount,
+                'base_amount' => $allocation->base_amount,
+                'invoice' => $allocation->invoice ? new InvoiceResource($allocation->invoice) : null,
+            ]),
+            'allocated_amount' => $allocatedAmount,
+            'unallocated_amount' => (int) ((int) $this->amount - $allocatedAmount),
+            'base_allocated_amount' => $baseAllocatedAmount,
+            'base_unallocated_amount' => (int) ($baseAmount - $baseAllocatedAmount),
             'currency_id' => $this->currency_id,
             'transaction_id' => $this->transaction_id,
             'formatted_created_at' => $this->formattedCreatedAt,
@@ -35,9 +54,6 @@ class PaymentResource extends JsonResource
             'customer' => $this->when($this->customer()->exists(), function () {
                 return new CustomerResource($this->customer);
             }),
-            'invoice' => $this->when($this->invoice()->exists(), function () {
-                return new InvoiceResource($this->invoice);
-            }),
             'payment_method' => $this->when($this->paymentMethod()->exists(), function () {
                 return new PaymentMethodResource($this->paymentMethod);
             }),
diff --git a/app/Http/Resources/CustomerResource.php b/app/Http/Resources/CustomerResource.php
index 32e35948..8c65faf1 100644
--- a/app/Http/Resources/CustomerResource.php
+++ b/app/Http/Resources/CustomerResource.php
@@ -35,6 +35,12 @@ class CustomerResource extends JsonResource
             'avatar' => $this->avatar,
             'due_amount' => $this->due_amount,
             'base_due_amount' => $this->base_due_amount,
+            'invoice_due_amount' => $this->invoice_due_amount,
+            'base_invoice_due_amount' => $this->base_invoice_due_amount,
+            'available_credit' => $this->available_credit,
+            'base_available_credit' => $this->base_available_credit,
+            'account_balance' => $this->account_balance,
+            'base_account_balance' => $this->base_account_balance,
             'prefix' => $this->prefix,
             'tax_id' => $this->tax_id,
             'billing' => $this->when($this->billingAddress()->exists(), function () {
diff --git a/app/Http/Resources/CustomerStatementResource.php b/app/Http/Resources/CustomerStatementResource.php
new file mode 100644
index 00000000..f4dc6850
--- /dev/null
+++ b/app/Http/Resources/CustomerStatementResource.php
@@ -0,0 +1,100 @@
+<?php
+
+namespace App\Http\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+use Illuminate\Pagination\LengthAwarePaginator;
+
+class CustomerStatementResource extends JsonResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @return array<string, mixed>
+     */
+    public function toArray(Request $request): array
+    {
+        $statement = $this->resource;
+
+        $data = [
+            'type' => $statement['type'],
+            'customer' => new CustomerResource($statement['customer']),
+            'currency' => new CurrencyResource($statement['currency']),
+        ];
+
+        if ($statement['type'] === 'activity') {
+            /** @var LengthAwarePaginator $entries */
+            $entries = $statement['entries'];
+            $items = array_values(collect($entries->items())->map(fn (array $entry): array => [
+                'id' => (int) $entry['id'],
+                'date' => (string) $entry['date'],
+                'entry_type' => (string) $entry['entry_type'],
+                'reference' => (string) $entry['reference'],
+                'description' => (string) $entry['description'],
+                'debit_amount' => (int) $entry['debit_amount'],
+                'credit_amount' => (int) $entry['credit_amount'],
+                'base_debit_amount' => (int) $entry['base_debit_amount'],
+                'base_credit_amount' => (int) $entry['base_credit_amount'],
+                'balance' => (int) $entry['balance'],
+                'base_balance' => (int) $entry['base_balance'],
+            ])->all());
+
+            return array_merge($data, [
+                'from_date' => (string) $statement['from_date'],
+                'to_date' => (string) $statement['to_date'],
+                'opening_balance' => (int) $statement['opening_balance'],
+                'base_opening_balance' => (int) $statement['base_opening_balance'],
+                'closing_balance' => (int) $statement['closing_balance'],
+                'base_closing_balance' => (int) $statement['base_closing_balance'],
+                'entries' => $items,
+                'meta' => [
+                    'current_page' => (int) $entries->currentPage(),
+                    'last_page' => (int) $entries->lastPage(),
+                    'per_page' => (int) $entries->perPage(),
+                    'total' => (int) $entries->total(),
+                ],
+            ]);
+        }
+
+        $invoices = array_values(collect($statement['invoices'])->map(fn (array $invoice): array => [
+            'id' => (int) $invoice['id'],
+            'invoice_number' => (string) $invoice['invoice_number'],
+            'invoice_date' => (string) $invoice['invoice_date'],
+            'due_date' => $invoice['due_date'] === null ? null : (string) $invoice['due_date'],
+            'original_amount' => (int) $invoice['original_amount'],
+            'allocated_amount' => (int) $invoice['allocated_amount'],
+            'credit_amount' => (int) $invoice['credit_amount'],
+            'applied_amount' => (int) $invoice['applied_amount'],
+            'remaining_amount' => (int) $invoice['remaining_amount'],
+            'base_original_amount' => (int) $invoice['base_original_amount'],
+            'base_allocated_amount' => (int) $invoice['base_allocated_amount'],
+            'base_credit_amount' => (int) $invoice['base_credit_amount'],
+            'base_applied_amount' => (int) $invoice['base_applied_amount'],
+            'base_remaining_amount' => (int) $invoice['base_remaining_amount'],
+        ])->all());
+        $credits = array_values(collect($statement['credits'])->map(fn (array $credit): array => [
+            'id' => (int) $credit['id'],
+            'payment_number' => (string) $credit['payment_number'],
+            'payment_date' => (string) $credit['payment_date'],
+            'amount' => (int) $credit['amount'],
+            'allocated_amount' => (int) $credit['allocated_amount'],
+            'available_amount' => (int) $credit['available_amount'],
+            'base_amount' => (int) $credit['base_amount'],
+            'base_allocated_amount' => (int) $credit['base_allocated_amount'],
+            'base_available_amount' => (int) $credit['base_available_amount'],
+        ])->all());
+
+        return array_merge($data, [
+            'as_of' => (string) $statement['as_of'],
+            'invoices' => $invoices,
+            'credits' => $credits,
+            'invoice_due_amount' => (int) $statement['invoice_due_amount'],
+            'base_invoice_due_amount' => (int) $statement['base_invoice_due_amount'],
+            'available_credit' => (int) $statement['available_credit'],
+            'base_available_credit' => (int) $statement['base_available_credit'],
+            'account_balance' => (int) $statement['account_balance'],
+            'base_account_balance' => (int) $statement['base_account_balance'],
+        ]);
+    }
+}
diff --git a/app/Http/Resources/InvoiceResource.php b/app/Http/Resources/InvoiceResource.php
index 64aff4b3..b250a7da 100644
--- a/app/Http/Resources/InvoiceResource.php
+++ b/app/Http/Resources/InvoiceResource.php
@@ -120,6 +120,24 @@ class InvoiceResource extends JsonResource
                     return (object) $quantities;
                 }
             ),
+            // Allocation rows explain how this invoice was settled without
+            // reintroducing the removed singular payment.invoice relation.
+            // They are loaded for the detail response only, so index listings
+            // remain free of per-row payment queries.
+            'payment_allocations' => $this->when(
+                $this->relationLoaded('allocations'),
+                fn () => $this->allocations->map(fn ($allocation) => [
+                    'id' => $allocation->id,
+                    'payment_id' => $allocation->payment_id,
+                    'amount' => $allocation->amount,
+                    'base_amount' => $allocation->base_amount,
+                    'payment' => $allocation->relationLoaded('payment') && $allocation->payment ? [
+                        'id' => $allocation->payment->id,
+                        'payment_number' => $allocation->payment->payment_number,
+                        'formatted_payment_date' => $allocation->payment->formattedPaymentDate,
+                    ] : null,
+                ])->values()
+            ),
             'items' => $this->when($this->items()->exists(), function () {
                 return InvoiceItemResource::collection($this->items);
             }),
diff --git a/app/Http/Resources/PaymentResource.php b/app/Http/Resources/PaymentResource.php
index 2c69709e..abf433d7 100644
--- a/app/Http/Resources/PaymentResource.php
+++ b/app/Http/Resources/PaymentResource.php
@@ -14,6 +14,15 @@ class PaymentResource extends JsonResource
      */
     public function toArray($request): array
     {
+        $allocations = $this->relationLoaded('allocations')
+            ? $this->allocations
+            : $this->allocations()->with('invoice')->get();
+        $allocatedAmount = (int) $allocations->sum('amount');
+        $baseAllocatedAmount = (int) $allocations->sum('base_amount');
+        $baseAmount = $this->base_amount === null
+            ? (int) round($this->amount * ($this->exchange_rate ?: 1))
+            : (int) $this->base_amount;
+
         return [
             'id' => $this->id,
             'payment_number' => $this->payment_number,
@@ -21,13 +30,23 @@ class PaymentResource extends JsonResource
             'notes' => $this->getNotes(),
             'amount' => $this->amount,
             'unique_hash' => $this->unique_hash,
-            'invoice_id' => $this->invoice_id,
             'company_id' => $this->company_id,
             'payment_method_id' => $this->payment_method_id,
             'creator_id' => $this->creator_id,
             'customer_id' => $this->customer_id,
             'exchange_rate' => $this->exchange_rate,
-            'base_amount' => $this->base_amount,
+            'base_amount' => $baseAmount,
+            'allocations' => $allocations->map(fn ($allocation) => [
+                'id' => $allocation->id,
+                'invoice_id' => $allocation->invoice_id,
+                'amount' => $allocation->amount,
+                'base_amount' => $allocation->base_amount,
+                'invoice' => $allocation->invoice ? new InvoiceResource($allocation->invoice) : null,
+            ]),
+            'allocated_amount' => $allocatedAmount,
+            'unallocated_amount' => (int) ((int) $this->amount - $allocatedAmount),
+            'base_allocated_amount' => $baseAllocatedAmount,
+            'base_unallocated_amount' => (int) ($baseAmount - $baseAllocatedAmount),
             'currency_id' => $this->currency_id,
             'transaction_id' => $this->transaction_id,
             'sequence_number' => $this->sequence_number,
@@ -37,9 +56,6 @@ class PaymentResource extends JsonResource
             'customer' => $this->when($this->customer()->exists(), function () {
                 return new CustomerResource($this->customer);
             }),
-            'invoice' => $this->when($this->invoice()->exists(), function () {
-                return new InvoiceResource($this->invoice);
-            }),
             'payment_method' => $this->when($this->paymentMethod()->exists(), function () {
                 return new PaymentMethodResource($this->paymentMethod);
             }),
diff --git a/app/Mail/SendCustomerStatementMail.php b/app/Mail/SendCustomerStatementMail.php
new file mode 100644
index 00000000..73d797f6
--- /dev/null
+++ b/app/Mail/SendCustomerStatementMail.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Mail;
+
+use App\Models\EmailLog;
+use Illuminate\Bus\Queueable;
+use Illuminate\Mail\Mailable;
+use Illuminate\Queue\SerializesModels;
+
+class SendCustomerStatementMail extends Mailable
+{
+    use Queueable, SerializesModels;
+
+    public array $data;
+
+    public function __construct(array $data)
+    {
+        $this->data = $data;
+    }
+
+    public function build()
+    {
+        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' => $this->data['customer']::class,
+            'mailable_id' => $this->data['customer']->id,
+        ]);
+
+        return $this->from($this->data['from'], $this->data['from_name'])
+            ->subject($this->data['subject'])
+            ->markdown('emails.send.customer-statement', ['data' => $this->data])
+            ->attachData($this->data['pdf']->output(), $this->data['filename']);
+    }
+}
diff --git a/app/Models/Customer.php b/app/Models/Customer.php
index bcd2283d..b5e2454e 100644
--- a/app/Models/Customer.php
+++ b/app/Models/Customer.php
@@ -10,6 +10,7 @@ use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\Relations\HasOne;
+use Illuminate\Database\Eloquent\Relations\MorphMany;
 use Illuminate\Foundation\Auth\User as Authenticatable;
 use Illuminate\Notifications\Notifiable;
 use Laravel\Sanctum\HasApiTokens;
@@ -85,6 +86,11 @@ class Customer extends Authenticatable implements HasMedia
         return $this->hasMany(Payment::class);
     }
 
+    public function emailLogs(): MorphMany
+    {
+        return $this->morphMany(EmailLog::class, 'mailable');
+    }
+
     public function addresses(): HasMany
     {
         return $this->hasMany(Address::class);
diff --git a/app/Models/Invoice.php b/app/Models/Invoice.php
index 0d0f07e8..a4728ab1 100644
--- a/app/Models/Invoice.php
+++ b/app/Models/Invoice.php
@@ -12,6 +12,7 @@ use Carbon\Carbon;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\Relations\MorphMany;
 use Illuminate\Support\Str;
@@ -96,9 +97,16 @@ class Invoice extends Model implements HasMedia
         return $this->hasMany(Tax::class);
     }
 
-    public function payments(): HasMany
+    public function allocations(): HasMany
     {
-        return $this->hasMany(Payment::class);
+        return $this->hasMany(PaymentAllocation::class);
+    }
+
+    public function payments(): BelongsToMany
+    {
+        return $this->belongsToMany(Payment::class, 'payment_allocations')
+            ->withPivot(['amount', 'base_amount'])
+            ->withTimestamps();
     }
 
     public function currency(): BelongsTo
diff --git a/app/Models/Payment.php b/app/Models/Payment.php
index add37c5e..5e367718 100644
--- a/app/Models/Payment.php
+++ b/app/Models/Payment.php
@@ -12,7 +12,10 @@ use Carbon\Carbon;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\Relations\MorphMany;
+use Illuminate\Support\Facades\DB;
 use Spatie\MediaLibrary\HasMedia;
 use Spatie\MediaLibrary\InteractsWithMedia;
 
@@ -44,11 +47,11 @@ class Payment extends Model implements HasMedia
     protected static function booted()
     {
         static::created(function ($payment) {
-            GeneratePaymentPdfJob::dispatch($payment);
+            DB::afterCommit(fn () => GeneratePaymentPdfJob::dispatch($payment)->afterCommit());
         });
 
         static::updated(function ($payment) {
-            GeneratePaymentPdfJob::dispatch($payment, true);
+            DB::afterCommit(fn () => GeneratePaymentPdfJob::dispatch($payment, true)->afterCommit());
         });
     }
 
@@ -98,9 +101,16 @@ class Payment extends Model implements HasMedia
         return $this->belongsTo(Company::class);
     }
 
-    public function invoice(): BelongsTo
+    public function allocations(): HasMany
     {
-        return $this->belongsTo(Invoice::class);
+        return $this->hasMany(PaymentAllocation::class);
+    }
+
+    public function invoices(): BelongsToMany
+    {
+        return $this->belongsToMany(Invoice::class, 'payment_allocations')
+            ->withPivot(['amount', 'base_amount'])
+            ->withTimestamps();
     }
 
     public function creator(): BelongsTo
diff --git a/app/Models/PaymentAllocation.php b/app/Models/PaymentAllocation.php
new file mode 100644
index 00000000..b4d7d7f6
--- /dev/null
+++ b/app/Models/PaymentAllocation.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class PaymentAllocation extends Model
+{
+    use HasFactory;
+
+    protected $guarded = ['id'];
+
+    protected function casts(): array
+    {
+        return [
+            'amount' => 'integer',
+            'base_amount' => 'integer',
+        ];
+    }
+
+    public function payment(): BelongsTo
+    {
+        return $this->belongsTo(Payment::class);
+    }
+
+    public function invoice(): BelongsTo
+    {
+        return $this->belongsTo(Invoice::class);
+    }
+}
diff --git a/app/Services/Ai/Tools/ListRecentPaymentsTool.php b/app/Services/Ai/Tools/ListRecentPaymentsTool.php
index 4ddde204..d5d1caa8 100644
--- a/app/Services/Ai/Tools/ListRecentPaymentsTool.php
+++ b/app/Services/Ai/Tools/ListRecentPaymentsTool.php
@@ -22,7 +22,7 @@ class ListRecentPaymentsTool extends AiTool
 
     public function description(): string
     {
-        return 'List payments received in the last N days for the current company, sorted most recent first. Returns payment number, customer, amount, payment date, and payment method.';
+        return 'List payments received in the last N days for the current company, sorted most recent first. Returns payment number, customer, amount, allocation breakdown, unapplied credit, payment date, and payment method.';
     }
 
     public function parameterSchema(): array
@@ -62,7 +62,7 @@ class ListRecentPaymentsTool extends AiTool
         $payments = Payment::query()
             ->where('company_id', $companyId)
             ->where('payment_date', '>=', $since)
-            ->with(['customer:id,name', 'paymentMethod:id,name'])
+            ->with(['allocations:id,payment_id,invoice_id,amount', 'customer:id,name', 'paymentMethod:id,name'])
             ->latest('payment_date')
             ->limit($limit)
             ->get();
@@ -76,7 +76,12 @@ class ListRecentPaymentsTool extends AiTool
                 'amount' => $p->amount,
                 'customer_id' => $p->customer_id,
                 'customer_name' => $p->customer?->name,
-                'invoice_id' => $p->invoice_id,
+                'allocations' => $p->allocations->map(fn ($allocation) => [
+                    'invoice_id' => $allocation->invoice_id,
+                    'amount' => $allocation->amount,
+                ])->all(),
+                'allocated_amount' => (int) $p->allocations->sum('amount'),
+                'unallocated_amount' => (int) $p->amount - (int) $p->allocations->sum('amount'),
                 'payment_method' => $p->paymentMethod?->name,
             ])->all(),
         ];
diff --git a/app/Services/Company/CompanyService.php b/app/Services/Company/CompanyService.php
index 5afb98dd..b2c3e1d4 100644
--- a/app/Services/Company/CompanyService.php
+++ b/app/Services/Company/CompanyService.php
@@ -4,6 +4,7 @@ namespace App\Services\Company;
 
 use App\Models\Company;
 use App\Models\CompanySetting;
+use App\Models\PaymentAllocation;
 use App\Models\PaymentMethod;
 use App\Models\Unit;
 use App\Models\User;
@@ -56,6 +57,9 @@ class CompanyService
         }
 
         if ($company->payments()->exists()) {
+            PaymentAllocation::query()
+                ->whereIn('payment_id', $company->payments()->select('id'))
+                ->delete();
             $company->payments()->delete();
         }
 
diff --git a/app/Services/CustomerService.php b/app/Services/CustomerService.php
index aa3e0405..c36366d6 100644
--- a/app/Services/CustomerService.php
+++ b/app/Services/CustomerService.php
@@ -7,6 +7,7 @@ use App\Models\Customer;
 use App\Models\Expense;
 use App\Models\Invoice;
 use App\Models\Payment;
+use App\Models\PaymentAllocation;
 use Carbon\Carbon;
 use Illuminate\Http\Request;
 use Illuminate\Support\Collection;
@@ -86,6 +87,16 @@ class CustomerService
                 $customer->estimates()->delete();
             }
 
+            // There are no database foreign keys for payment allocations. Clear
+            // them before the bulk payment delete, then remove invoices so an
+            // allocation cannot outlive either side of the relationship.
+            if ($customer->payments()->exists()) {
+                PaymentAllocation::query()
+                    ->whereIn('payment_id', $customer->payments()->select('id'))
+                    ->delete();
+                $customer->payments()->delete();
+            }
+
             if ($customer->invoices()->exists()) {
                 $customer->invoices->map(function ($invoice) {
                     if ($invoice->transactions()->exists()) {
@@ -95,10 +106,6 @@ class CustomerService
                 });
             }
 
-            if ($customer->payments()->exists()) {
-                $customer->payments()->delete();
-            }
-
             if ($customer->addresses()->exists()) {
                 $customer->addresses()->delete();
             }
diff --git a/app/Services/CustomerStatementPdfService.php b/app/Services/CustomerStatementPdfService.php
new file mode 100644
index 00000000..b1dadad5
--- /dev/null
+++ b/app/Services/CustomerStatementPdfService.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Services;
+
+use App\Facades\Pdf;
+use App\Models\CompanySetting;
+use App\Support\Pdf\PdfPageSetup;
+use Illuminate\Support\Facades\App;
+
+class CustomerStatementPdfService
+{
+    public function render(array $statement)
+    {
+        $customer = $statement['customer'];
+        $company = $customer->company;
+
+        App::setLocale(CompanySetting::getSetting('language', $company->id));
+
+        view()->share([
+            'statement' => $statement,
+            'customer' => $customer,
+            'company' => $company,
+            'currency' => $statement['currency'],
+            'logo' => $company->logo_path,
+        ]);
+
+        return Pdf::loadView('app.pdf.reports.customer-statement', [], PdfPageSetup::forReports());
+    }
+}
diff --git a/app/Services/CustomerStatementService.php b/app/Services/CustomerStatementService.php
new file mode 100644
index 00000000..2fa0074d
--- /dev/null
+++ b/app/Services/CustomerStatementService.php
@@ -0,0 +1,363 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\Customer;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
+use Carbon\Carbon;
+use Illuminate\Pagination\LengthAwarePaginator;
+use Illuminate\Support\Collection;
+
+class CustomerStatementService
+{
+    public const TYPE_ACTIVITY = 'activity';
+
+    public const TYPE_OUTSTANDING = 'outstanding';
+
+    /**
+     * Build a live account statement in the customer's currency.
+     */
+    public function statement(Customer $customer, string $type, Carbon $from, Carbon $to, int $perPage = 50, int $page = 1): array
+    {
+        $customer->loadMissing(['company', 'currency']);
+
+        return $type === self::TYPE_OUTSTANDING
+            ? $this->outstandingStatement($customer, $to)
+            : $this->activityStatement($customer, $from, $to, $perPage, $page);
+    }
+
+    /**
+     * Add the account-summary fields expected by the customer API without
+     * persisting derived balances on customers.
+     */
+    public function hydrateAccountSummaries(iterable $customers): void
+    {
+        $customers = collect($customers)->values();
+
+        if ($customers->isEmpty()) {
+            return;
+        }
+
+        $customerIds = $customers->pluck('id')->all();
+        $invoiceTotals = Invoice::query()
+            ->whereIn('customer_id', $customerIds)
+            ->where('type', Invoice::TYPE_INVOICE)
+            ->where('status', '!=', Invoice::STATUS_DRAFT)
+            ->select('customer_id')
+            ->selectRaw('COALESCE(SUM(due_amount), 0) as invoice_due_amount')
+            ->selectRaw('COALESCE(SUM(base_due_amount), 0) as base_invoice_due_amount')
+            ->groupBy('customer_id')
+            ->get()
+            ->keyBy('customer_id');
+
+        $allocationTotals = PaymentAllocation::query()
+            ->select('payment_id')
+            ->selectRaw('COALESCE(SUM(amount), 0) as allocated_amount')
+            ->selectRaw('COALESCE(SUM(base_amount), 0) as base_allocated_amount')
+            ->groupBy('payment_id');
+
+        $paymentTotals = Payment::query()
+            ->whereIn('customer_id', $customerIds)
+            ->leftJoinSub($allocationTotals, 'allocation_totals', function ($join) {
+                $join->on('payments.id', '=', 'allocation_totals.payment_id');
+            })
+            ->select('payments.customer_id')
+            ->selectRaw('COALESCE(SUM(payments.amount), 0) as payment_amount')
+            ->selectRaw('COALESCE(SUM(payments.base_amount), 0) as base_payment_amount')
+            ->selectRaw('COALESCE(SUM(COALESCE(allocation_totals.allocated_amount, 0)), 0) as allocated_amount')
+            ->selectRaw('COALESCE(SUM(COALESCE(allocation_totals.base_allocated_amount, 0)), 0) as base_allocated_amount')
+            ->groupBy('payments.customer_id')
+            ->get()
+            ->keyBy('customer_id');
+
+        foreach ($customers as $customer) {
+            $invoice = $invoiceTotals->get($customer->id);
+            $payment = $paymentTotals->get($customer->id);
+
+            $invoiceDue = (int) ($invoice->invoice_due_amount ?? 0);
+            $baseInvoiceDue = (int) ($invoice->base_invoice_due_amount ?? 0);
+            $paymentTotal = (int) ($payment->payment_amount ?? 0);
+            $basePaymentTotal = (int) ($payment->base_payment_amount ?? 0);
+            $allocated = (int) ($payment->allocated_amount ?? 0);
+            $baseAllocated = (int) ($payment->base_allocated_amount ?? 0);
+
+            $credit = max(0, $paymentTotal - $allocated);
+            $baseCredit = max(0, $basePaymentTotal - $baseAllocated);
+
+            $customer->setAttribute('invoice_due_amount', $invoiceDue);
+            $customer->setAttribute('base_invoice_due_amount', $baseInvoiceDue);
+            $customer->setAttribute('available_credit', $credit);
+            $customer->setAttribute('base_available_credit', $baseCredit);
+            $customer->setAttribute('account_balance', $invoiceDue - $credit);
+            $customer->setAttribute('base_account_balance', $baseInvoiceDue - $baseCredit);
+
+            // Keep this long-standing response field meaningful for clients
+            // which have not yet adopted the richer account summary.
+            $customer->setAttribute('due_amount', $invoiceDue);
+            $customer->setAttribute('base_due_amount', $baseInvoiceDue);
+        }
+    }
+
+    public function accountSummary(Customer $customer): array
+    {
+        $this->hydrateAccountSummaries([$customer]);
+
+        return [
+            'invoice_due_amount' => (int) $customer->invoice_due_amount,
+            'base_invoice_due_amount' => (int) $customer->base_invoice_due_amount,
+            'available_credit' => (int) $customer->available_credit,
+            'base_available_credit' => (int) $customer->base_available_credit,
+            'account_balance' => (int) $customer->account_balance,
+            'base_account_balance' => (int) $customer->base_account_balance,
+        ];
+    }
+
+    private function activityStatement(Customer $customer, Carbon $from, Carbon $to, int $perPage, int $page): array
+    {
+        $openingBalance = $this->activityBalanceBefore($customer, $from);
+        $entries = collect();
+
+        $documents = $this->statementDocuments($customer)
+            ->whereBetween('invoice_date', [$from->toDateString(), $to->toDateString()])
+            ->get(['id', 'invoice_date', 'invoice_number', 'type', 'total', 'base_total']);
+
+        foreach ($documents as $document) {
+            $isCreditNote = $document->type === Invoice::TYPE_CREDIT_NOTE;
+            $entries->push([
+                'id' => $document->id,
+                'date' => Carbon::parse($document->invoice_date)->toDateString(),
+                'entry_type' => $isCreditNote ? 'credit_note' : 'invoice',
+                'reference' => $document->invoice_number,
+                'description' => $isCreditNote ? __('Credit note') : __('Invoice'),
+                'debit_amount' => $isCreditNote ? 0 : (int) $document->total,
+                'credit_amount' => $isCreditNote ? abs((int) $document->total) : 0,
+                'base_debit_amount' => $isCreditNote ? 0 : (int) $document->base_total,
+                'base_credit_amount' => $isCreditNote ? abs((int) $document->base_total) : 0,
+                'sort_order' => $isCreditNote ? 1 : 0,
+            ]);
+        }
+
+        $payments = Payment::query()
+            ->where('company_id', $customer->company_id)
+            ->where('customer_id', $customer->id)
+            ->whereBetween('payment_date', [$from->toDateString(), $to->toDateString()])
+            ->get(['id', 'payment_date', 'payment_number', 'amount', 'base_amount']);
+
+        foreach ($payments as $payment) {
+            $entries->push([
+                'id' => $payment->id,
+                'date' => Carbon::parse($payment->payment_date)->toDateString(),
+                'entry_type' => 'payment',
+                'reference' => $payment->payment_number,
+                'description' => __('Payment'),
+                'debit_amount' => 0,
+                'credit_amount' => (int) $payment->amount,
+                'base_debit_amount' => 0,
+                'base_credit_amount' => (int) $payment->base_amount,
+                'sort_order' => 2,
+            ]);
+        }
+
+        $entries = $entries
+            ->sort(fn (array $left, array $right) => [$left['date'], $left['sort_order'], $left['id']] <=> [$right['date'], $right['sort_order'], $right['id']])
+            ->values();
+
+        $runningBalance = $openingBalance['amount'];
+        $baseRunningBalance = $openingBalance['base_amount'];
+        $entries = $entries->map(function (array $entry) use (&$runningBalance, &$baseRunningBalance) {
+            $runningBalance += $entry['debit_amount'] - $entry['credit_amount'];
+            $baseRunningBalance += $entry['base_debit_amount'] - $entry['base_credit_amount'];
+            $entry['balance'] = $runningBalance;
+            $entry['base_balance'] = $baseRunningBalance;
+            unset($entry['sort_order']);
+
+            return $entry;
+        });
+
+        $paginator = new LengthAwarePaginator(
+            $entries->forPage($page, $perPage)->values(),
+            $entries->count(),
+            $perPage,
+            $page,
+            ['path' => request()->url(), 'query' => request()->query()]
+        );
+
+        return [
+            'type' => self::TYPE_ACTIVITY,
+            'customer' => $customer,
+            'currency' => $customer->currency,
+            'from_date' => $from->toDateString(),
+            'to_date' => $to->toDateString(),
+            'opening_balance' => $openingBalance['amount'],
+            'base_opening_balance' => $openingBalance['base_amount'],
+            'closing_balance' => $runningBalance,
+            'base_closing_balance' => $baseRunningBalance,
+            'entries' => $paginator,
+        ];
+    }
+
+    private function outstandingStatement(Customer $customer, Carbon $asOf): array
+    {
+        $invoices = Invoice::query()
+            ->where('company_id', $customer->company_id)
+            ->where('customer_id', $customer->id)
+            ->where('type', Invoice::TYPE_INVOICE)
+            ->where('status', '!=', Invoice::STATUS_DRAFT)
+            ->where('invoice_date', '<=', $asOf->toDateString())
+            ->withSum([
+                'creditNotes as credited_amount' => fn ($query) => $query->where('invoice_date', '<=', $asOf->toDateString()),
+            ], 'total')
+            ->withSum([
+                'creditNotes as base_credited_amount' => fn ($query) => $query->where('invoice_date', '<=', $asOf->toDateString()),
+            ], 'base_total')
+            ->orderBy('due_date')
+            ->orderBy('id')
+            ->get(['id', 'invoice_date', 'due_date', 'invoice_number', 'total', 'base_total']);
+
+        $invoiceAllocations = $this->allocationTotalsForInvoices($invoices->pluck('id'), $asOf);
+        $openInvoices = $invoices->map(function (Invoice $invoice) use ($invoiceAllocations) {
+            $allocation = $invoiceAllocations->get($invoice->id, ['amount' => 0, 'base_amount' => 0]);
+            $credit = max(0, -(int) ($invoice->credited_amount ?? 0));
+            $baseCredit = max(0, -(int) ($invoice->base_credited_amount ?? 0));
+            $remaining = max(0, (int) $invoice->total - $credit - $allocation['amount']);
+            $baseRemaining = max(0, (int) $invoice->base_total - $baseCredit - $allocation['base_amount']);
+
+            return [
+                'id' => $invoice->id,
+                'invoice_number' => $invoice->invoice_number,
+                'invoice_date' => Carbon::parse($invoice->invoice_date)->toDateString(),
+                'due_date' => $invoice->due_date ? Carbon::parse($invoice->due_date)->toDateString() : null,
+                'original_amount' => (int) $invoice->total,
+                'allocated_amount' => $allocation['amount'],
+                'credit_amount' => $credit,
+                'applied_amount' => $allocation['amount'] + $credit,
+                'remaining_amount' => $remaining,
+                'base_original_amount' => (int) $invoice->base_total,
+                'base_allocated_amount' => $allocation['base_amount'],
+                'base_credit_amount' => $baseCredit,
+                'base_applied_amount' => $allocation['base_amount'] + $baseCredit,
+                'base_remaining_amount' => $baseRemaining,
+            ];
+        })->filter(fn (array $invoice) => $invoice['remaining_amount'] > 0)->values();
+
+        $payments = Payment::query()
+            ->where('company_id', $customer->company_id)
+            ->where('customer_id', $customer->id)
+            ->where('payment_date', '<=', $asOf->toDateString())
+            ->orderBy('payment_date')
+            ->orderBy('id')
+            ->get(['id', 'payment_date', 'payment_number', 'amount', 'base_amount']);
+        $paymentAllocations = $this->allocationTotalsForPayments($payments->pluck('id'), $asOf);
+
+        $credits = $payments->map(function (Payment $payment) use ($paymentAllocations) {
+            $allocation = $paymentAllocations->get($payment->id, ['amount' => 0, 'base_amount' => 0]);
+            $available = max(0, (int) $payment->amount - $allocation['amount']);
+
+            return [
+                'id' => $payment->id,
+                'payment_number' => $payment->payment_number,
+                'payment_date' => Carbon::parse($payment->payment_date)->toDateString(),
+                'amount' => (int) $payment->amount,
+                'allocated_amount' => $allocation['amount'],
+                'available_amount' => $available,
+                'base_amount' => (int) $payment->base_amount,
+                'base_allocated_amount' => $allocation['base_amount'],
+                'base_available_amount' => max(0, (int) $payment->base_amount - $allocation['base_amount']),
+            ];
+        })->filter(fn (array $payment) => $payment['available_amount'] > 0)->values();
+
+        $invoiceDue = (int) $openInvoices->sum('remaining_amount');
+        $baseInvoiceDue = (int) $openInvoices->sum('base_remaining_amount');
+        $availableCredit = (int) $credits->sum('available_amount');
+        $baseAvailableCredit = (int) $credits->sum('base_available_amount');
+
+        return [
+            'type' => self::TYPE_OUTSTANDING,
+            'customer' => $customer,
+            'currency' => $customer->currency,
+            'as_of' => $asOf->toDateString(),
+            'invoices' => $openInvoices,
+            'credits' => $credits,
+            'invoice_due_amount' => $invoiceDue,
+            'base_invoice_due_amount' => $baseInvoiceDue,
+            'available_credit' => $availableCredit,
+            'base_available_credit' => $baseAvailableCredit,
+            'account_balance' => $invoiceDue - $availableCredit,
+            'base_account_balance' => $baseInvoiceDue - $baseAvailableCredit,
+        ];
+    }
+
+    private function activityBalanceBefore(Customer $customer, Carbon $from): array
+    {
+        $documents = $this->statementDocuments($customer)
+            ->where('invoice_date', '<', $from->toDateString());
+        $payments = Payment::query()
+            ->where('company_id', $customer->company_id)
+            ->where('customer_id', $customer->id)
+            ->where('payment_date', '<', $from->toDateString());
+
+        return [
+            'amount' => (int) $documents->sum('total') - (int) $payments->sum('amount'),
+            'base_amount' => (int) $documents->sum('base_total') - (int) $payments->sum('base_amount'),
+        ];
+    }
+
+    private function statementDocuments(Customer $customer)
+    {
+        return Invoice::query()
+            ->where('company_id', $customer->company_id)
+            ->where('customer_id', $customer->id)
+            ->where(function ($query) {
+                $query->where('type', Invoice::TYPE_CREDIT_NOTE)
+                    ->orWhere(function ($query) {
+                        $query->where('type', Invoice::TYPE_INVOICE)
+                            ->where('status', '!=', Invoice::STATUS_DRAFT);
+                    });
+            });
+    }
+
+    private function allocationTotalsForInvoices(Collection $invoiceIds, Carbon $asOf): Collection
+    {
+        if ($invoiceIds->isEmpty()) {
+            return collect();
+        }
+
+        return PaymentAllocation::query()
+            ->join('payments', 'payments.id', '=', 'payment_allocations.payment_id')
+            ->whereIn('payment_allocations.invoice_id', $invoiceIds)
+            ->where('payments.payment_date', '<=', $asOf->toDateString())
+            ->where('payment_allocations.created_at', '<=', $asOf->copy()->endOfDay())
+            ->selectRaw('payment_allocations.invoice_id, SUM(payment_allocations.amount) as amount, SUM(payment_allocations.base_amount) as base_amount')
+            ->groupBy('payment_allocations.invoice_id')
+            ->get()
+            ->mapWithKeys(fn (PaymentAllocation $allocation) => [$allocation->invoice_id => [
+                'amount' => (int) $allocation->amount,
+                'base_amount' => (int) $allocation->base_amount,
+            ]]);
+    }
+
+    private function allocationTotalsForPayments(Collection $paymentIds, ?Carbon $asOf = null): Collection
+    {
+        if ($paymentIds->isEmpty()) {
+            return collect();
+        }
+
+        $query = PaymentAllocation::query()
+            ->whereIn('payment_id', $paymentIds)
+            ->selectRaw('payment_id, SUM(amount) as amount, SUM(base_amount) as base_amount')
+            ->groupBy('payment_id');
+
+        if ($asOf) {
+            $query->where('created_at', '<=', $asOf->copy()->endOfDay());
+        }
+
+        return $query
+            ->get()
+            ->mapWithKeys(fn (PaymentAllocation $allocation) => [$allocation->payment_id => [
+                'amount' => (int) $allocation->amount,
+                'base_amount' => (int) $allocation->base_amount,
+            ]]);
+    }
+}
diff --git a/app/Services/Document/CreditNoteService.php b/app/Services/Document/CreditNoteService.php
index 28129a59..80cbdce2 100644
--- a/app/Services/Document/CreditNoteService.php
+++ b/app/Services/Document/CreditNoteService.php
@@ -33,6 +33,7 @@ class CreditNoteService
 {
     public function __construct(
         private readonly DocumentItemService $documentItemService,
+        private readonly InvoiceBalanceService $invoiceBalanceService,
     ) {}
 
     /**
@@ -63,7 +64,7 @@ class CreditNoteService
             $before = $this->creditedQuantities($original);
             $after = $this->targetQuantities($invoiced, $before, $items);
 
-            $paid = (int) $original->payments()->sum('amount');
+            $paid = (int) $original->allocations()->sum('amount');
             $creditedBefore = $this->creditedTotal($original);
 
             $this->guard($original, $invoiced, $before, $after, $paid, $creditedBefore);
@@ -118,43 +119,9 @@ class CreditNoteService
         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();
+        $this->invoiceBalanceService->recalculate($invoice);
     }
 
     /**
diff --git a/app/Services/Document/InvoiceBalanceService.php b/app/Services/Document/InvoiceBalanceService.php
new file mode 100644
index 00000000..edb46918
--- /dev/null
+++ b/app/Services/Document/InvoiceBalanceService.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Services\Document;
+
+use App\Models\Invoice;
+
+class InvoiceBalanceService
+{
+    public function allocatedTotal(Invoice $invoice): int
+    {
+        return (int) $invoice->allocations()->sum('amount');
+    }
+
+    public function creditedTotal(Invoice $invoice): int
+    {
+        return -(int) $invoice->creditNotes()->sum('total');
+    }
+
+    /**
+     * Recalculate an invoice exclusively from durable credits and payment
+     * allocations. Callers that change allocations must hold the invoice lock.
+     */
+    public function recalculate(Invoice $invoice): void
+    {
+        $allocated = $this->allocatedTotal($invoice);
+        $credited = $this->creditedTotal($invoice);
+        $due = max(0, (int) $invoice->total - $allocated - $credited);
+
+        $invoice->due_amount = $due;
+        $invoice->base_due_amount = (int) round($due * $invoice->exchange_rate);
+
+        if ($due === 0) {
+            $invoice->status = Invoice::STATUS_COMPLETED;
+            $invoice->paid_status = Invoice::STATUS_PAID;
+            $invoice->overdue = false;
+        } else {
+            $invoice->status = $invoice->getPreviousStatus();
+            $invoice->paid_status = $allocated > 0
+                ? Invoice::STATUS_PARTIALLY_PAID
+                : Invoice::STATUS_UNPAID;
+        }
+
+        $invoice->save();
+    }
+}
diff --git a/app/Services/Document/InvoiceService.php b/app/Services/Document/InvoiceService.php
index f140166e..925ce9e0 100644
--- a/app/Services/Document/InvoiceService.php
+++ b/app/Services/Document/InvoiceService.php
@@ -171,6 +171,12 @@ class InvoiceService
         foreach ($ids as $id) {
             $invoice = Invoice::find($id);
 
+            if ($invoice->allocations()->exists()) {
+                throw ValidationException::withMessages([
+                    'invoice' => ['invoice_has_payment_allocations'],
+                ]);
+            }
+
             if ($invoice->transactions()->exists()) {
                 $invoice->transactions()->delete();
             }
@@ -477,7 +483,7 @@ class InvoiceService
             $invoice->sent = true;
             $invoice->save();
         } elseif ($status == Invoice::STATUS_COMPLETED) {
-            $paid = (int) $invoice->payments()->sum('amount');
+            $paid = (int) $invoice->allocations()->sum('amount');
             $credited = $this->creditNoteService->creditedTotal($invoice);
             $outstanding = max(0, (int) $invoice->total - $paid - $credited);
 
diff --git a/app/Services/Document/PaymentAllocationService.php b/app/Services/Document/PaymentAllocationService.php
new file mode 100644
index 00000000..d879a98d
--- /dev/null
+++ b/app/Services/Document/PaymentAllocationService.php
@@ -0,0 +1,328 @@
+<?php
+
+namespace App\Services\Document;
+
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
+
+class PaymentAllocationService
+{
+    public function __construct(
+        private readonly InvoiceBalanceService $invoiceBalanceService,
+    ) {}
+
+    /**
+     * Replace the complete allocation set for a payment. Empty allocations are
+     * valid and represent unapplied customer credit.
+     */
+    public function replace(Payment $payment, array $allocations): Payment
+    {
+        return DB::transaction(function () use ($payment, $allocations): Payment {
+            $lockedPayment = Payment::query()
+                ->whereKey($payment->getKey())
+                ->lockForUpdate()
+                ->firstOrFail();
+
+            $this->replaceLocked($lockedPayment, $allocations);
+
+            return $lockedPayment;
+        });
+    }
+
+    /**
+     * Atomically apply existing unapplied credit to one or more invoices. The
+     * supplied rows are additive: existing allocations remain in place.
+     */
+    public function applyCustomerCredits(int $companyId, int $customerId, array $allocations): void
+    {
+        DB::transaction(function () use ($companyId, $customerId, $allocations): void {
+            $this->assertCreditRows($allocations);
+
+            $paymentIds = collect($allocations)->pluck('payment_id')->map(fn ($id) => (int) $id)->unique()->sort()->values();
+            $invoiceIds = collect($allocations)->pluck('invoice_id')->map(fn ($id) => (int) $id)->unique()->sort()->values();
+
+            $payments = Payment::query()
+                ->whereIn('id', $paymentIds)
+                ->where('company_id', $companyId)
+                ->where('customer_id', $customerId)
+                ->orderBy('id')
+                ->lockForUpdate()
+                ->get()
+                ->keyBy('id');
+
+            if ($payments->count() !== $paymentIds->count()) {
+                throw ValidationException::withMessages([
+                    'allocations' => ['payment_allocation_payment_not_found'],
+                ]);
+            }
+
+            $existingInvoiceIds = PaymentAllocation::query()
+                ->whereIn('payment_id', $paymentIds)
+                ->pluck('invoice_id');
+            $allInvoiceIds = $existingInvoiceIds->concat($invoiceIds)->unique()->sort()->values();
+
+            // Lock every invoice before changing any allocation. This is the
+            // same lock order used by replaceLocked(), avoiding overspending
+            // the balance when two credits target the same invoice.
+            Invoice::query()
+                ->whereIn('id', $allInvoiceIds)
+                ->orderBy('id')
+                ->lockForUpdate()
+                ->get();
+
+            foreach ($payments as $payment) {
+                $existing = $payment->allocations()
+                    ->get(['invoice_id', 'amount'])
+                    ->map(fn (PaymentAllocation $allocation) => [
+                        'invoice_id' => (int) $allocation->invoice_id,
+                        'amount' => (int) $allocation->amount,
+                    ]);
+                $extra = collect($allocations)
+                    ->where('payment_id', $payment->id)
+                    ->map(fn (array $allocation) => [
+                        'invoice_id' => (int) $allocation['invoice_id'],
+                        'amount' => (int) $allocation['amount'],
+                    ]);
+
+                $target = $existing->concat($extra)
+                    ->groupBy('invoice_id')
+                    ->map(fn (Collection $rows, $invoiceId) => [
+                        'invoice_id' => (int) $invoiceId,
+                        'amount' => $rows->sum('amount'),
+                    ])
+                    ->values()
+                    ->all();
+
+                $this->replaceLocked($payment, $target, true);
+            }
+        });
+    }
+
+    private function replaceLocked(Payment $payment, array $allocations, bool $invoicesAlreadyLocked = false): void
+    {
+        $allocations = $this->normaliseAllocations($allocations);
+        $this->assertAllocationTotal($payment, $allocations);
+
+        $oldInvoiceIds = $payment->allocations()->pluck('invoice_id');
+        $invoiceIds = collect($allocations)->pluck('invoice_id')->unique()->sort()->values();
+        $affectedIds = $oldInvoiceIds->concat($invoiceIds)->unique()->sort()->values();
+
+        // Old and new invoice rows share one sorted lock set. Clearing or
+        // moving an allocation changes an old invoice's available balance just
+        // as much as allocating to a new invoice does.
+        $invoices = $affectedIds->isEmpty()
+            ? collect()
+            : Invoice::query()
+                ->whereIn('id', $affectedIds)
+                ->orderBy('id')
+                ->when(! $invoicesAlreadyLocked, fn ($query) => $query->lockForUpdate())
+                ->get()
+                ->keyBy('id');
+
+        if ($invoices->whereIn('id', $invoiceIds)->count() !== $invoiceIds->count()) {
+            throw ValidationException::withMessages([
+                'allocations' => ['payment_allocation_invoice_not_found'],
+            ]);
+        }
+
+        foreach ($allocations as $allocation) {
+            $invoice = $invoices->get($allocation['invoice_id']);
+            $this->assertInvoiceCanReceiveAllocation($payment, $invoice, $allocation['amount']);
+        }
+
+        $payment->allocations()->delete();
+
+        foreach ($this->baseAmounts($payment, $allocations) as $allocation) {
+            $payment->allocations()->create($allocation);
+        }
+
+        foreach ($invoices as $invoice) {
+            $this->invoiceBalanceService->recalculate($invoice);
+        }
+    }
+
+    private function normaliseAllocations(array $allocations): array
+    {
+        $invoiceIds = collect($allocations)->pluck('invoice_id');
+
+        if ($invoiceIds->count() !== $invoiceIds->unique()->count()) {
+            throw ValidationException::withMessages([
+                'allocations' => ['payment_allocation_duplicate_invoice'],
+            ]);
+        }
+
+        $normalised = collect($allocations)
+            ->map(function (array $allocation): array {
+                if (! array_key_exists('invoice_id', $allocation) || ! array_key_exists('amount', $allocation)) {
+                    throw ValidationException::withMessages([
+                        'allocations' => ['payment_allocation_invalid'],
+                    ]);
+                }
+
+                if (! $this->isInteger($allocation['invoice_id']) || ! $this->isInteger($allocation['amount'])) {
+                    throw ValidationException::withMessages([
+                        'allocations' => ['payment_allocation_invalid'],
+                    ]);
+                }
+
+                return [
+                    'invoice_id' => (int) $allocation['invoice_id'],
+                    'amount' => (int) $allocation['amount'],
+                ];
+            })
+            ->sortBy('invoice_id')
+            ->values()
+            ->all();
+
+        foreach ($normalised as $allocation) {
+            if ($allocation['invoice_id'] < 1 || $allocation['amount'] < 1) {
+                throw ValidationException::withMessages([
+                    'allocations' => ['payment_allocation_invalid'],
+                ]);
+            }
+        }
+
+        return $normalised;
+    }
+
+    private function assertAllocationTotal(Payment $payment, array $allocations): void
+    {
+        if ((int) $payment->amount < 1) {
+            throw ValidationException::withMessages([
+                'amount' => ['payment_amount_must_be_positive'],
+            ]);
+        }
+
+        if (collect($allocations)->sum('amount') > (int) $payment->amount) {
+            throw ValidationException::withMessages([
+                'allocations' => ['payment_allocation_exceeds_payment_amount'],
+            ]);
+        }
+    }
+
+    private function assertInvoiceCanReceiveAllocation(Payment $payment, Invoice $invoice, int $amount): void
+    {
+        if (
+            (int) $invoice->company_id !== (int) $payment->company_id
+            || (int) $invoice->customer_id !== (int) $payment->customer_id
+            || (int) $invoice->currency_id !== (int) $payment->currency_id
+        ) {
+            throw ValidationException::withMessages([
+                'allocations' => ['payment_allocation_invoice_mismatch'],
+            ]);
+        }
+
+        if ($invoice->type !== Invoice::TYPE_INVOICE || $invoice->status === Invoice::STATUS_DRAFT) {
+            throw ValidationException::withMessages([
+                'allocations' => ['payment_allocation_invoice_not_payable'],
+            ]);
+        }
+
+        $allocatedByOtherPayments = (int) PaymentAllocation::query()
+            ->where('invoice_id', $invoice->id)
+            ->where('payment_id', '!=', $payment->id)
+            ->sum('amount');
+        $available = max(0, (int) $invoice->total - $this->invoiceBalanceService->creditedTotal($invoice) - $allocatedByOtherPayments);
+
+        if ($amount > $available) {
+            throw ValidationException::withMessages([
+                'allocations' => ['payment_allocation_exceeds_invoice_balance'],
+            ]);
+        }
+    }
+
+    private function baseAmounts(Payment $payment, array $allocations): array
+    {
+        $paymentAmount = (int) $payment->amount;
+        $paymentBaseAmount = $payment->base_amount === null
+            ? (int) round($paymentAmount * ((float) $payment->exchange_rate ?: 1))
+            : (int) $payment->base_amount;
+        $allocatedAmount = (int) collect($allocations)->sum('amount');
+        $allocatedBaseAmount = 0;
+
+        return collect($allocations)->values()->map(function (array $allocation, int $index) use ($paymentAmount, $paymentBaseAmount, $allocatedAmount, &$allocatedBaseAmount, $allocations): array {
+            $isLastFullyAllocatedRow = $allocatedAmount === $paymentAmount && $index === count($allocations) - 1;
+            $baseAmount = $isLastFullyAllocatedRow
+                ? $paymentBaseAmount - $allocatedBaseAmount
+                : $this->proportionalAmount($paymentBaseAmount, $allocation['amount'], $paymentAmount);
+
+            $allocatedBaseAmount += $baseAmount;
+
+            return [
+                'invoice_id' => $allocation['invoice_id'],
+                'amount' => $allocation['amount'],
+                'base_amount' => $baseAmount,
+            ];
+        })->all();
+    }
+
+    private function assertCreditRows(array $allocations): void
+    {
+        if ($allocations === []) {
+            throw ValidationException::withMessages([
+                'allocations' => ['payment_allocation_required'],
+            ]);
+        }
+
+        foreach ($allocations as $allocation) {
+            if (
+                ! isset($allocation['payment_id'], $allocation['invoice_id'], $allocation['amount'])
+                || ! $this->isInteger($allocation['payment_id'])
+                || ! $this->isInteger($allocation['invoice_id'])
+                || ! $this->isInteger($allocation['amount'])
+                || (int) $allocation['payment_id'] < 1
+                || (int) $allocation['invoice_id'] < 1
+                || (int) $allocation['amount'] < 1
+            ) {
+                throw ValidationException::withMessages([
+                    'allocations' => ['payment_allocation_invalid'],
+                ]);
+            }
+        }
+    }
+
+    private function isInteger(mixed $value): bool
+    {
+        return filter_var($value, FILTER_VALIDATE_INT) !== false;
+    }
+
+    /**
+     * Calculate floor(baseAmount * allocationAmount / paymentAmount) without
+     * overflowing an intermediate product. Every intermediate stays below the
+     * payment amount except the bounded final result.
+     */
+    private function proportionalAmount(int $baseAmount, int $allocationAmount, int $paymentAmount): int
+    {
+        $whole = intdiv($baseAmount, $paymentAmount) * $allocationAmount;
+        $remainder = $baseAmount % $paymentAmount;
+        $quotient = 0;
+        $modulo = 0;
+        $factor = $remainder;
+        $multiplier = $allocationAmount;
+
+        while ($multiplier > 0) {
+            if ($multiplier % 2 === 1) {
+                if ($modulo >= $paymentAmount - $factor) {
+                    $quotient++;
+                    $modulo -= $paymentAmount - $factor;
+                } else {
+                    $modulo += $factor;
+                }
+            }
+
+            if ($factor >= $paymentAmount - $factor) {
+                $factor -= $paymentAmount - $factor;
+            } else {
+                $factor += $factor;
+            }
+
+            $multiplier = intdiv($multiplier, 2);
+        }
+
+        return $whole + $quotient;
+    }
+}
diff --git a/app/Services/Document/PaymentService.php b/app/Services/Document/PaymentService.php
index c32fdb01..6feff4e8 100644
--- a/app/Services/Document/PaymentService.php
+++ b/app/Services/Document/PaymentService.php
@@ -16,129 +16,118 @@ use App\Support\Pdf\PdfTemplateUtils;
 use Carbon\Carbon;
 use Illuminate\Http\Request;
 use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
 
 class PaymentService
 {
+    public function __construct(
+        private readonly PaymentAllocationService $paymentAllocationService,
+    ) {}
+
     public function create(Request $request): Payment
     {
         $data = $request->getPaymentPayload();
+        $allocations = $request->validated('allocations') ?? [];
 
-        if ($request->invoice_id) {
-            $invoice = Invoice::find($request->invoice_id);
-            $invoice->subtractInvoicePayment($request->amount);
-        }
+        $payment = DB::transaction(function () use ($data, $allocations, $request): Payment {
+            $payment = Payment::create($data);
+            $payment->unique_hash = Hashids::connection(Payment::class)->encode($payment->id);
 
-        $payment = Payment::create($data);
-        $payment->unique_hash = Hashids::connection(Payment::class)->encode($payment->id);
+            $serial = (new SerialNumberService)
+                ->setModel($payment)
+                ->setCompany($payment->company_id)
+                ->setCustomer($payment->customer_id)
+                ->setNextNumbers();
 
-        $serial = (new SerialNumberService)
-            ->setModel($payment)
-            ->setCompany($payment->company_id)
-            ->setCustomer($payment->customer_id)
-            ->setNextNumbers();
+            $payment->sequence_number = $serial->nextSequenceNumber;
+            $payment->customer_sequence_number = $serial->nextCustomerSequenceNumber;
+            $payment->save();
 
-        $payment->sequence_number = $serial->nextSequenceNumber;
-        $payment->customer_sequence_number = $serial->nextCustomerSequenceNumber;
-        $payment->save();
+            $this->paymentAllocationService->replace($payment, $allocations);
 
-        $companyCurrency = CompanySetting::getSetting('currency', $request->header('company'));
+            $companyCurrency = CompanySetting::getSetting('currency', $request->header('company'));
 
-        if ((string) $payment['currency_id'] !== $companyCurrency) {
-            ExchangeRateLog::addExchangeRateLog($payment);
-        }
+            if ((string) $payment->currency_id !== $companyCurrency) {
+                ExchangeRateLog::addExchangeRateLog($payment);
+            }
 
-        $customFields = $request->customFields;
+            if ($request->customFields) {
+                $payment->addCustomFields($request->customFields);
+            }
 
-        if ($customFields) {
-            $payment->addCustomFields($customFields);
-        }
+            return $payment;
+        });
 
-        return Payment::with([
-            'customer',
-            'invoice',
-            'paymentMethod',
-            'fields',
-        ])->find($payment->id);
+        return $this->loadPayment($payment);
     }
 
     public function update(Payment $payment, Request $request): Payment
     {
         $data = $request->getPaymentPayload();
+        $replaceAllocations = $request->exists('allocations');
+        $requestedAllocations = $request->validated('allocations') ?? [];
 
-        if ($request->invoice_id && (! $payment->invoice_id || $payment->invoice_id !== $request->invoice_id)) {
-            $invoice = Invoice::find($request->invoice_id);
-            $invoice->subtractInvoicePayment($request->amount);
-        }
+        $payment = DB::transaction(function () use ($payment, $data, $replaceAllocations, $requestedAllocations, $request): Payment {
+            $lockedPayment = Payment::query()->whereKey($payment->id)->lockForUpdate()->firstOrFail();
+            $allocations = $replaceAllocations
+                ? $requestedAllocations
+                : $lockedPayment->allocations()
+                    ->get(['invoice_id', 'amount'])
+                    ->map(fn ($allocation) => [
+                        'invoice_id' => (int) $allocation->invoice_id,
+                        'amount' => (int) $allocation->amount,
+                    ])
+                    ->all();
+            $customerChanged = (int) $lockedPayment->customer_id !== (int) $data['customer_id'];
 
-        if ($payment->invoice_id && (! $request->invoice_id || $payment->invoice_id !== $request->invoice_id)) {
-            $invoice = Invoice::find($payment->invoice_id);
-            $invoice->addInvoicePayment($payment->amount);
-        }
+            if ($customerChanged && $allocations !== []) {
+                throw ValidationException::withMessages([
+                    'customer_id' => ['payment_customer_change_requires_unallocated_credit'],
+                ]);
+            }
 
-        if ($payment->invoice_id && $payment->invoice_id === $request->invoice_id && $request->amount !== $payment->amount) {
-            $invoice = Invoice::find($payment->invoice_id);
-            $invoice->addInvoicePayment($payment->amount);
-            $invoice->subtractInvoicePayment($request->amount);
-        }
+            $serial = (new SerialNumberService)
+                ->setModel($lockedPayment)
+                ->setCompany($lockedPayment->company_id)
+                ->setCustomer($data['customer_id'])
+                ->setModelObject($lockedPayment->id)
+                ->setNextNumbers();
 
-        $serial = (new SerialNumberService)
-            ->setModel($payment)
-            ->setCompany($payment->company_id)
-            ->setCustomer($request->customer_id)
-            ->setModelObject($payment->id)
-            ->setNextNumbers();
+            $data['customer_sequence_number'] = $serial->nextCustomerSequenceNumber;
+            $lockedPayment->update($data);
+            $this->paymentAllocationService->replace($lockedPayment, $allocations);
 
-        $data['customer_sequence_number'] = $serial->nextCustomerSequenceNumber;
-        $payment->update($data);
+            $companyCurrency = CompanySetting::getSetting('currency', $request->header('company'));
 
-        $companyCurrency = CompanySetting::getSetting('currency', $request->header('company'));
+            if ((string) $lockedPayment->currency_id !== $companyCurrency) {
+                ExchangeRateLog::addExchangeRateLog($lockedPayment);
+            }
 
-        if ((string) $data['currency_id'] !== $companyCurrency) {
-            ExchangeRateLog::addExchangeRateLog($payment);
-        }
+            if ($request->customFields) {
+                $lockedPayment->updateCustomFields($request->customFields);
+            }
 
-        $customFields = $request->customFields;
+            return $lockedPayment;
+        });
 
-        if ($customFields) {
-            $payment->updateCustomFields($customFields);
-        }
-
-        return Payment::with([
-            'customer',
-            'invoice',
-            'paymentMethod',
-        ])->find($payment->id);
+        return $this->loadPayment($payment);
     }
 
     public function delete(Collection $ids): bool
     {
-        foreach ($ids as $id) {
-            $payment = Payment::find($id);
+        DB::transaction(function () use ($ids): void {
+            foreach ($ids->sort() as $id) {
+                $payment = Payment::query()->whereKey($id)->lockForUpdate()->first();
 
-            if ($payment->invoice_id != null) {
-                $invoice = Invoice::find($payment->invoice_id);
-                $invoice->due_amount = ((int) $invoice->due_amount + (int) $payment->amount);
+                if (! $payment) {
+                    continue;
+                }
 
-                // 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();
+                $this->paymentAllocationService->replace($payment, []);
+                $payment->delete();
             }
-
-            $payment->delete();
-        }
+        });
 
         return true;
     }
@@ -176,6 +165,8 @@ class PaymentService
 
     public function getPdfData(Payment $payment)
     {
+        $payment->loadMissing('allocations.invoice.currency');
+
         $company = Company::find($payment->company_id);
         $locale = CompanySetting::getSetting('language', $company->id);
 
@@ -216,24 +207,38 @@ class PaymentService
 
         $data['payment_number'] = $serial->getNextNumber();
         $data['payment_date'] = Carbon::now();
-        $data['amount'] = $invoice->total;
-        $data['invoice_id'] = $invoice->id;
+        $data['amount'] = $invoice->due_amount;
         $data['payment_method_id'] = request()->payment_method_id;
         $data['customer_id'] = $invoice->customer_id;
         $data['exchange_rate'] = $invoice->exchange_rate;
-        $data['base_amount'] = $data['amount'] * $data['exchange_rate'];
+        $data['base_amount'] = (int) round($data['amount'] * $data['exchange_rate']);
         $data['currency_id'] = $invoice->currency_id;
         $data['company_id'] = $invoice->company_id;
         $data['transaction_id'] = $transaction->id;
 
-        $payment = Payment::create($data);
-        $payment->unique_hash = Hashids::connection(Payment::class)->encode($payment->id);
-        $payment->sequence_number = $serial->nextSequenceNumber;
-        $payment->customer_sequence_number = $serial->nextCustomerSequenceNumber;
-        $payment->save();
+        return DB::transaction(function () use ($data, $serial, $invoice): Payment {
+            $payment = Payment::create($data);
+            $payment->unique_hash = Hashids::connection(Payment::class)->encode($payment->id);
+            $payment->sequence_number = $serial->nextSequenceNumber;
+            $payment->customer_sequence_number = $serial->nextCustomerSequenceNumber;
+            $payment->save();
 
-        $invoice->subtractInvoicePayment($invoice->total);
+            $this->paymentAllocationService->replace($payment, [[
+                'invoice_id' => $invoice->id,
+                'amount' => (int) $data['amount'],
+            ]]);
 
-        return $payment;
+            return $payment;
+        });
+    }
+
+    private function loadPayment(Payment $payment): Payment
+    {
+        return Payment::with([
+            'customer',
+            'allocations.invoice',
+            'paymentMethod',
+            'fields',
+        ])->findOrFail($payment->id);
     }
 }
diff --git a/database/factories/PaymentAllocationFactory.php b/database/factories/PaymentAllocationFactory.php
new file mode 100644
index 00000000..dfe258c2
--- /dev/null
+++ b/database/factories/PaymentAllocationFactory.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<PaymentAllocation>
+ */
+class PaymentAllocationFactory extends Factory
+{
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            'payment_id' => Payment::factory(),
+            'invoice_id' => Invoice::factory(),
+            'amount' => $this->faker->numberBetween(1, 10000),
+            'base_amount' => $this->faker->numberBetween(1, 10000),
+        ];
+    }
+}
diff --git a/database/migrations/2026_08_02_230400_replace_payment_invoice_with_allocations.php b/database/migrations/2026_08_02_230400_replace_payment_invoice_with_allocations.php
new file mode 100644
index 00000000..c14d9c61
--- /dev/null
+++ b/database/migrations/2026_08_02_230400_replace_payment_invoice_with_allocations.php
@@ -0,0 +1,340 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        if (! Schema::hasTable('payment_allocations')) {
+            Schema::create('payment_allocations', function (Blueprint $table) {
+                $table->bigIncrements('id');
+                $table->unsignedBigInteger('payment_id')->index();
+                $table->unsignedInteger('invoice_id')->index();
+                $table->unsignedBigInteger('amount');
+                $table->unsignedBigInteger('base_amount');
+                $table->timestamps();
+
+                $table->unique(['payment_id', 'invoice_id']);
+            });
+        }
+
+        // A fresh install replays the historical payments migration before
+        // reaching this migration. Existing v2/v3 databases arrive here with
+        // the same nullable legacy column; a retry after a partial run does
+        // not, and must not attempt the conversion again.
+        if (! Schema::hasColumn('payments', 'invoice_id')) {
+            $this->verifyLegacyAllocations();
+
+            return;
+        }
+
+        DB::transaction(function (): void {
+            $this->backfillLegacyAllocations();
+            $this->verifyLegacyAllocations();
+            $this->recalculateAffectedInvoices();
+        });
+
+        try {
+            Schema::table('payments', function (Blueprint $table) {
+                $table->dropForeign(['invoice_id']);
+            });
+        } catch (Throwable) {
+            // SQLite and manually upgraded databases may not carry the old
+            // constraint. The column can still be removed below.
+        }
+
+        try {
+            Schema::table('payments', function (Blueprint $table) {
+                $table->dropIndex(['invoice_id']);
+            });
+        } catch (Throwable) {
+            // SQLite keeps the legacy index and requires explicit removal;
+            // MySQL can remove it together with its foreign key.
+        }
+
+        Schema::table('payments', function (Blueprint $table) {
+            $table->dropColumn('invoice_id');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        if (! Schema::hasTable('payment_allocations')) {
+            return;
+        }
+
+        if (DB::table('payment_allocations')
+            ->select('payment_id')
+            ->groupBy('payment_id')
+            ->havingRaw('COUNT(*) > 1')
+            ->exists()) {
+            throw new RuntimeException('Cannot roll back payment allocations after a payment was allocated to multiple invoices.');
+        }
+
+        $hasPartialAllocation = DB::table('payment_allocations')
+            ->join('payments', 'payments.id', '=', 'payment_allocations.payment_id')
+            ->whereColumn('payment_allocations.amount', '!=', 'payments.amount')
+            ->exists();
+
+        if ($hasPartialAllocation) {
+            throw new RuntimeException('Cannot roll back payment allocations with unapplied customer credit.');
+        }
+
+        if (! Schema::hasColumn('payments', 'invoice_id')) {
+            Schema::table('payments', function (Blueprint $table) {
+                $table->unsignedInteger('invoice_id')->nullable()->index();
+            });
+        }
+
+        DB::table('payment_allocations')->orderBy('id')->each(function (object $allocation): void {
+            DB::table('payments')
+                ->where('id', $allocation->payment_id)
+                ->update(['invoice_id' => $allocation->invoice_id]);
+        });
+
+        Schema::dropIfExists('payment_allocations');
+    }
+
+    private function backfillLegacyAllocations(): void
+    {
+        DB::table('payments')
+            ->whereNotNull('invoice_id')
+            ->orderBy('invoice_id')
+            ->orderBy('payment_date')
+            ->orderBy('id')
+            ->each(function (object $payment): void {
+                // A rerun after the allocation insert but before the legacy
+                // column disappears leaves the already migrated payment alone.
+                if (DB::table('payment_allocations')->where('payment_id', $payment->id)->exists()) {
+                    return;
+                }
+
+                $invoice = DB::table('invoices')->where('id', $payment->invoice_id)->first();
+
+                if (! $this->isValidLegacyLink($payment, $invoice)) {
+                    Log::warning('Payment legacy invoice link was retained as unapplied customer credit.', [
+                        'payment_id' => $payment->id,
+                        'invoice_id' => $payment->invoice_id,
+                    ]);
+
+                    return;
+                }
+
+                $allocated = (int) DB::table('payment_allocations')
+                    ->where('invoice_id', $invoice->id)
+                    ->sum('amount');
+                $credited = $this->creditedTotal($invoice->id);
+                $remaining = max(0, (int) $invoice->total - $credited - $allocated);
+                $amount = min((int) $payment->amount, $remaining);
+
+                if ($amount === 0) {
+                    return;
+                }
+
+                DB::table('payment_allocations')->insert([
+                    'payment_id' => $payment->id,
+                    'invoice_id' => $invoice->id,
+                    'amount' => $amount,
+                    'base_amount' => $this->allocatedBaseAmount($payment, $amount),
+                    // The legacy relationship existed at payment time; using
+                    // its date preserves historical as-of statement balances
+                    // instead of making every old allocation appear today.
+                    'created_at' => $payment->payment_date,
+                    'updated_at' => $payment->payment_date,
+                ]);
+            });
+    }
+
+    private function isValidLegacyLink(object $payment, ?object $invoice): bool
+    {
+        return $invoice
+            && (int) $payment->company_id === (int) $invoice->company_id
+            && (int) $payment->customer_id === (int) $invoice->customer_id
+            && (int) $payment->currency_id === (int) $invoice->currency_id
+            && ($invoice->type ?? 'INVOICE') === 'INVOICE'
+            && $invoice->status !== 'DRAFT';
+    }
+
+    private function allocatedBaseAmount(object $payment, int $amount): int
+    {
+        $paymentAmount = (int) $payment->amount;
+
+        if ($paymentAmount === 0) {
+            return 0;
+        }
+
+        $baseAmount = $payment->base_amount === null
+            ? (int) round($paymentAmount * ((float) $payment->exchange_rate ?: 1))
+            : (int) $payment->base_amount;
+
+        return $this->proportionalAmount($baseAmount, $amount, $paymentAmount);
+    }
+
+    private function verifyLegacyAllocations(): void
+    {
+        $orphanedPayment = DB::table('payment_allocations')
+            ->leftJoin('payments', 'payments.id', '=', 'payment_allocations.payment_id')
+            ->whereNull('payments.id')
+            ->first();
+
+        if ($orphanedPayment) {
+            throw new RuntimeException('Payment allocation migration verification failed: allocation payment is missing.');
+        }
+
+        $overAllocatedPayment = DB::table('payment_allocations')
+            ->join('payments', 'payments.id', '=', 'payment_allocations.payment_id')
+            ->select('payments.id')
+            ->groupBy('payments.id', 'payments.amount')
+            ->havingRaw('SUM(payment_allocations.amount) > payments.amount')
+            ->first();
+
+        if ($overAllocatedPayment) {
+            throw new RuntimeException('Payment allocation migration verification failed: an allocation exceeds its payment.');
+        }
+
+        $overAllocatedBasePayment = DB::table('payment_allocations')
+            ->join('payments', 'payments.id', '=', 'payment_allocations.payment_id')
+            ->select('payments.id', 'payments.amount', 'payments.base_amount', 'payments.exchange_rate')
+            ->groupBy('payments.id', 'payments.amount', 'payments.base_amount', 'payments.exchange_rate')
+            ->selectRaw('SUM(payment_allocations.base_amount) as allocated_base_amount')
+            ->get()
+            ->first(function (object $payment): bool {
+                $baseAmount = $payment->base_amount === null
+                    ? (int) round((int) $payment->amount * ((float) $payment->exchange_rate ?: 1))
+                    : (int) $payment->base_amount;
+
+                return (int) $payment->allocated_base_amount > $baseAmount;
+            });
+
+        if ($overAllocatedBasePayment) {
+            throw new RuntimeException('Payment allocation migration verification failed: allocation base amount exceeds its payment.');
+        }
+
+        $invalidOwnership = DB::table('payment_allocations')
+            ->join('payments', 'payments.id', '=', 'payment_allocations.payment_id')
+            ->join('invoices', 'invoices.id', '=', 'payment_allocations.invoice_id')
+            ->where(function ($query): void {
+                $query->whereColumn('payments.company_id', '!=', 'invoices.company_id')
+                    ->orWhereColumn('payments.customer_id', '!=', 'invoices.customer_id')
+                    ->orWhereColumn('payments.currency_id', '!=', 'invoices.currency_id');
+            })
+            ->first();
+
+        if ($invalidOwnership) {
+            throw new RuntimeException('Payment allocation migration verification failed: allocation ownership mismatch.');
+        }
+
+        $invalidTarget = DB::table('payment_allocations')
+            ->leftJoin('invoices', 'invoices.id', '=', 'payment_allocations.invoice_id')
+            ->where(function ($query): void {
+                $query->whereNull('invoices.id')
+                    ->orWhere('payment_allocations.amount', '<=', 0)
+                    ->orWhere('payment_allocations.base_amount', '<', 0)
+                    ->orWhere('invoices.type', '!=', 'INVOICE')
+                    ->orWhere('invoices.status', 'DRAFT');
+            })
+            ->first();
+
+        if ($invalidTarget) {
+            throw new RuntimeException('Payment allocation migration verification failed: allocation target is not payable.');
+        }
+
+        DB::table('payment_allocations')
+            ->select('invoice_id')
+            ->groupBy('invoice_id')
+            ->orderBy('invoice_id')
+            ->each(function (object $allocation): void {
+                $invoice = DB::table('invoices')->where('id', $allocation->invoice_id)->first();
+                $allocated = (int) DB::table('payment_allocations')->where('invoice_id', $invoice->id)->sum('amount');
+
+                if ($allocated > max(0, (int) $invoice->total - $this->creditedTotal($invoice->id))) {
+                    throw new RuntimeException('Payment allocation migration verification failed: allocation exceeds invoice balance.');
+                }
+            });
+    }
+
+    private function recalculateAffectedInvoices(): void
+    {
+        // Include all legacy targets, not only allocations that survived the
+        // conversion. An invalid link or excess legacy payment may previously
+        // have driven a target invoice's stored balance below its true balance.
+        DB::table('invoices')
+            ->where('type', 'INVOICE')
+            ->whereIn('id', function ($query): void {
+                $query->select('invoice_id')->from('payments')->whereNotNull('invoice_id');
+            })
+            ->orderBy('id')
+            ->each(function (object $invoice): void {
+                $paid = (int) DB::table('payment_allocations')->where('invoice_id', $invoice->id)->sum('amount');
+                $due = max(0, (int) $invoice->total - $this->creditedTotal($invoice->id) - $paid);
+
+                DB::table('invoices')->where('id', $invoice->id)->update([
+                    'due_amount' => $due,
+                    'base_due_amount' => (int) round($due * (float) $invoice->exchange_rate),
+                    'status' => $due === 0
+                        ? 'COMPLETED'
+                        : ((bool) $invoice->viewed ? 'VIEWED' : ((bool) $invoice->sent ? 'SENT' : 'DRAFT')),
+                    'paid_status' => $due === 0 ? 'PAID' : ($paid > 0 ? 'PARTIALLY_PAID' : 'UNPAID'),
+                ]);
+            });
+    }
+
+    private function creditedTotal(int $invoiceId): int
+    {
+        if (! Schema::hasColumn('invoices', 'related_invoice_id')) {
+            return 0;
+        }
+
+        return -(int) DB::table('invoices')
+            ->where('related_invoice_id', $invoiceId)
+            ->where('type', 'CREDIT_NOTE')
+            ->sum('total');
+    }
+
+    /**
+     * Calculate floor(baseAmount * allocationAmount / paymentAmount) without
+     * multiplying two arbitrary BIGINT values. The long-division remainder
+     * loop keeps every intermediate value below paymentAmount.
+     */
+    private function proportionalAmount(int $baseAmount, int $allocationAmount, int $paymentAmount): int
+    {
+        $whole = intdiv($baseAmount, $paymentAmount) * $allocationAmount;
+        $remainder = $baseAmount % $paymentAmount;
+        $quotient = 0;
+        $modulo = 0;
+        $factor = $remainder;
+        $multiplier = $allocationAmount;
+
+        while ($multiplier > 0) {
+            if ($multiplier % 2 === 1) {
+                if ($modulo >= $paymentAmount - $factor) {
+                    $quotient++;
+                    $modulo -= $paymentAmount - $factor;
+                } else {
+                    $modulo += $factor;
+                }
+            }
+
+            if ($factor >= $paymentAmount - $factor) {
+                $factor -= $paymentAmount - $factor;
+            } else {
+                $factor += $factor;
+            }
+
+            $multiplier = intdiv($multiplier, 2);
+        }
+
+        return $whole + $quotient;
+    }
+};
diff --git a/database/seeders/RealisticDemoSeeder.php b/database/seeders/RealisticDemoSeeder.php
index 1c0d8064..fc793663 100644
--- a/database/seeders/RealisticDemoSeeder.php
+++ b/database/seeders/RealisticDemoSeeder.php
@@ -3,6 +3,7 @@
 namespace Database\Seeders;
 
 use App\Facades\Hashids;
+use App\Jobs\GeneratePaymentPdfJob;
 use App\Models\Address;
 use App\Models\AiConversation;
 use App\Models\Company;
@@ -20,12 +21,14 @@ use App\Models\InvoiceItem;
 use App\Models\Item;
 use App\Models\Note;
 use App\Models\Payment;
+use App\Models\PaymentAllocation;
 use App\Models\PaymentMethod;
 use App\Models\RecurringInvoice;
 use App\Models\Tax;
 use App\Models\TaxType;
 use App\Models\Unit;
 use App\Models\User;
+use App\Services\Document\PaymentAllocationService;
 use App\Services\Document\SerialNumberService;
 use Carbon\Carbon;
 use Illuminate\Database\Seeder;
@@ -238,7 +241,9 @@ class RealisticDemoSeeder extends Seeder
     private function cleanupExistingDemoData(): void
     {
         AiConversation::where('company_id', $this->companyId)->delete(); // cascades to ai_messages
-        Payment::where('company_id', $this->companyId)->delete();
+        $paymentIds = Payment::where('company_id', $this->companyId)->pluck('id');
+        PaymentAllocation::whereIn('payment_id', $paymentIds)->delete();
+        Payment::whereIn('id', $paymentIds)->delete();
         InvoiceItem::where('company_id', $this->companyId)->delete();
         Invoice::where('company_id', $this->companyId)->delete();
         EstimateItem::where('company_id', $this->companyId)->delete();
@@ -376,45 +381,53 @@ class RealisticDemoSeeder extends Seeder
      */
     private function seedInvoicesWithPayments(): void
     {
-        // Distribution plan: [count, status, paid_status, overdue, age_weeks_min, age_weeks_max]
+        // Distribution plan: [count, status, paid_status, overdue, age_weeks_min, age_weeks_max, current_month]
         //
         // Split by time bucket so get_company_stats(period=this_month/last_month/this_quarter) differ.
         $plan = [
-            // This month (0-4 weeks ago) — fresh activity
-            [3, Invoice::STATUS_SENT,      Invoice::STATUS_UNPAID,         false, 0, 3],
-            [2, Invoice::STATUS_VIEWED,    Invoice::STATUS_UNPAID,         false, 0, 4],
-            [2, Invoice::STATUS_DRAFT,     Invoice::STATUS_UNPAID,         false, 0, 2],
-            [3, Invoice::STATUS_COMPLETED, Invoice::STATUS_PAID,           false, 0, 4],
-            [1, Invoice::STATUS_COMPLETED, Invoice::STATUS_PARTIALLY_PAID, false, 0, 4],
+            // Current calendar month — each customer receives posted activity
+            // so its default Account Activity statement is useful immediately.
+            [3, Invoice::STATUS_SENT,      Invoice::STATUS_UNPAID,         false, 0, 3, true],
+            [2, Invoice::STATUS_VIEWED,    Invoice::STATUS_UNPAID,         false, 0, 4, true],
+            [2, Invoice::STATUS_DRAFT,     Invoice::STATUS_UNPAID,         false, 0, 2, true],
+            [3, Invoice::STATUS_COMPLETED, Invoice::STATUS_PAID,           false, 0, 4, true],
+            [1, Invoice::STATUS_COMPLETED, Invoice::STATUS_PARTIALLY_PAID, false, 0, 4, true],
             // Last month (4-8 weeks ago)
-            [2, Invoice::STATUS_VIEWED,    Invoice::STATUS_UNPAID,         false, 4, 8],
-            [1, Invoice::STATUS_DRAFT,     Invoice::STATUS_UNPAID,         false, 4, 8],
-            [2, Invoice::STATUS_SENT,      Invoice::STATUS_UNPAID,         true,  5, 8],  // overdue
-            [3, Invoice::STATUS_COMPLETED, Invoice::STATUS_PAID,           false, 4, 8],
-            [2, Invoice::STATUS_COMPLETED, Invoice::STATUS_PARTIALLY_PAID, false, 4, 8],
+            [2, Invoice::STATUS_VIEWED,    Invoice::STATUS_UNPAID,         false, 4, 8, false],
+            [1, Invoice::STATUS_DRAFT,     Invoice::STATUS_UNPAID,         false, 4, 8, false],
+            [2, Invoice::STATUS_SENT,      Invoice::STATUS_UNPAID,         true,  5, 8, false],  // overdue
+            [3, Invoice::STATUS_COMPLETED, Invoice::STATUS_PAID,           false, 4, 8, false],
+            [2, Invoice::STATUS_COMPLETED, Invoice::STATUS_PARTIALLY_PAID, false, 4, 8, false],
             // 2-3 months ago
-            [2, Invoice::STATUS_SENT,      Invoice::STATUS_UNPAID,         true,  10, 13], // overdue
-            [3, Invoice::STATUS_COMPLETED, Invoice::STATUS_PAID,           false, 8, 13],
-            [2, Invoice::STATUS_COMPLETED, Invoice::STATUS_PARTIALLY_PAID, false, 9, 13],
-            [1, Invoice::STATUS_VIEWED,    Invoice::STATUS_UNPAID,         false, 10, 13],
+            [2, Invoice::STATUS_SENT,      Invoice::STATUS_UNPAID,         true,  10, 13, false], // overdue
+            [3, Invoice::STATUS_COMPLETED, Invoice::STATUS_PAID,           false, 8, 13, false],
+            [2, Invoice::STATUS_COMPLETED, Invoice::STATUS_PARTIALLY_PAID, false, 9, 13, false],
+            [1, Invoice::STATUS_VIEWED,    Invoice::STATUS_UNPAID,         false, 10, 13, false],
             // 4-6 months ago (older)
-            [2, Invoice::STATUS_COMPLETED, Invoice::STATUS_PAID,           false, 16, 24],
-            [1, Invoice::STATUS_COMPLETED, Invoice::STATUS_PARTIALLY_PAID, false, 16, 22],
-            [1, Invoice::STATUS_VIEWED,    Invoice::STATUS_UNPAID,         false, 18, 24],
-            [1, Invoice::STATUS_SENT,      Invoice::STATUS_UNPAID,         false, 18, 24],
-            [1, Invoice::STATUS_DRAFT,     Invoice::STATUS_UNPAID,         false, 20, 26],
+            [2, Invoice::STATUS_COMPLETED, Invoice::STATUS_PAID,           false, 16, 24, false],
+            [1, Invoice::STATUS_COMPLETED, Invoice::STATUS_PARTIALLY_PAID, false, 16, 22, false],
+            [1, Invoice::STATUS_VIEWED,    Invoice::STATUS_UNPAID,         false, 18, 24, false],
+            [1, Invoice::STATUS_SENT,      Invoice::STATUS_UNPAID,         false, 18, 24, false],
+            [1, Invoice::STATUS_DRAFT,     Invoice::STATUS_UNPAID,         false, 20, 26, false],
         ];
 
-        foreach ($plan as [$count, $status, $paidStatus, $overdue, $minWeeks, $maxWeeks]) {
+        $activityCustomerIndex = 0;
+
+        foreach ($plan as [$count, $status, $paidStatus, $overdue, $minWeeks, $maxWeeks, $currentMonth]) {
             for ($i = 0; $i < $count; $i++) {
-                $weeksAgo = random_int($minWeeks, $maxWeeks);
-                $invoiceDate = Carbon::now()->subWeeks($weeksAgo)->subDays(random_int(0, 6))->startOfDay();
+                $invoiceDate = $currentMonth
+                    ? Carbon::now()->startOfMonth()->addDays(random_int(0, Carbon::now()->day - 1))->startOfDay()
+                    : Carbon::now()->subWeeks(random_int($minWeeks, $maxWeeks))->subDays(random_int(0, 6))->startOfDay();
                 $dueDate = $overdue
                     ? Carbon::now()->subDays(random_int(3, 45))->startOfDay()
                     : $invoiceDate->copy()->addDays(30);
 
                 $itemCount = random_int(1, 4);
-                $this->createInvoice($invoiceDate, $dueDate, $status, $paidStatus, $itemCount, $overdue);
+                $customer = $currentMonth && $status !== Invoice::STATUS_DRAFT
+                    ? $this->customers[$activityCustomerIndex++ % count($this->customers)]
+                    : null;
+
+                $this->createInvoice($invoiceDate, $dueDate, $status, $paidStatus, $itemCount, $overdue, $customer);
             }
         }
     }
@@ -426,8 +439,9 @@ class RealisticDemoSeeder extends Seeder
         string $paidStatus,
         int $itemCount,
         bool $overdue,
+        ?Customer $customer = null,
     ): void {
-        $customer = $this->customers[array_rand($this->customers)];
+        $customer ??= $this->customers[array_rand($this->customers)];
         $selectedItems = collect($this->items)->random($itemCount)->all();
 
         // Compute totals from the selected line items
@@ -445,17 +459,15 @@ class RealisticDemoSeeder extends Seeder
         }
 
         // Tax is computed once off the subtotal, not per line, and then has to be
-        // carried through total, due_amount and every base_* twin. Miss due_amount
-        // and a fully paid invoice renders as part-paid.
+        // carried through total and every base_* twin.
         $taxType = $this->taxTypeForDocument($this->invoiceSequence);
         $taxAmount = $taxType ? (int) round($subTotal * $taxType->percent / 100) : 0;
 
         $total = $subTotal + $taxAmount;
-        $dueAmount = match ($paidStatus) {
-            Invoice::STATUS_PAID => 0,
-            Invoice::STATUS_PARTIALLY_PAID => (int) round($total * 0.6),  // 40% paid, 60% still due
-            default => $total,
-        };
+        // PaymentAllocationService is the source of truth for paid balances.
+        // Start with the full balance, then let it reduce the amount after each
+        // seeded payment is allocated.
+        $dueAmount = $total;
 
         $invoiceNumber = 'INV-'.str_pad((string) $this->invoiceSequence, 6, '0', STR_PAD_LEFT);
         $this->invoiceSequence++;
@@ -541,12 +553,13 @@ class RealisticDemoSeeder extends Seeder
             $this->applyDocumentTax($invoice, $taxType, $taxAmount, 'invoice_id');
         }
 
-        // Back-fill payments for PAID and PARTIALLY_PAID invoices.
+        // Back-fill payments for PAID and PARTIALLY_PAID invoices. Allocation
+        // recalculation updates their stored balance and paid status.
         if ($paidStatus === Invoice::STATUS_PAID) {
             $this->createPayment($invoice, $total, $invoiceDate->copy()->addDays(random_int(3, 25)));
         } elseif ($paidStatus === Invoice::STATUS_PARTIALLY_PAID) {
             // 40% of the total, in one payment
-            $partialAmount = $total - $dueAmount;
+            $partialAmount = (int) round($total * 0.4);
             $this->createPayment($invoice, $partialAmount, $invoiceDate->copy()->addDays(random_int(5, 20)));
         }
     }
@@ -562,7 +575,7 @@ class RealisticDemoSeeder extends Seeder
             $paymentDate = Carbon::now()->subDays(random_int(1, 7));
         }
 
-        $payment = Payment::create([
+        $payment = Payment::withoutEvents(fn () => Payment::create([
             'payment_number' => $paymentNumber,
             'payment_date' => $paymentDate->toDateString(),
             'amount' => $amount,
@@ -570,13 +583,12 @@ class RealisticDemoSeeder extends Seeder
             'exchange_rate' => 1,
             'user_id' => $this->user->id,
             'creator_id' => $this->user->id,
-            'invoice_id' => $invoice->id,
             'customer_id' => $invoice->customer_id,
             'payment_method_id' => $this->paymentMethodId,
             'currency_id' => $this->currencyId,
             'company_id' => $this->companyId,
             'notes' => null,
-        ]);
+        ]));
 
         // See seedInvoice(): the PDF routes bind on unique_hash.
         $serial = (new SerialNumberService)
@@ -590,7 +602,14 @@ class RealisticDemoSeeder extends Seeder
         $payment->unique_hash = Hashids::connection(Payment::class)->encode($payment->id);
         $payment->created_at = $paymentDate;
         $payment->updated_at = $paymentDate;
-        $payment->save();
+        Payment::withoutEvents(fn () => $payment->save());
+
+        app(PaymentAllocationService::class)->replace($payment, [[
+            'invoice_id' => $invoice->id,
+            'amount' => $amount,
+        ]]);
+
+        GeneratePaymentPdfJob::dispatch($payment);
     }
 
     private function seedEstimates(): void
diff --git a/lang/en.json b/lang/en.json
index e457173e..63e67baa 100644
--- a/lang/en.json
+++ b/lang/en.json
@@ -39,6 +39,9 @@
     "update": "Update",
     "deselect": "Deselect",
     "download": "Download",
+    "refresh": "Refresh",
+    "loading": "Loading…",
+    "date": "Date",
     "from_date": "From Date",
     "to_date": "To Date",
     "from": "From",
@@ -276,7 +279,33 @@
     "updated_message": "Customer updated successfully",
     "address_updated_message": "Address Information Updated succesfully",
     "deleted_message": "Customer deleted successfully | Customers deleted successfully",
-    "edit_currency_not_allowed": "Cannot change currency once transactions created."
+    "edit_currency_not_allowed": "Cannot change currency once transactions created.",
+    "statement_type": "Statement Type",
+    "from_date": "From Date",
+    "to_date": "To Date",
+    "as_of": "As Of",
+    "download_statement": "Download Statement",
+    "send_statement": "Send Statement",
+    "invoice_due": "Invoice Due",
+    "available_credit": "Available Credit",
+    "net_account_balance": "Net Account Balance",
+    "credit": "Credit",
+    "account_activity": "Account Activity",
+    "outstanding_items": "Outstanding Items",
+    "opening_balance": "Opening Balance",
+    "activity": "Activity",
+    "debit": "Debit",
+    "balance": "Balance",
+    "original_amount": "Original Amount",
+    "applied": "Applied",
+    "remaining": "Remaining",
+    "no_statement_activity": "No account activity in this period.",
+    "no_outstanding_invoices": "No outstanding invoices.",
+    "apply_credit": "Apply Credit",
+    "apply_credit_description": "Choose the available payment credit and invoices to settle. Amounts are only applied when you confirm.",
+    "statement_sent": "Statement sent successfully",
+    "credit_applied": "Customer credit applied successfully",
+    "statement_email_body": "Please find your account statement attached."
   },
   "items": {
     "title": "Items",
@@ -346,6 +375,7 @@
     "send_estimate": "Send Estimate",
     "resend_estimate": "Resend Estimate",
     "record_payment": "Record Payment",
+    "allocated_payments": "Allocated Payments",
     "add_estimate": "Add Estimate",
     "save_estimate": "Save Estimate",
     "cloned_successfully": "Estimate cloned successfully",
@@ -692,7 +722,17 @@
     "updated_message": "Payment updated successfully",
     "deleted_message": "Payment deleted successfully | Payments deleted successfully",
     "invalid_amount_message": "Payment amount is invalid",
-    "amount_due": "Due Amount"
+    "amount_due": "Due Amount",
+    "allocations": "Invoice Allocations",
+    "allocations_description": "Apply this payment to one or more open invoices. Any amount left over remains customer credit.",
+    "allocate_oldest_first": "Allocate Oldest First",
+    "add_allocation": "Add Allocation",
+    "select_customer_to_allocate": "Select a customer before allocating this payment.",
+    "no_allocations": "No invoices selected. This payment will remain available as customer credit.",
+    "allocated": "Allocated",
+    "unapplied_credit": "Unapplied Credit",
+    "remove_allocation": "Remove allocation",
+    "allocation_exceeds_amount": "Invoice allocations cannot exceed the payment amount."
   },
   "expenses": {
     "title": "Expenses",
@@ -1856,6 +1896,16 @@
     "credit_note_cannot_be_converted_to_estimate": "A credit note cannot be converted to an estimate.",
     "invoice_must_be_settled_before_completion": "Record a payment or create a credit note before completing this invoice.",
     "payment_amount_exceeds_invoice_due_amount": "The payment is more than the invoice's outstanding balance.",
+    "payment_allocation_required": "Add at least one invoice allocation.",
+    "payment_allocation_invalid": "Enter a valid invoice and amount for every allocation.",
+    "payment_allocation_duplicate_invoice": "Each invoice can only appear once in a payment.",
+    "payment_allocation_exceeds_payment_amount": "Invoice allocations cannot exceed the payment amount.",
+    "payment_allocation_payment_not_found": "One of the selected payments is no longer available.",
+    "payment_allocation_invoice_not_found": "One of the selected invoices is no longer available.",
+    "payment_allocation_invoice_mismatch": "Payments can only be applied to invoices for the same customer and currency.",
+    "payment_allocation_invoice_not_payable": "Payments can only be applied to sent, unpaid invoices.",
+    "payment_allocation_exceeds_invoice_balance": "An allocation is more than the invoice's outstanding balance.",
+    "payment_customer_change_requires_unallocated_credit": "Remove all invoice allocations before changing this payment's customer.",
     "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.",
diff --git a/public/openapi.json b/public/openapi.json
index 1450a7b3..3ca9ee5d 100644
--- a/public/openapi.json
+++ b/public/openapi.json
@@ -3822,6 +3822,76 @@
                 }
             }
         },
+        "/customers/{customer}/credit-allocations": {
+            "post": {
+                "operationId": "creditAllocations.store",
+                "tags": [
+                    "CreditAllocations"
+                ],
+                "parameters": [
+                    {
+                        "name": "customer",
+                        "in": "path",
+                        "required": true,
+                        "description": "The customer ID",
+                        "schema": {
+                            "type": "integer"
+                        }
+                    },
+                    {
+                        "name": "company",
+                        "in": "header",
+                        "required": true,
+                        "description": "ID of the company the request operates on (multi-tenancy).",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ],
+                "requestBody": {
+                    "required": true,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "$ref": "#/components/schemas/CreditAllocationRequest"
+                            }
+                        }
+                    }
+                },
+                "responses": {
+                    "200": {
+                        "description": "",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {
+                                        "success": {
+                                            "type": "boolean"
+                                        }
+                                    },
+                                    "required": [
+                                        "success"
+                                    ]
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "$ref": "#/components/responses/AuthorizationException"
+                    },
+                    "404": {
+                        "$ref": "#/components/responses/ModelNotFoundException"
+                    },
+                    "401": {
+                        "$ref": "#/components/responses/AuthenticationException"
+                    },
+                    "422": {
+                        "$ref": "#/components/responses/ValidationException"
+                    }
+                }
+            }
+        },
         "/currencies": {
             "get": {
                 "operationId": "admin.currencies",
@@ -4156,6 +4226,134 @@
                 }
             }
         },
+        "/customers/{customer}/statement": {
+            "get": {
+                "operationId": "customer.customerStatement",
+                "tags": [
+                    "CustomerStatement"
+                ],
+                "parameters": [
+                    {
+                        "name": "customer",
+                        "in": "path",
+                        "required": true,
+                        "description": "The customer ID",
+                        "schema": {
+                            "type": "integer"
+                        }
+                    },
+                    {
+                        "name": "type",
+                        "in": "query",
+                        "required": true,
+                        "schema": {
+                            "type": "string",
+                            "enum": [
+                                "activity",
+                                "outstanding"
+                            ]
+                        }
+                    },
+                    {
+                        "name": "from_date",
+                        "in": "query",
+                        "schema": {
+                            "type": [
+                                "string",
+                                "null"
+                            ],
+                            "format": "date"
+                        }
+                    },
+                    {
+                        "name": "to_date",
+                        "in": "query",
+                        "schema": {
+                            "type": [
+                                "string",
+                                "null"
+                            ],
+                            "format": "date"
+                        }
+                    },
+                    {
+                        "name": "as_of",
+                        "in": "query",
+                        "schema": {
+                            "type": [
+                                "string",
+                                "null"
+                            ],
+                            "format": "date"
+                        }
+                    },
+                    {
+                        "name": "per_page",
+                        "in": "query",
+                        "schema": {
+                            "type": [
+                                "integer",
+                                "null"
+                            ],
+                            "minimum": 1,
+                            "maximum": 100
+                        }
+                    },
+                    {
+                        "name": "page",
+                        "in": "query",
+                        "schema": {
+                            "type": [
+                                "integer",
+                                "null"
+                            ],
+                            "minimum": 1
+                        }
+                    },
+                    {
+                        "name": "company",
+                        "in": "header",
+                        "required": true,
+                        "description": "ID of the company the request operates on (multi-tenancy).",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "`CustomerStatementResource`",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {
+                                        "data": {
+                                            "$ref": "#/components/schemas/CustomerStatementResource"
+                                        }
+                                    },
+                                    "required": [
+                                        "data"
+                                    ]
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "$ref": "#/components/responses/AuthorizationException"
+                    },
+                    "404": {
+                        "$ref": "#/components/responses/ModelNotFoundException"
+                    },
+                    "401": {
+                        "$ref": "#/components/responses/AuthenticationException"
+                    },
+                    "422": {
+                        "$ref": "#/components/responses/ValidationException"
+                    }
+                }
+            }
+        },
         "/customers/{customer}/stats": {
             "get": {
                 "operationId": "customer.customerStats",
@@ -4858,8 +5056,7 @@
                                             "type": "object",
                                             "properties": {
                                                 "database_connection": {
-                                                    "type": "string",
-                                                    "const": "mysql"
+                                                    "type": "string"
                                                 },
                                                 "database_host": {
                                                     "type": "string",
@@ -16504,6 +16701,75 @@
                 }
             }
         },
+        "/invoices/{invoice}/credit-note": {
+            "post": {
+                "operationId": "invoices.createCreditNote",
+                "tags": [
+                    "Invoices"
+                ],
+                "parameters": [
+                    {
+                        "name": "invoice",
+                        "in": "path",
+                        "required": true,
+                        "description": "The invoice ID",
+                        "schema": {
+                            "type": "integer"
+                        }
+                    },
+                    {
+                        "name": "company",
+                        "in": "header",
+                        "required": true,
+                        "description": "ID of the company the request operates on (multi-tenancy).",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ],
+                "requestBody": {
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "$ref": "#/components/schemas/CreateCreditNoteRequest"
+                            }
+                        }
+                    }
+                },
+                "responses": {
+                    "201": {
+                        "description": "`CreditNoteResource`",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {
+                                        "data": {
+                                            "$ref": "#/components/schemas/CreditNoteResource"
+                                        }
+                                    },
+                                    "required": [
+                                        "data"
+                                    ]
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "$ref": "#/components/responses/AuthorizationException"
+                    },
+                    "422": {
+                        "$ref": "#/components/responses/ValidationException"
+                    },
+                    "404": {
+                        "$ref": "#/components/responses/ModelNotFoundException"
+                    },
+                    "401": {
+                        "$ref": "#/components/responses/AuthenticationException"
+                    }
+                }
+            }
+        },
         "/invoices/{invoice}/status": {
             "post": {
                 "operationId": "invoices.changeStatus",
@@ -16530,6 +16796,16 @@
                         }
                     }
                 ],
+                "requestBody": {
+                    "required": true,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "$ref": "#/components/schemas/ChangeInvoiceStatusRequest"
+                            }
+                        }
+                    }
+                },
                 "responses": {
                     "200": {
                         "description": "",
@@ -16557,6 +16833,9 @@
                     },
                     "401": {
                         "$ref": "#/components/responses/AuthenticationException"
+                    },
+                    "422": {
+                        "$ref": "#/components/responses/ValidationException"
                     }
                 }
             }
@@ -16776,19 +17055,11 @@
                 ],
                 "responses": {
                     "200": {
-                        "description": "`InvoiceResource`",
+                        "description": "",
                         "content": {
                             "application/json": {
                                 "schema": {
-                                    "type": "object",
-                                    "properties": {
-                                        "data": {
-                                            "$ref": "#/components/schemas/InvoiceResource"
-                                        }
-                                    },
-                                    "required": [
-                                        "data"
-                                    ]
+                                    "type": "object"
                                 }
                             }
                         }
@@ -16900,6 +17171,7 @@
                                             "properties": {
                                                 "invoiceTotalCount": {
                                                     "type": "integer",
+                                                    "description": "Issued invoices only: a credit note is a reversal document,\nnot another invoice the customer received.",
                                                     "minimum": 0
                                                 }
                                             },
@@ -19432,27 +19704,7 @@
                         "content": {
                             "application/json": {
                                 "schema": {
-                                    "type": "object",
-                                    "properties": {
-                                        "pdf_driver": {
-                                            "type": "string"
-                                        },
-                                        "gotenberg_host": {
-                                            "type": "string"
-                                        },
-                                        "gotenberg_margins": {
-                                            "type": "string"
-                                        },
-                                        "gotenberg_papersize": {
-                                            "type": "string"
-                                        }
-                                    },
-                                    "required": [
-                                        "pdf_driver",
-                                        "gotenberg_host",
-                                        "gotenberg_margins",
-                                        "gotenberg_papersize"
-                                    ]
+                                    "type": "string"
                                 }
                             }
                         }
@@ -19976,6 +20228,76 @@
                 }
             }
         },
+        "/payments/{payment}/allocations": {
+            "put": {
+                "operationId": "payments.replaceAllocations",
+                "tags": [
+                    "Payments"
+                ],
+                "parameters": [
+                    {
+                        "name": "payment",
+                        "in": "path",
+                        "required": true,
+                        "description": "The payment ID",
+                        "schema": {
+                            "type": "integer"
+                        }
+                    },
+                    {
+                        "name": "company",
+                        "in": "header",
+                        "required": true,
+                        "description": "ID of the company the request operates on (multi-tenancy).",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ],
+                "requestBody": {
+                    "required": true,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "$ref": "#/components/schemas/ReplacePaymentAllocationsRequest"
+                            }
+                        }
+                    }
+                },
+                "responses": {
+                    "200": {
+                        "description": "`PaymentResource`",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {
+                                        "data": {
+                                            "$ref": "#/components/schemas/PaymentResource"
+                                        }
+                                    },
+                                    "required": [
+                                        "data"
+                                    ]
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "$ref": "#/components/responses/AuthorizationException"
+                    },
+                    "404": {
+                        "$ref": "#/components/responses/ModelNotFoundException"
+                    },
+                    "401": {
+                        "$ref": "#/components/responses/AuthenticationException"
+                    },
+                    "422": {
+                        "$ref": "#/components/responses/ValidationException"
+                    }
+                }
+            }
+        },
         "/payments/delete": {
             "post": {
                 "operationId": "payments.delete",
@@ -21701,6 +22023,76 @@
                 }
             }
         },
+        "/customers/{customer}/statement/send": {
+            "post": {
+                "operationId": "customer.sendCustomerStatement",
+                "tags": [
+                    "SendCustomerStatement"
+                ],
+                "parameters": [
+                    {
+                        "name": "customer",
+                        "in": "path",
+                        "required": true,
+                        "description": "The customer ID",
+                        "schema": {
+                            "type": "integer"
+                        }
+                    },
+                    {
+                        "name": "company",
+                        "in": "header",
+                        "required": true,
+                        "description": "ID of the company the request operates on (multi-tenancy).",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ],
+                "requestBody": {
+                    "required": true,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "$ref": "#/components/schemas/SendCustomerStatementRequest"
+                            }
+                        }
+                    }
+                },
+                "responses": {
+                    "200": {
+                        "description": "",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {
+                                        "success": {
+                                            "type": "boolean"
+                                        }
+                                    },
+                                    "required": [
+                                        "success"
+                                    ]
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "$ref": "#/components/responses/AuthorizationException"
+                    },
+                    "422": {
+                        "$ref": "#/components/responses/ValidationException"
+                    },
+                    "404": {
+                        "$ref": "#/components/responses/ModelNotFoundException"
+                    },
+                    "401": {
+                        "$ref": "#/components/responses/AuthenticationException"
+                    }
+                }
+            }
+        },
         "/next-number": {
             "get": {
                 "operationId": "serialNumber.nextNumber",
@@ -25518,12 +25910,6 @@
                             "null"
                         ]
                     },
-                    "invoice_id": {
-                        "type": [
-                            "integer",
-                            "null"
-                        ]
-                    },
                     "company_id": {
                         "type": [
                             "integer",
@@ -25549,10 +25935,56 @@
                         ]
                     },
                     "base_amount": {
-                        "type": [
-                            "integer",
-                            "null"
-                        ]
+                        "type": "integer"
+                    },
+                    "allocations": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "integer"
+                                },
+                                "invoice_id": {
+                                    "type": "integer"
+                                },
+                                "amount": {
+                                    "type": "integer"
+                                },
+                                "base_amount": {
+                                    "type": "integer"
+                                },
+                                "invoice": {
+                                    "anyOf": [
+                                        {
+                                            "$ref": "#/components/schemas/App.Http.Resources.Customer.InvoiceResource"
+                                        },
+                                        {
+                                            "type": "null"
+                                        }
+                                    ]
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "invoice_id",
+                                "amount",
+                                "base_amount",
+                                "invoice"
+                            ]
+                        }
+                    },
+                    "allocated_amount": {
+                        "type": "integer"
+                    },
+                    "unallocated_amount": {
+                        "type": "integer"
+                    },
+                    "base_allocated_amount": {
+                        "type": "integer"
+                    },
+                    "base_unallocated_amount": {
+                        "type": "integer"
                     },
                     "currency_id": {
                         "type": [
@@ -25578,9 +26010,6 @@
                     "customer": {
                         "$ref": "#/components/schemas/App.Http.Resources.Customer.CustomerResource"
                     },
-                    "invoice": {
-                        "$ref": "#/components/schemas/App.Http.Resources.Customer.InvoiceResource"
-                    },
                     "payment_method": {
                         "$ref": "#/components/schemas/App.Http.Resources.Customer.PaymentMethodResource"
                     },
@@ -25607,12 +26036,16 @@
                     "notes",
                     "amount",
                     "unique_hash",
-                    "invoice_id",
                     "company_id",
                     "payment_method_id",
                     "customer_id",
                     "exchange_rate",
                     "base_amount",
+                    "allocations",
+                    "allocated_amount",
+                    "unallocated_amount",
+                    "base_allocated_amount",
+                    "base_unallocated_amount",
                     "currency_id",
                     "transaction_id",
                     "formatted_created_at",
@@ -25679,7 +26112,7 @@
                         ]
                     },
                     "compound_tax": {
-                        "type": "integer"
+                        "type": "boolean"
                     },
                     "base_amount": {
                         "type": [
@@ -25740,6 +26173,9 @@
                             "null"
                         ]
                     },
+                    "transaction_type": {
+                        "type": "string"
+                    },
                     "compound_tax": {
                         "type": "boolean"
                     },
@@ -25766,6 +26202,7 @@
                     "id",
                     "name",
                     "percent",
+                    "transaction_type",
                     "compound_tax",
                     "collective_tax",
                     "description",
@@ -25865,6 +26302,22 @@
                 ],
                 "title": "BulkExchangeRateRequest"
             },
+            "ChangeInvoiceStatusRequest": {
+                "type": "object",
+                "properties": {
+                    "status": {
+                        "type": "string",
+                        "enum": [
+                            "SENT",
+                            "COMPLETED"
+                        ]
+                    }
+                },
+                "required": [
+                    "status"
+                ],
+                "title": "ChangeInvoiceStatusRequest"
+            },
             "CompaniesRequest": {
                 "type": "object",
                 "properties": {
@@ -26260,6 +26713,475 @@
                 ],
                 "title": "CountryResource"
             },
+            "CreateCreditNoteRequest": {
+                "type": "object",
+                "properties": {
+                    "reason": {
+                        "type": [
+                            "string",
+                            "null"
+                        ],
+                        "maxLength": 1000
+                    },
+                    "items": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "integer"
+                                },
+                                "quantity": {
+                                    "type": "number"
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "quantity"
+                            ]
+                        }
+                    }
+                },
+                "title": "CreateCreditNoteRequest"
+            },
+            "CreditAllocationRequest": {
+                "type": "object",
+                "properties": {
+                    "allocations": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "payment_id": {
+                                    "type": "integer"
+                                },
+                                "invoice_id": {
+                                    "type": "integer"
+                                },
+                                "amount": {
+                                    "type": "integer",
+                                    "minimum": 1
+                                }
+                            },
+                            "required": [
+                                "payment_id",
+                                "invoice_id",
+                                "amount"
+                            ]
+                        },
+                        "minItems": 1
+                    }
+                },
+                "required": [
+                    "allocations"
+                ],
+                "title": "CreditAllocationRequest"
+            },
+            "CreditNoteResource": {
+                "type": "object",
+                "properties": {
+                    "id": {
+                        "type": "integer"
+                    },
+                    "invoice_date": {
+                        "type": "string"
+                    },
+                    "due_date": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "invoice_number": {
+                        "type": "string"
+                    },
+                    "reference_number": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "type": {
+                        "type": "string"
+                    },
+                    "related_invoice_id": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "status": {
+                        "type": "string"
+                    },
+                    "paid_status": {
+                        "type": "string"
+                    },
+                    "tax_per_item": {
+                        "type": "string"
+                    },
+                    "tax_included": {
+                        "type": "integer"
+                    },
+                    "discount_per_item": {
+                        "type": "string"
+                    },
+                    "notes": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "discount_type": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "discount": {
+                        "type": [
+                            "number",
+                            "null"
+                        ]
+                    },
+                    "discount_val": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "sub_total": {
+                        "type": "integer"
+                    },
+                    "total": {
+                        "type": "integer"
+                    },
+                    "tax": {
+                        "type": "integer"
+                    },
+                    "due_amount": {
+                        "type": "integer"
+                    },
+                    "sent": {
+                        "type": "integer"
+                    },
+                    "viewed": {
+                        "type": "integer"
+                    },
+                    "unique_hash": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "template_name": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "customer_id": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "recurring_invoice_id": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "sequence_number": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "exchange_rate": {
+                        "type": [
+                            "number",
+                            "null"
+                        ]
+                    },
+                    "base_discount_val": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "base_sub_total": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "base_total": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "creator_id": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "base_tax": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "base_due_amount": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "currency_id": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "formatted_created_at": {
+                        "type": "string"
+                    },
+                    "invoice_pdf_url": {
+                        "type": "string"
+                    },
+                    "formatted_invoice_date": {
+                        "type": "string"
+                    },
+                    "formatted_due_date": {
+                        "type": "string"
+                    },
+                    "allow_edit": {
+                        "type": "string"
+                    },
+                    "payment_module_enabled": {
+                        "type": "string"
+                    },
+                    "sales_tax_type": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "sales_tax_address_type": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "overdue": {
+                        "type": "integer"
+                    },
+                    "credit_notes": {
+                        "type": "array",
+                        "description": "Credit notes reversing this invoice (minimal reference so the\nUI can flag the invoice as cancelled and link to the storno\ndocument, mirroring the related_invoice back-link). Emitted only\nwhere the relation was eager-loaded: probing it per row costs two\nqueries each, and this resource is serialized in paginated lists.",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "integer"
+                                },
+                                "invoice_number": {
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "invoice_number"
+                            ]
+                        }
+                    },
+                    "credit_reason": {
+                        "type": [
+                            "string",
+                            "null"
+                        ],
+                        "description": "Why this invoice was credited, if it was. Set only by the\ncredit-note flow, never by the invoice form."
+                    },
+                    "credited_total": {
+                        "type": "integer",
+                        "description": "How much of the invoice has been credited off it, as a positive\nnumber of cents (credit notes store negative totals), and whether\nthat covers the whole document. Both are read off the same loaded\nrelation the banner uses, so they cost no extra query."
+                    },
+                    "credited_status": {
+                        "type": "string",
+                        "enum": [
+                            "FULL",
+                            "PARTIAL",
+                            "NONE"
+                        ]
+                    },
+                    "credited_quantities": {
+                        "type": "string",
+                        "description": "Credited quantity per ORIGINAL line, which is what a partial\ncredit form needs to offer the remaining quantities. Emitted only\nwhen the credit notes' items came along."
+                    },
+                    "payment_allocations": {
+                        "type": "array",
+                        "description": "Allocation rows explain how this invoice was settled without\nreintroducing the removed singular payment.invoice relation.\nThey are loaded for the detail response only, so index listings\nremain free of per-row payment queries.",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "integer"
+                                },
+                                "payment_id": {
+                                    "type": "integer"
+                                },
+                                "amount": {
+                                    "type": "integer"
+                                },
+                                "base_amount": {
+                                    "type": "integer"
+                                },
+                                "payment": {
+                                    "type": [
+                                        "object",
+                                        "null"
+                                    ],
+                                    "properties": {
+                                        "id": {
+                                            "type": "integer"
+                                        },
+                                        "payment_number": {
+                                            "type": "string"
+                                        },
+                                        "formatted_payment_date": {
+                                            "type": "string"
+                                        }
+                                    },
+                                    "required": [
+                                        "id",
+                                        "payment_number",
+                                        "formatted_payment_date"
+                                    ]
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "payment_id",
+                                "amount",
+                                "base_amount",
+                                "payment"
+                            ]
+                        }
+                    },
+                    "items": {
+                        "type": "array",
+                        "items": {
+                            "$ref": "#/components/schemas/InvoiceItemResource"
+                        }
+                    },
+                    "customer": {
+                        "$ref": "#/components/schemas/CustomerResource"
+                    },
+                    "creator": {
+                        "$ref": "#/components/schemas/UserResource"
+                    },
+                    "taxes": {
+                        "type": "array",
+                        "items": {
+                            "$ref": "#/components/schemas/TaxResource"
+                        }
+                    },
+                    "fields": {
+                        "type": "array",
+                        "items": {
+                            "$ref": "#/components/schemas/CustomFieldValueResource"
+                        }
+                    },
+                    "company": {
+                        "$ref": "#/components/schemas/CompanyResource"
+                    },
+                    "currency": {
+                        "$ref": "#/components/schemas/CurrencyResource"
+                    },
+                    "related_invoice": {
+                        "type": "object",
+                        "description": "type + related_invoice_id come from InvoiceResource; this adds the\nexpanded reference to the original invoice being reversed.\nRead off the loaded relation rather than probing it: the caller\neager-loads relatedInvoice, so an exists() query here would be\npure overhead.",
+                        "properties": {
+                            "id": {
+                                "type": "string"
+                            },
+                            "invoice_number": {
+                                "type": "string"
+                            },
+                            "invoice_date": {
+                                "type": "string"
+                            },
+                            "formatted_invoice_date": {
+                                "type": "string"
+                            },
+                            "total": {
+                                "type": "string"
+                            },
+                            "unique_hash": {
+                                "type": "string"
+                            }
+                        },
+                        "required": [
+                            "id",
+                            "invoice_number",
+                            "invoice_date",
+                            "formatted_invoice_date",
+                            "total",
+                            "unique_hash"
+                        ]
+                    }
+                },
+                "required": [
+                    "id",
+                    "invoice_date",
+                    "due_date",
+                    "invoice_number",
+                    "reference_number",
+                    "type",
+                    "related_invoice_id",
+                    "status",
+                    "paid_status",
+                    "tax_per_item",
+                    "tax_included",
+                    "discount_per_item",
+                    "notes",
+                    "discount_type",
+                    "discount",
+                    "discount_val",
+                    "sub_total",
+                    "total",
+                    "tax",
+                    "due_amount",
+                    "sent",
+                    "viewed",
+                    "unique_hash",
+                    "template_name",
+                    "customer_id",
+                    "recurring_invoice_id",
+                    "sequence_number",
+                    "exchange_rate",
+                    "base_discount_val",
+                    "base_sub_total",
+                    "base_total",
+                    "creator_id",
+                    "base_tax",
+                    "base_due_amount",
+                    "currency_id",
+                    "formatted_created_at",
+                    "invoice_pdf_url",
+                    "formatted_invoice_date",
+                    "formatted_due_date",
+                    "allow_edit",
+                    "payment_module_enabled",
+                    "sales_tax_type",
+                    "sales_tax_address_type",
+                    "overdue",
+                    "credit_reason"
+                ],
+                "title": "CreditNoteResource"
+            },
             "Currency": {
                 "type": "object",
                 "properties": {
@@ -27186,6 +28108,24 @@
                     "base_due_amount": {
                         "type": "string"
                     },
+                    "invoice_due_amount": {
+                        "type": "string"
+                    },
+                    "base_invoice_due_amount": {
+                        "type": "string"
+                    },
+                    "available_credit": {
+                        "type": "string"
+                    },
+                    "base_available_credit": {
+                        "type": "string"
+                    },
+                    "account_balance": {
+                        "type": "string"
+                    },
+                    "base_account_balance": {
+                        "type": "string"
+                    },
                     "prefix": {
                         "type": [
                             "string",
@@ -27238,11 +28178,151 @@
                     "avatar",
                     "due_amount",
                     "base_due_amount",
+                    "invoice_due_amount",
+                    "base_invoice_due_amount",
+                    "available_credit",
+                    "base_available_credit",
+                    "account_balance",
+                    "base_account_balance",
                     "prefix",
                     "tax_id"
                 ],
                 "title": "CustomerResource"
             },
+            "CustomerStatementResource": {
+                "anyOf": [
+                    {
+                        "type": "object",
+                        "properties": {
+                            "type": {
+                                "type": "string"
+                            },
+                            "customer": {
+                                "$ref": "#/components/schemas/CustomerResource"
+                            },
+                            "currency": {
+                                "$ref": "#/components/schemas/CurrencyResource"
+                            },
+                            "as_of": {
+                                "type": "string"
+                            },
+                            "invoices": {
+                                "type": "array",
+                                "items": {}
+                            },
+                            "credits": {
+                                "type": "array",
+                                "items": {}
+                            },
+                            "invoice_due_amount": {
+                                "type": "integer"
+                            },
+                            "base_invoice_due_amount": {
+                                "type": "integer"
+                            },
+                            "available_credit": {
+                                "type": "integer"
+                            },
+                            "base_available_credit": {
+                                "type": "integer"
+                            },
+                            "account_balance": {
+                                "type": "integer"
+                            },
+                            "base_account_balance": {
+                                "type": "integer"
+                            }
+                        },
+                        "required": [
+                            "type",
+                            "customer",
+                            "currency",
+                            "as_of",
+                            "invoices",
+                            "credits",
+                            "invoice_due_amount",
+                            "base_invoice_due_amount",
+                            "available_credit",
+                            "base_available_credit",
+                            "account_balance",
+                            "base_account_balance"
+                        ]
+                    },
+                    {
+                        "type": "object",
+                        "properties": {
+                            "type": {
+                                "type": "string"
+                            },
+                            "customer": {
+                                "$ref": "#/components/schemas/CustomerResource"
+                            },
+                            "currency": {
+                                "$ref": "#/components/schemas/CurrencyResource"
+                            },
+                            "from_date": {
+                                "type": "string"
+                            },
+                            "to_date": {
+                                "type": "string"
+                            },
+                            "opening_balance": {
+                                "type": "integer"
+                            },
+                            "base_opening_balance": {
+                                "type": "integer"
+                            },
+                            "closing_balance": {
+                                "type": "integer"
+                            },
+                            "base_closing_balance": {
+                                "type": "integer"
+                            },
+                            "entries": {
+                                "type": "array",
+                                "items": {}
+                            },
+                            "meta": {
+                                "type": "object",
+                                "properties": {
+                                    "current_page": {
+                                        "type": "integer"
+                                    },
+                                    "last_page": {
+                                        "type": "integer"
+                                    },
+                                    "per_page": {
+                                        "type": "integer"
+                                    },
+                                    "total": {
+                                        "type": "integer"
+                                    }
+                                },
+                                "required": [
+                                    "current_page",
+                                    "last_page",
+                                    "per_page",
+                                    "total"
+                                ]
+                            }
+                        },
+                        "required": [
+                            "type",
+                            "customer",
+                            "currency",
+                            "from_date",
+                            "to_date",
+                            "opening_balance",
+                            "base_opening_balance",
+                            "closing_balance",
+                            "base_closing_balance",
+                            "entries",
+                            "meta"
+                        ]
+                    }
+                ],
+                "title": "CustomerStatementResource"
+            },
             "DatabaseEnvironmentRequest": {
                 "type": "object",
                 "properties": {
@@ -28255,7 +29335,8 @@
                         ]
                     },
                     "amount": {
-                        "type": "string"
+                        "type": "integer",
+                        "minimum": 0
                     },
                     "customer_id": {
                         "type": [
@@ -28280,6 +29361,25 @@
                         "format": "binary",
                         "contentMediaType": "application/octet-stream",
                         "maxLength": 20000
+                    },
+                    "taxes": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "tax_type_id": {
+                                    "type": "integer"
+                                },
+                                "amount": {
+                                    "type": "integer",
+                                    "minimum": 0
+                                }
+                            },
+                            "required": [
+                                "tax_type_id",
+                                "amount"
+                            ]
+                        }
                     }
                 },
                 "required": [
@@ -28374,6 +29474,12 @@
                             "null"
                         ]
                     },
+                    "taxes": {
+                        "type": "array",
+                        "items": {
+                            "$ref": "#/components/schemas/TaxResource"
+                        }
+                    },
                     "customer": {
                         "$ref": "#/components/schemas/CustomerResource"
                     },
@@ -28662,6 +29768,21 @@
                     },
                     "tax_included": {
                         "type": "integer"
+                    },
+                    "type": {
+                        "type": "string"
+                    },
+                    "related_invoice_id": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
+                    "credit_reason": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
                     }
                 },
                 "required": [
@@ -28705,7 +29826,10 @@
                     "sales_tax_type",
                     "sales_tax_address_type",
                     "overdue",
-                    "tax_included"
+                    "tax_included",
+                    "type",
+                    "related_invoice_id",
+                    "credit_reason"
                 ],
                 "title": "Invoice"
             },
@@ -28869,6 +29993,15 @@
                             "null"
                         ]
                     },
+                    "type": {
+                        "type": "string"
+                    },
+                    "related_invoice_id": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
                     "status": {
                         "type": "string"
                     },
@@ -29037,6 +30170,98 @@
                     "overdue": {
                         "type": "integer"
                     },
+                    "credit_notes": {
+                        "type": "array",
+                        "description": "Credit notes reversing this invoice (minimal reference so the\nUI can flag the invoice as cancelled and link to the storno\ndocument, mirroring the related_invoice back-link). Emitted only\nwhere the relation was eager-loaded: probing it per row costs two\nqueries each, and this resource is serialized in paginated lists.",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "integer"
+                                },
+                                "invoice_number": {
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "invoice_number"
+                            ]
+                        }
+                    },
+                    "credit_reason": {
+                        "type": [
+                            "string",
+                            "null"
+                        ],
+                        "description": "Why this invoice was credited, if it was. Set only by the\ncredit-note flow, never by the invoice form."
+                    },
+                    "credited_total": {
+                        "type": "integer",
+                        "description": "How much of the invoice has been credited off it, as a positive\nnumber of cents (credit notes store negative totals), and whether\nthat covers the whole document. Both are read off the same loaded\nrelation the banner uses, so they cost no extra query."
+                    },
+                    "credited_status": {
+                        "type": "string",
+                        "enum": [
+                            "FULL",
+                            "PARTIAL",
+                            "NONE"
+                        ]
+                    },
+                    "credited_quantities": {
+                        "type": "string",
+                        "description": "Credited quantity per ORIGINAL line, which is what a partial\ncredit form needs to offer the remaining quantities. Emitted only\nwhen the credit notes' items came along."
+                    },
+                    "payment_allocations": {
+                        "type": "array",
+                        "description": "Allocation rows explain how this invoice was settled without\nreintroducing the removed singular payment.invoice relation.\nThey are loaded for the detail response only, so index listings\nremain free of per-row payment queries.",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "integer"
+                                },
+                                "payment_id": {
+                                    "type": "integer"
+                                },
+                                "amount": {
+                                    "type": "integer"
+                                },
+                                "base_amount": {
+                                    "type": "integer"
+                                },
+                                "payment": {
+                                    "type": [
+                                        "object",
+                                        "null"
+                                    ],
+                                    "properties": {
+                                        "id": {
+                                            "type": "integer"
+                                        },
+                                        "payment_number": {
+                                            "type": "string"
+                                        },
+                                        "formatted_payment_date": {
+                                            "type": "string"
+                                        }
+                                    },
+                                    "required": [
+                                        "id",
+                                        "payment_number",
+                                        "formatted_payment_date"
+                                    ]
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "payment_id",
+                                "amount",
+                                "base_amount",
+                                "payment"
+                            ]
+                        }
+                    },
                     "items": {
                         "type": "array",
                         "items": {
@@ -29074,6 +30299,8 @@
                     "due_date",
                     "invoice_number",
                     "reference_number",
+                    "type",
+                    "related_invoice_id",
                     "status",
                     "paid_status",
                     "tax_per_item",
@@ -29110,7 +30337,8 @@
                     "payment_module_enabled",
                     "sales_tax_type",
                     "sales_tax_address_type",
-                    "overdue"
+                    "overdue",
+                    "credit_reason"
                 ],
                 "title": "InvoiceResource"
             },
@@ -29666,10 +30894,53 @@
                 "properties": {
                     "pdf_driver": {
                         "type": "string"
+                    },
+                    "pdf_paper_width": {
+                        "type": "string"
+                    },
+                    "pdf_paper_height": {
+                        "type": "string"
+                    },
+                    "pdf_orientation": {
+                        "type": "string",
+                        "enum": [
+                            "portrait",
+                            "landscape"
+                        ]
+                    },
+                    "pdf_margin_top": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "pdf_margin_right": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "pdf_margin_bottom": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "pdf_margin_left": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "pdf_page_numbers": {
+                        "type": "boolean"
                     }
                 },
                 "required": [
-                    "pdf_driver"
+                    "pdf_driver",
+                    "pdf_paper_width",
+                    "pdf_paper_height",
+                    "pdf_orientation"
                 ],
                 "title": "PDFConfigurationRequest"
             },
@@ -29722,7 +30993,7 @@
                         "type": "string"
                     },
                     "customer_id": {
-                        "type": "string"
+                        "type": "integer"
                     },
                     "exchange_rate": {
                         "type": [
@@ -29731,17 +31002,12 @@
                         ]
                     },
                     "amount": {
-                        "type": "string"
+                        "type": "integer",
+                        "minimum": 1
                     },
                     "payment_number": {
                         "type": "string"
                     },
-                    "invoice_id": {
-                        "type": [
-                            "string",
-                            "null"
-                        ]
-                    },
                     "payment_method_id": {
                         "type": [
                             "string",
@@ -29753,6 +31019,28 @@
                             "string",
                             "null"
                         ]
+                    },
+                    "allocations": {
+                        "type": [
+                            "array",
+                            "null"
+                        ],
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "invoice_id": {
+                                    "type": "integer"
+                                },
+                                "amount": {
+                                    "type": "integer",
+                                    "minimum": 1
+                                }
+                            },
+                            "required": [
+                                "invoice_id",
+                                "amount"
+                            ]
+                        }
                     }
                 },
                 "required": [
@@ -29787,12 +31075,6 @@
                             "null"
                         ]
                     },
-                    "invoice_id": {
-                        "type": [
-                            "integer",
-                            "null"
-                        ]
-                    },
                     "company_id": {
                         "type": [
                             "integer",
@@ -29824,10 +31106,56 @@
                         ]
                     },
                     "base_amount": {
-                        "type": [
-                            "integer",
-                            "null"
-                        ]
+                        "type": "integer"
+                    },
+                    "allocations": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "integer"
+                                },
+                                "invoice_id": {
+                                    "type": "integer"
+                                },
+                                "amount": {
+                                    "type": "integer"
+                                },
+                                "base_amount": {
+                                    "type": "integer"
+                                },
+                                "invoice": {
+                                    "anyOf": [
+                                        {
+                                            "$ref": "#/components/schemas/InvoiceResource"
+                                        },
+                                        {
+                                            "type": "null"
+                                        }
+                                    ]
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "invoice_id",
+                                "amount",
+                                "base_amount",
+                                "invoice"
+                            ]
+                        }
+                    },
+                    "allocated_amount": {
+                        "type": "integer"
+                    },
+                    "unallocated_amount": {
+                        "type": "integer"
+                    },
+                    "base_allocated_amount": {
+                        "type": "integer"
+                    },
+                    "base_unallocated_amount": {
+                        "type": "integer"
                     },
                     "currency_id": {
                         "type": [
@@ -29859,9 +31187,6 @@
                     "customer": {
                         "$ref": "#/components/schemas/CustomerResource"
                     },
-                    "invoice": {
-                        "$ref": "#/components/schemas/InvoiceResource"
-                    },
                     "payment_method": {
                         "$ref": "#/components/schemas/PaymentMethodResource"
                     },
@@ -29888,13 +31213,17 @@
                     "notes",
                     "amount",
                     "unique_hash",
-                    "invoice_id",
                     "company_id",
                     "payment_method_id",
                     "creator_id",
                     "customer_id",
                     "exchange_rate",
                     "base_amount",
+                    "allocations",
+                    "allocated_amount",
+                    "unallocated_amount",
+                    "base_allocated_amount",
+                    "base_unallocated_amount",
                     "currency_id",
                     "transaction_id",
                     "sequence_number",
@@ -30217,6 +31546,34 @@
                 ],
                 "title": "RecurringInvoiceResource"
             },
+            "ReplacePaymentAllocationsRequest": {
+                "type": "object",
+                "properties": {
+                    "allocations": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "invoice_id": {
+                                    "type": "integer"
+                                },
+                                "amount": {
+                                    "type": "integer",
+                                    "minimum": 1
+                                }
+                            },
+                            "required": [
+                                "invoice_id",
+                                "amount"
+                            ]
+                        }
+                    }
+                },
+                "required": [
+                    "allocations"
+                ],
+                "title": "ReplacePaymentAllocationsRequest"
+            },
             "Role": {
                 "type": "object",
                 "properties": {
@@ -30321,6 +31678,70 @@
                 ],
                 "title": "RoleResource"
             },
+            "SendCustomerStatementRequest": {
+                "type": "object",
+                "properties": {
+                    "type": {
+                        "type": "string",
+                        "enum": [
+                            "activity",
+                            "outstanding"
+                        ]
+                    },
+                    "from_date": {
+                        "type": [
+                            "string",
+                            "null"
+                        ],
+                        "format": "date"
+                    },
+                    "to_date": {
+                        "type": [
+                            "string",
+                            "null"
+                        ],
+                        "format": "date"
+                    },
+                    "as_of": {
+                        "type": [
+                            "string",
+                            "null"
+                        ],
+                        "format": "date"
+                    },
+                    "subject": {
+                        "type": "string"
+                    },
+                    "body": {
+                        "type": "string"
+                    },
+                    "to": {
+                        "type": "string",
+                        "format": "email"
+                    },
+                    "cc": {
+                        "type": [
+                            "string",
+                            "null"
+                        ],
+                        "format": "email"
+                    },
+                    "bcc": {
+                        "type": [
+                            "string",
+                            "null"
+                        ],
+                        "format": "email"
+                    }
+                },
+                "required": [
+                    "type",
+                    "subject",
+                    "body",
+                    "to"
+                ],
+                "title": "SendCustomerStatementRequest"
+            },
             "SendEstimatesRequest": {
                 "type": "object",
                 "properties": {
@@ -30474,6 +31895,12 @@
                             "null"
                         ]
                     },
+                    "expense_id": {
+                        "type": [
+                            "integer",
+                            "null"
+                        ]
+                    },
                     "item_id": {
                         "type": [
                             "integer",
@@ -30508,7 +31935,7 @@
                         ]
                     },
                     "compound_tax": {
-                        "type": "integer"
+                        "type": "boolean"
                     },
                     "base_amount": {
                         "type": [
@@ -30545,6 +31972,7 @@
                     "estimate_id",
                     "invoice_item_id",
                     "estimate_item_id",
+                    "expense_id",
                     "item_id",
                     "company_id",
                     "name",
@@ -30618,6 +32046,9 @@
                             "integer",
                             "null"
                         ]
+                    },
+                    "transaction_type": {
+                        "type": "string"
                     }
                 },
                 "required": [
@@ -30632,7 +32063,8 @@
                     "updated_at",
                     "type",
                     "calculation_type",
-                    "fixed_amount"
+                    "fixed_amount",
+                    "transaction_type"
                 ],
                 "title": "TaxType"
             },
@@ -30678,6 +32110,13 @@
                             "string",
                             "null"
                         ]
+                    },
+                    "transaction_type": {
+                        "type": "string",
+                        "enum": [
+                            "sales",
+                            "purchases"
+                        ]
                     }
                 },
                 "required": [
@@ -30713,6 +32152,9 @@
                     "type": {
                         "type": "string"
                     },
+                    "transaction_type": {
+                        "type": "string"
+                    },
                     "compound_tax": {
                         "type": "boolean"
                     },
@@ -30742,6 +32184,7 @@
                     "fixed_amount",
                     "calculation_type",
                     "type",
+                    "transaction_type",
                     "compound_tax",
                     "collective_tax",
                     "description",
diff --git a/resources/scripts/api/endpoints.ts b/resources/scripts/api/endpoints.ts
index a9826053..0da8c044 100644
--- a/resources/scripts/api/endpoints.ts
+++ b/resources/scripts/api/endpoints.ts
@@ -35,6 +35,7 @@ export const API = {
   CUSTOMERS: '/api/v1/customers',
   CUSTOMERS_DELETE: '/api/v1/customers/delete',
   CUSTOMER_STATS: '/api/v1/customers', // append /{id}/stats
+  CUSTOMER_STATEMENT: '/api/v1/customers', // append /{id}/statement
 
   // Items & Units
   ITEMS: '/api/v1/items',
diff --git a/resources/scripts/api/services/customer.service.ts b/resources/scripts/api/services/customer.service.ts
index fb083497..8718c5ed 100644
--- a/resources/scripts/api/services/customer.service.ts
+++ b/resources/scripts/api/services/customer.service.ts
@@ -6,6 +6,79 @@ import type {
   ListParams,
   DeletePayload,
 } from '@/scripts/types/api'
+import type { Currency } from '@/scripts/types/domain/currency'
+
+export type CustomerStatementType = 'activity' | 'outstanding'
+
+export interface CustomerStatementEntry {
+  id: string | number
+  date: string
+  entry_type: 'invoice' | 'credit_note' | 'payment'
+  reference: string
+  description?: string | null
+  debit_amount: number
+  credit_amount: number
+  balance?: number
+}
+
+export interface CustomerStatementOutstandingInvoice {
+  id: number
+  invoice_number: string
+  invoice_date: string
+  due_date: string | null
+  original_amount: number
+  applied_amount: number
+  remaining_amount: number
+}
+
+export interface CustomerStatementCredit {
+  id: number
+  payment_number: string
+  payment_date: string
+  amount: number
+  allocated_amount: number
+  available_amount: number
+}
+
+export interface CustomerStatement {
+  type: CustomerStatementType
+  customer: Customer
+  currency?: Currency
+  opening_balance?: number
+  closing_balance?: number
+  invoice_due_amount?: number
+  available_credit?: number
+  account_balance?: number
+  entries?: CustomerStatementEntry[]
+  meta?: {
+    current_page: number
+    last_page: number
+    per_page: number
+    total: number
+  }
+  invoices?: CustomerStatementOutstandingInvoice[]
+  credits?: CustomerStatementCredit[]
+}
+
+export interface CustomerStatementParams {
+  type: CustomerStatementType
+  from_date?: string
+  to_date?: string
+  as_of?: string
+  page?: number
+}
+
+export interface SendCustomerStatementPayload {
+  type: CustomerStatementType
+  from_date?: string
+  to_date?: string
+  as_of?: string
+  to?: string
+  cc?: string
+  bcc?: string
+  subject?: string
+  body?: string
+}
 
 export interface CustomerListParams extends ListParams {
   display_name?: string
@@ -81,4 +154,40 @@ export const customerService = {
     const { data } = await client.get(`${API.CUSTOMER_STATS}/${id}/stats`, { params })
     return data
   },
+
+  async getStatement(
+    id: number,
+    params: CustomerStatementParams,
+  ): Promise<ApiResponse<CustomerStatement>> {
+    const { data } = await client.get(`${API.CUSTOMER_STATEMENT}/${id}/statement`, { params })
+    return data
+  },
+
+  statementPdfUrl(id: number, params: CustomerStatementParams): string {
+    const query = new URLSearchParams(
+      Object.entries(params).reduce<Record<string, string>>((result, [key, value]) => {
+        if (value !== undefined && value !== null) result[key] = String(value)
+        return result
+      }, {}),
+    )
+    query.set('download', '1')
+
+    return `/reports/customers/${id}/statement?${query.toString()}`
+  },
+
+  async sendStatement(
+    id: number,
+    payload: SendCustomerStatementPayload,
+  ): Promise<{ success: boolean }> {
+    const { data } = await client.post(`${API.CUSTOMER_STATEMENT}/${id}/statement/send`, payload)
+    return data
+  },
+
+  async allocateCredit(
+    id: number,
+    allocations: Array<{ payment_id: number; invoice_id: number; amount: number }>,
+  ): Promise<{ success: boolean }> {
+    const { data } = await client.post(`${API.CUSTOMER_STATEMENT}/${id}/credit-allocations`, { allocations })
+    return data
+  },
 }
diff --git a/resources/scripts/features/company/customers/components/CustomerBalanceCard.vue b/resources/scripts/features/company/customers/components/CustomerBalanceCard.vue
new file mode 100644
index 00000000..da5fee42
--- /dev/null
+++ b/resources/scripts/features/company/customers/components/CustomerBalanceCard.vue
@@ -0,0 +1,27 @@
+<template>
+  <BaseCard class="p-4">
+    <p class="text-sm text-muted">{{ label }}</p>
+    <BaseFormatMoney
+      class="block mt-2 text-xl font-semibold whitespace-nowrap tabular-nums text-heading"
+      :amount="Math.abs(amount)"
+      :currency="currency"
+    />
+    <p v-if="creditLabel && amount < 0" class="mt-1 text-xs font-medium text-status-green">
+      {{ creditLabel }}
+    </p>
+  </BaseCard>
+</template>
+
+<script setup lang="ts">
+import type { Currency } from '@/scripts/types/domain/currency'
+
+withDefaults(defineProps<{
+  label: string
+  amount: number
+  currency?: Currency | Record<string, unknown> | null
+  creditLabel?: string
+}>(), {
+  currency: null,
+  creditLabel: '',
+})
+</script>
diff --git a/resources/scripts/features/company/customers/components/CustomerStatement.vue b/resources/scripts/features/company/customers/components/CustomerStatement.vue
new file mode 100644
index 00000000..1bc1464a
--- /dev/null
+++ b/resources/scripts/features/company/customers/components/CustomerStatement.vue
@@ -0,0 +1,334 @@
+<template>
+  <div class="mt-6 space-y-6">
+    <BaseCard>
+      <div class="flex flex-wrap items-end gap-4">
+        <BaseInputGroup :label="$t('customers.statement_type')" class="min-w-48">
+          <BaseMultiselect v-model="filters.type" :options="statementTypes" :allow-empty="false" :can-deselect="false" :show-labels="false" />
+        </BaseInputGroup>
+
+        <template v-if="filters.type === 'activity'">
+          <BaseInputGroup :label="$t('customers.from_date')" class="min-w-44">
+            <BaseDatePicker v-model="filters.from_date" />
+          </BaseInputGroup>
+          <BaseInputGroup :label="$t('customers.to_date')" class="min-w-44">
+            <BaseDatePicker v-model="filters.to_date" />
+          </BaseInputGroup>
+        </template>
+        <BaseInputGroup v-else :label="$t('customers.as_of')" class="min-w-44">
+          <BaseDatePicker v-model="filters.as_of" />
+        </BaseInputGroup>
+
+        <div class="flex w-full flex-wrap gap-2 sm:ml-auto sm:w-auto">
+          <BaseButton variant="primary-outline" :loading="isLoading" @click="refreshStatement">
+            <template #left="slotProps"><BaseIcon name="ArrowPathIcon" :class="slotProps.class" /></template>
+            {{ $t('general.refresh') }}
+          </BaseButton>
+          <a v-if="pdfUrl" :href="pdfUrl" target="_blank" rel="noopener">
+            <BaseButton variant="primary-outline">
+              <template #left="slotProps"><BaseIcon name="ArrowDownTrayIcon" :class="slotProps.class" /></template>
+              {{ $t('customers.download_statement') }}
+            </BaseButton>
+          </a>
+          <BaseButton variant="primary" :disabled="!statement" @click="openEmailModal">
+            <template #left="slotProps"><BaseIcon name="PaperAirplaneIcon" :class="slotProps.class" /></template>
+            {{ $t('customers.send_statement') }}
+          </BaseButton>
+        </div>
+      </div>
+    </BaseCard>
+
+    <BaseCard v-if="isLoading" class="py-12 text-center text-muted">
+      {{ $t('general.loading') }}
+    </BaseCard>
+
+    <template v-else-if="statement">
+      <div class="grid gap-4 md:grid-cols-3 xl:grid-cols-2 min-[1400px]:grid-cols-3">
+        <BalanceCard :label="$t('customers.invoice_due')" :amount="invoiceDueAmount" :currency="statement.currency ?? customer.currency" />
+        <BalanceCard :label="$t('customers.available_credit')" :amount="availableCredit" :currency="statement.currency ?? customer.currency" />
+        <BalanceCard class="xl:col-span-2 min-[1400px]:col-span-1" :label="$t('customers.net_account_balance')" :amount="accountBalance" :currency="statement.currency ?? customer.currency" :credit-label="$t('customers.credit')" />
+      </div>
+
+      <BaseCard>
+        <div class="flex items-center justify-between gap-4 mb-5">
+          <div>
+            <h2 class="text-lg font-semibold text-heading">{{ filters.type === 'activity' ? $t('customers.account_activity') : $t('customers.outstanding_items') }}</h2>
+            <p v-if="filters.type === 'activity'" class="mt-1 text-sm text-muted">
+              {{ $t('customers.opening_balance') }}: <BaseFormatMoney :amount="statement.opening_balance ?? 0" :currency="statement.currency ?? customer.currency" />
+            </p>
+          </div>
+          <BaseButton v-if="availableCredit > 0 && canEditPayments" variant="primary-outline" @click="openCreditModal">
+            {{ $t('customers.apply_credit') }}
+          </BaseButton>
+        </div>
+
+        <div v-if="filters.type === 'activity'" class="overflow-x-auto">
+          <table class="w-full text-sm">
+            <thead class="border-b border-line-default text-muted">
+              <tr>
+                <th class="px-3 py-3 text-left font-medium">{{ $t('general.date') }}</th>
+                <th class="px-3 py-3 text-left font-medium">{{ $t('customers.activity') }}</th>
+                <th class="px-3 py-3 text-right font-medium">{{ $t('customers.debit') }}</th>
+                <th class="px-3 py-3 text-right font-medium">{{ $t('customers.credit') }}</th>
+                <th class="px-3 py-3 text-right font-medium">{{ $t('customers.balance') }}</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="entry in statement.entries ?? []" :key="`${entry.entry_type}-${entry.id}`" class="border-b border-line-light">
+                <td class="px-3 py-3 whitespace-nowrap text-body">{{ entry.date }}</td>
+                <td class="px-3 py-3 text-heading"><span class="font-medium">{{ entry.reference }}</span><span v-if="entry.description" class="block text-xs text-muted">{{ entry.description }}</span></td>
+                <td class="px-3 py-3 text-right whitespace-nowrap"><BaseFormatMoney :amount="entry.debit_amount" :currency="statement.currency ?? customer.currency" /></td>
+                <td class="px-3 py-3 text-right whitespace-nowrap"><BaseFormatMoney :amount="entry.credit_amount" :currency="statement.currency ?? customer.currency" /></td>
+                <td class="px-3 py-3 text-right font-medium whitespace-nowrap text-heading"><BaseFormatMoney :amount="entry.balance ?? 0" :currency="statement.currency ?? customer.currency" /></td>
+              </tr>
+            </tbody>
+          </table>
+          <p v-if="!(statement.entries?.length)" class="py-8 text-center text-sm text-muted">{{ $t('customers.no_statement_activity') }}</p>
+          <BaseTablePagination
+            v-if="statement.meta"
+            :pagination="{
+              currentPage: statement.meta.current_page,
+              totalPages: statement.meta.last_page,
+              totalCount: statement.meta.total,
+              count: statement.entries?.length ?? 0,
+              limit: statement.meta.per_page,
+            }"
+            @page-change="changeActivityPage"
+          />
+        </div>
+
+        <div v-else class="overflow-x-auto">
+          <table class="w-full text-sm">
+            <thead class="border-b border-line-default text-muted">
+              <tr>
+                <th class="px-3 py-3 text-left font-medium">{{ $t('payments.invoice') }}</th>
+                <th class="px-3 py-3 text-left font-medium">{{ $t('invoices.due_date') }}</th>
+                <th class="px-3 py-3 text-right font-medium">{{ $t('customers.original_amount') }}</th>
+                <th class="px-3 py-3 text-right font-medium">{{ $t('customers.applied') }}</th>
+                <th class="px-3 py-3 text-right font-medium">{{ $t('customers.remaining') }}</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="invoice in statement.invoices ?? []" :key="invoice.id" class="border-b border-line-light">
+                <td class="px-3 py-3 whitespace-nowrap"><router-link :to="`/admin/invoices/${invoice.id}/view`" class="font-medium text-primary-500">{{ invoice.invoice_number }}</router-link></td>
+                <td class="px-3 py-3 whitespace-nowrap text-body">{{ invoice.due_date }}</td>
+                <td class="px-3 py-3 text-right whitespace-nowrap"><BaseFormatMoney :amount="invoice.original_amount" :currency="statement.currency ?? customer.currency" /></td>
+                <td class="px-3 py-3 text-right whitespace-nowrap"><BaseFormatMoney :amount="invoice.applied_amount" :currency="statement.currency ?? customer.currency" /></td>
+                <td class="px-3 py-3 text-right font-medium whitespace-nowrap text-heading"><BaseFormatMoney :amount="invoice.remaining_amount" :currency="statement.currency ?? customer.currency" /></td>
+              </tr>
+            </tbody>
+          </table>
+          <p v-if="!(statement.invoices?.length)" class="py-8 text-center text-sm text-muted">{{ $t('customers.no_outstanding_invoices') }}</p>
+        </div>
+        <div v-if="filters.type === 'outstanding' && statement.credits?.length" class="pt-5 mt-5 border-t border-line-default">
+          <h3 class="mb-3 text-sm font-semibold text-heading">{{ $t('customers.available_credit') }}</h3>
+          <div v-for="credit in statement.credits" :key="credit.id" class="flex items-center justify-between py-2 text-sm border-b border-line-light">
+            <router-link :to="`/admin/payments/${credit.id}/view`" class="font-medium text-primary-500">{{ credit.payment_number }}</router-link>
+            <BaseFormatMoney :amount="credit.available_amount" :currency="statement.currency ?? customer.currency" class="font-medium text-status-green" />
+          </div>
+        </div>
+      </BaseCard>
+    </template>
+
+    <BaseModal :show="showEmailModal" @close="showEmailModal = false">
+      <template #header><div class="flex items-center justify-between w-full">{{ $t('customers.send_statement') }}<BaseIcon name="XMarkIcon" class="w-5 h-5 cursor-pointer text-muted" @click="showEmailModal = false" /></div></template>
+      <form @submit.prevent="sendStatement">
+        <div class="p-6 space-y-4">
+          <BaseInputGroup :label="$t('general.to')" required><BaseInput v-model="emailForm.to" type="email" /></BaseInputGroup>
+          <BaseInputGroup :label="$t('general.cc')"><BaseInput v-model="emailForm.cc" type="email" /></BaseInputGroup>
+          <BaseInputGroup :label="$t('general.bcc')"><BaseInput v-model="emailForm.bcc" type="email" /></BaseInputGroup>
+          <BaseInputGroup :label="$t('general.subject')" required><BaseInput v-model="emailForm.subject" /></BaseInputGroup>
+          <BaseInputGroup :label="$t('general.body')" required><BaseTextarea v-model="emailForm.body" /></BaseInputGroup>
+        </div>
+        <div class="flex justify-end gap-3 p-4 border-t border-line-default"><BaseButton variant="primary-outline" type="button" @click="showEmailModal = false">{{ $t('general.cancel') }}</BaseButton><BaseButton variant="primary" :loading="isSending" type="submit">{{ $t('general.send') }}</BaseButton></div>
+      </form>
+    </BaseModal>
+
+    <BaseModal :show="showCreditModal" @close="showCreditModal = false">
+      <template #header><div class="flex items-center justify-between w-full">{{ $t('customers.apply_credit') }}<BaseIcon name="XMarkIcon" class="w-5 h-5 cursor-pointer text-muted" @click="showCreditModal = false" /></div></template>
+      <div class="p-6">
+        <p class="mb-4 text-sm text-muted">{{ $t('customers.apply_credit_description') }}</p>
+        <div v-if="creditRows.length" class="space-y-3">
+          <div v-for="(row, index) in creditRows" :key="index" class="grid items-end gap-3 p-3 rounded-lg bg-surface-secondary md:grid-cols-[minmax(0,1fr)_minmax(0,1fr)_9rem_auto]">
+            <BaseInputGroup :label="$t('payments.payment')"><BaseMultiselect v-model="row.payment_id" value-prop="id" track-by="payment_number" label="payment_number" :options="creditPayments" /></BaseInputGroup>
+            <BaseInputGroup :label="$t('payments.invoice')"><BaseMultiselect v-model="row.invoice_id" value-prop="id" track-by="invoice_number" label="invoice_number" :options="openInvoices" /></BaseInputGroup>
+            <BaseInputGroup :label="$t('payments.amount')"><BaseMoney :model-value="row.amount / 100" :currency="statement?.currency ?? customer.currency" @update:model-value="setCreditAmount(index, $event)" /></BaseInputGroup>
+            <div class="justify-self-end">
+              <BaseButton type="button" size="sm" variant="gray" :aria-label="$t('payments.remove_allocation')" @click="creditRows.splice(index, 1)"><BaseIcon name="TrashIcon" /></BaseButton>
+            </div>
+          </div>
+        </div>
+        <div class="flex flex-wrap gap-2 mt-4">
+          <BaseButton size="sm" variant="primary-outline" :disabled="!creditPayments.length || !openInvoices.length" @click="allocateCreditOldestFirst">{{ $t('payments.allocate_oldest_first') }}</BaseButton>
+          <BaseButton size="sm" variant="primary-outline" @click="addCreditRow"><template #left="slotProps"><BaseIcon name="PlusIcon" :class="slotProps.class" /></template>{{ $t('payments.add_allocation') }}</BaseButton>
+        </div>
+      </div>
+      <template #footer><div class="flex justify-end gap-3 p-4 border-t border-line-default"><BaseButton variant="primary-outline" @click="showCreditModal = false">{{ $t('general.cancel') }}</BaseButton><BaseButton variant="primary" :loading="isApplyingCredit" @click="applyCredit">{{ $t('customers.apply_credit') }}</BaseButton></div></template>
+    </BaseModal>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, reactive, ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { customerService, type CustomerStatement, type CustomerStatementParams } from '@/scripts/api/services/customer.service'
+import { invoiceService } from '@/scripts/api/services/invoice.service'
+import { paymentService } from '@/scripts/api/services/payment.service'
+import { useNotificationStore } from '@/scripts/stores/notification.store'
+import { useUserStore } from '@/scripts/stores/user.store'
+import { getErrorTranslationKey, handleApiError } from '@/scripts/utils/error-handling'
+import { formatDate } from '@/scripts/utils/format-date'
+import type { Customer } from '@/scripts/types/domain/customer'
+import type { Invoice } from '@/scripts/types/domain/invoice'
+import type { Payment } from '@/scripts/types/domain/payment'
+import BalanceCard from './CustomerBalanceCard.vue'
+
+const props = defineProps<{ customer: Customer }>()
+const { t } = useI18n()
+const notificationStore = useNotificationStore()
+const userStore = useUserStore()
+const today = formatDate(new Date())
+const monthStart = `${today.slice(0, 8)}01`
+const filters = reactive<CustomerStatementParams>({ type: 'activity', from_date: monthStart, to_date: today, as_of: today })
+const statement = ref<CustomerStatement | null>(null)
+const isLoading = ref(false)
+const showEmailModal = ref(false)
+const isSending = ref(false)
+const showCreditModal = ref(false)
+const isApplyingCredit = ref(false)
+const creditPayments = ref<Payment[]>([])
+const openInvoices = ref<Invoice[]>([])
+const creditRows = ref<Array<{ payment_id: number; invoice_id: number; amount: number }>>([])
+const emailForm = reactive({ to: '', cc: '', bcc: '', subject: '', body: '' })
+const statementTypes = computed(() => [
+  { label: t('customers.account_activity'), value: 'activity' },
+  { label: t('customers.outstanding_items'), value: 'outstanding' },
+])
+const statementParams = computed<CustomerStatementParams>(() => filters.type === 'activity'
+  ? { type: 'activity', from_date: filters.from_date, to_date: filters.to_date, page: filters.page ?? 1 }
+  : { type: 'outstanding', as_of: filters.as_of })
+const pdfUrl = computed(() => statement.value ? customerService.statementPdfUrl(props.customer.id, statementParams.value) : '')
+const invoiceDueAmount = computed(() => statement.value?.invoice_due_amount ?? props.customer.invoice_due_amount ?? props.customer.due_amount ?? 0)
+const availableCredit = computed(() => statement.value?.available_credit ?? props.customer.available_credit ?? 0)
+const accountBalance = computed(() => statement.value?.account_balance ?? props.customer.account_balance ?? (invoiceDueAmount.value - availableCredit.value))
+const canEditPayments = computed(() => userStore.hasAbilities('edit-payment'))
+
+watch(() => props.customer.id, () => void loadStatement(), { immediate: true })
+watch(() => filters.type, () => {
+  filters.page = 1
+  void loadStatement()
+})
+
+async function loadStatement(): Promise<void> {
+  isLoading.value = true
+  try {
+    statement.value = (await customerService.getStatement(props.customer.id, statementParams.value)).data
+  } catch {
+    statement.value = null
+  } finally {
+    isLoading.value = false
+  }
+}
+
+function refreshStatement(): void {
+  filters.page = 1
+  void loadStatement()
+}
+
+function changeActivityPage(page: number): void {
+  filters.page = page
+  void loadStatement()
+}
+
+async function sendStatement(): Promise<void> {
+  if (!emailForm.to || !emailForm.subject || !emailForm.body) return
+  isSending.value = true
+  try {
+    await customerService.sendStatement(props.customer.id, { ...statementParams.value, ...emailForm })
+    notificationStore.showNotification({ type: 'success', message: t('customers.statement_sent') })
+    showEmailModal.value = false
+  } catch (error) {
+    showErrorNotification(error)
+  } finally {
+    isSending.value = false
+  }
+}
+
+function openEmailModal(): void {
+  emailForm.to = props.customer.email ?? ''
+  emailForm.subject = t('customers.statement')
+  emailForm.body = t('customers.statement_email_body')
+  showEmailModal.value = true
+}
+
+async function openCreditModal(): Promise<void> {
+  showCreditModal.value = true
+  const [payments, invoices] = await Promise.all([
+    paymentService.list({ customer_id: props.customer.id, limit: 'all' }),
+    invoiceService.list({ customer_id: props.customer.id, limit: 'all' } as never),
+  ])
+  creditPayments.value = payments.data.filter((payment) => (payment.unallocated_amount ?? 0) > 0)
+  openInvoices.value = (invoices.data as unknown as Invoice[]).filter(isEligibleInvoice)
+  if (!creditRows.value.length) addCreditRow()
+}
+
+function addCreditRow(): void {
+  const payment = creditPayments.value[0]
+  const invoice = openInvoices.value[0]
+  if (payment && invoice) creditRows.value.push({ payment_id: payment.id, invoice_id: invoice.id, amount: 0 })
+}
+
+function setCreditAmount(index: number, value: number): void {
+  if (creditRows.value[index]) creditRows.value[index].amount = Math.round(value * 100)
+}
+
+function isEligibleInvoice(invoice: Invoice): boolean {
+  return invoice.type === 'INVOICE' && invoice.status !== 'DRAFT' && invoice.due_amount > 0
+}
+
+function allocateCreditOldestFirst(): void {
+  const remainingInvoices = new Map(
+    [...openInvoices.value]
+      .sort((a, b) => (a.due_date ?? '9999-12-31').localeCompare(b.due_date ?? '9999-12-31') || a.id - b.id)
+      .map((invoice) => [invoice.id, invoice.due_amount]),
+  )
+  const rows: Array<{ payment_id: number; invoice_id: number; amount: number }> = []
+
+  for (const payment of [...creditPayments.value].sort((a, b) => (a.payment_date ?? '').localeCompare(b.payment_date ?? '') || a.id - b.id)) {
+    let remainingCredit = payment.unallocated_amount ?? 0
+    for (const [invoiceId, invoiceDue] of remainingInvoices) {
+      if (remainingCredit <= 0) break
+      if (invoiceDue <= 0) continue
+
+      const amount = Math.min(remainingCredit, invoiceDue)
+      rows.push({ payment_id: payment.id, invoice_id: invoiceId, amount })
+      remainingCredit -= amount
+      remainingInvoices.set(invoiceId, invoiceDue - amount)
+    }
+  }
+
+  creditRows.value = rows
+}
+
+async function applyCredit(): Promise<void> {
+  const allocations = creditRows.value.filter((row) => row.payment_id && row.invoice_id && row.amount > 0)
+  if (!allocations.length) return
+  isApplyingCredit.value = true
+  try {
+    await customerService.allocateCredit(props.customer.id, allocations)
+    notificationStore.showNotification({ type: 'success', message: t('customers.credit_applied') })
+    showCreditModal.value = false
+    creditRows.value = []
+    await loadStatement()
+  } catch (error) {
+    showErrorNotification(error)
+  } finally {
+    isApplyingCredit.value = false
+  }
+}
+
+function showErrorNotification(error: unknown): void {
+  const normalized = handleApiError(error)
+  const translationKey = getErrorTranslationKey(normalized.message)
+  notificationStore.showNotification({ type: 'error', message: translationKey ? t(translationKey) : normalized.message })
+}
+</script>
diff --git a/resources/scripts/features/company/customers/components/CustomerViewSidebar.vue b/resources/scripts/features/company/customers/components/CustomerViewSidebar.vue
index 94c6ca5d..c8da3a30 100644
--- a/resources/scripts/features/company/customers/components/CustomerViewSidebar.vue
+++ b/resources/scripts/features/company/customers/components/CustomerViewSidebar.vue
@@ -5,6 +5,7 @@ import { useRoute } from 'vue-router'
 import { useCustomerStore } from '../store'
 import { useDebounceFn } from '@vueuse/core'
 import LoadingIcon from '@/scripts/components/icons/LoadingIcon.vue'
+import type { Currency } from '@/scripts/types/domain/currency'
 
 interface SearchData {
   orderBy: string | null
@@ -17,7 +18,8 @@ interface CustomerListItem {
   name: string
   contact_name: string | null
   due_amount: number | null
-  currency: Record<string, unknown> | null
+  account_balance?: number | null
+  currency: Currency | null
 }
 
 const customerStore = useCustomerStore()
@@ -76,13 +78,23 @@ async function loadCustomers(
   })
   isFetching.value = false
 
-  if (!customerList.value) customerList.value = []
-  customerList.value = [...customerList.value, ...response.data]
+  const nextCustomers: CustomerListItem[] = [
+    ...(customerList.value ?? []),
+    ...response.data.map((customer) => ({
+      id: customer.id,
+      name: customer.name,
+      contact_name: customer.contact_name,
+      due_amount: customer.due_amount,
+      account_balance: customer.account_balance,
+      currency: customer.currency ?? null,
+    })),
+  ]
+  customerList.value = nextCustomers
 
   currentPageNumber.value = pageNumber ?? 1
   lastPageNumber.value = response.meta.last_page
 
-  const customerFound = customerList.value.find(
+  const customerFound = nextCustomers.find(
     (cust) => cust.id === Number(route.params.id)
   )
 
@@ -252,9 +264,10 @@ loadCustomers()
           </div>
           <div class="flex-1 font-bold text-right whitespace-nowrap">
             <BaseFormatMoney
-              :amount="customer.due_amount !== null ? customer.due_amount : 0"
+              :amount="Math.abs(customer.account_balance ?? customer.due_amount ?? 0)"
               :currency="customer.currency"
             />
+            <span v-if="(customer.account_balance ?? customer.due_amount ?? 0) < 0" class="block mt-1 text-xs font-medium text-status-green">{{ $t('customers.credit') }}</span>
           </div>
         </router-link>
       </div>
diff --git a/resources/scripts/features/company/customers/views/CustomerDetailView.vue b/resources/scripts/features/company/customers/views/CustomerDetailView.vue
index 104a48d1..911619f4 100644
--- a/resources/scripts/features/company/customers/views/CustomerDetailView.vue
+++ b/resources/scripts/features/company/customers/views/CustomerDetailView.vue
@@ -1,11 +1,14 @@
 <script setup lang="ts">
-import { computed } from 'vue'
+import { computed, watch } from 'vue'
 import { useRouter, useRoute } from 'vue-router'
 import { useCustomerStore } from '../store'
 import { useUserStore } from '../../../../stores/user.store'
 import CustomerDropdown from '../components/CustomerDropdown.vue'
 import CustomerViewSidebar from '@/scripts/features/company/customers/components/CustomerViewSidebar.vue'
 import CustomerChart from '@/scripts/features/company/customers/components/CustomerChart.vue'
+import CustomerStatement from '@/scripts/features/company/customers/components/CustomerStatement.vue'
+import CustomerBalanceCard from '@/scripts/features/company/customers/components/CustomerBalanceCard.vue'
+import type { Customer } from '@/scripts/types/domain/customer'
 
 const ABILITIES = {
   EDIT_CUSTOMER: 'edit-customer',
@@ -14,6 +17,8 @@ const ABILITIES = {
   CREATE_INVOICE: 'create-invoice',
   CREATE_PAYMENT: 'create-payment',
   CREATE_EXPENSE: 'create-expense',
+  VIEW_CUSTOMER: 'view-customer',
+  VIEW_FINANCIAL_REPORTS: 'view-financial-reports',
 } as const
 
 const customerStore = useCustomerStore()
@@ -28,6 +33,30 @@ const pageTitle = computed<string>(() => {
 
 const isLoading = computed<boolean>(() => customerStore.isFetchingViewData)
 
+const customerCurrency = computed(() => customerStore.selectedViewCustomer.currency)
+const selectedCustomer = computed<Customer | null>(() => (
+  customerStore.selectedViewCustomer.id
+    ? customerStore.selectedViewCustomer as Customer
+    : null
+))
+const invoiceDueAmount = computed(() => customerStore.selectedViewCustomer.invoice_due_amount ?? customerStore.selectedViewCustomer.due_amount ?? 0)
+const availableCredit = computed(() => customerStore.selectedViewCustomer.available_credit ?? 0)
+const accountBalance = computed(() => customerStore.selectedViewCustomer.account_balance ?? (invoiceDueAmount.value - availableCredit.value))
+const canViewStatement = computed(() => {
+  return userStore.hasAbilities(ABILITIES.VIEW_CUSTOMER)
+    && userStore.hasAbilities(ABILITIES.VIEW_FINANCIAL_REPORTS)
+})
+
+watch(
+  () => route.params.id,
+  (id) => {
+    if (id) {
+      void customerStore.fetchViewCustomer({ id: Number(id) })
+    }
+  },
+  { immediate: true },
+)
+
 function canCreateTransaction(): boolean {
   return userStore.hasAbilities([
     ABILITIES.CREATE_ESTIMATE,
@@ -136,7 +165,18 @@ function refreshData(): void {
     <!-- Customer View Sidebar -->
     <CustomerViewSidebar />
 
-    <!-- Chart -->
-    <CustomerChart />
+    <BaseTabGroup>
+      <BaseTab :title="$t('customers.overview')">
+        <div class="grid gap-4 mt-6 md:grid-cols-3 xl:grid-cols-2 min-[1400px]:grid-cols-3">
+          <CustomerBalanceCard :label="$t('customers.invoice_due')" :amount="invoiceDueAmount" :currency="customerCurrency" />
+          <CustomerBalanceCard :label="$t('customers.available_credit')" :amount="availableCredit" :currency="customerCurrency" />
+          <CustomerBalanceCard class="xl:col-span-2 min-[1400px]:col-span-1" :label="$t('customers.net_account_balance')" :amount="accountBalance" :currency="customerCurrency" :credit-label="$t('customers.credit')" />
+        </div>
+        <CustomerChart />
+      </BaseTab>
+      <BaseTab v-if="canViewStatement" :title="$t('customers.statement')">
+        <CustomerStatement v-if="selectedCustomer" :customer="selectedCustomer" />
+      </BaseTab>
+    </BaseTabGroup>
   </BasePage>
 </template>
diff --git a/resources/scripts/features/company/customers/views/CustomerIndexView.vue b/resources/scripts/features/company/customers/views/CustomerIndexView.vue
index d5b5a417..e2912d62 100644
--- a/resources/scripts/features/company/customers/views/CustomerIndexView.vue
+++ b/resources/scripts/features/company/customers/views/CustomerIndexView.vue
@@ -94,7 +94,11 @@ const customerColumns = computed<TableColumn[]>(() => [
     tdClass: 'font-medium text-heading',
   },
   { key: 'phone', label: t('customers.phone') },
-  { key: 'due_amount', label: t('customers.amount_due') },
+  {
+    key: 'account_balance',
+    label: t('customers.net_account_balance'),
+    sortable: false,
+  },
   {
     key: 'created_at',
     label: t('items.added_on'),
@@ -143,7 +147,7 @@ async function fetchData({ page, sort }: FetchParams): Promise<FetchResult> {
     contact_name: filters.contact_name,
     phone: filters.phone,
     orderByField: sort.fieldName || 'created_at',
-    orderBy: sort.order || 'desc',
+    orderBy: sort.order === 'asc' ? 'asc' as const : 'desc' as const,
     page,
   }
 
@@ -368,11 +372,11 @@ function removeMultipleCustomers(): void {
           </span>
         </template>
 
-        <template #cell-due_amount="{ row }">
-          <BaseFormatMoney
-            :amount="row.data.due_amount || 0"
-            :currency="row.data.currency"
-          />
+        <template #cell-account_balance="{ row }">
+          <div>
+            <BaseFormatMoney :amount="Math.abs(row.data.account_balance ?? row.data.due_amount ?? 0)" :currency="row.data.currency" />
+            <span v-if="(row.data.account_balance ?? row.data.due_amount ?? 0) < 0" class="block mt-1 text-xs font-medium text-status-green">{{ $t('customers.credit') }}</span>
+          </div>
         </template>
 
         <template #cell-created_at="{ row }">
diff --git a/resources/scripts/features/company/invoices/views/InvoiceDetailView.vue b/resources/scripts/features/company/invoices/views/InvoiceDetailView.vue
index 6da51dd3..e67e0ce5 100644
--- a/resources/scripts/features/company/invoices/views/InvoiceDetailView.vue
+++ b/resources/scripts/features/company/invoices/views/InvoiceDetailView.vue
@@ -114,6 +114,22 @@
       </span>
     </div>
 
+    <BaseCard v-if="invoicePaymentAllocations.length" class="mb-4">
+      <h2 class="mb-3 text-base font-semibold text-heading">{{ $t('invoices.allocated_payments') }}</h2>
+      <div class="divide-y divide-line-light">
+        <div v-for="allocation in invoicePaymentAllocations" :key="allocation.id" class="flex items-center justify-between gap-4 py-3 text-sm">
+          <div>
+            <router-link v-if="allocation.payment" :to="`/admin/payments/${allocation.payment.id}/view`" class="font-medium text-primary-500">
+              {{ allocation.payment.payment_number }}
+            </router-link>
+            <span v-else class="font-medium text-heading">{{ $t('payments.payment') }}</span>
+            <span v-if="allocation.payment?.formatted_payment_date" class="block mt-1 text-xs text-muted">{{ allocation.payment.formatted_payment_date }}</span>
+          </div>
+          <BaseFormatMoney :amount="allocation.amount" :currency="invoiceData.customer?.currency" class="font-medium text-heading" />
+        </div>
+      </div>
+    </BaseCard>
+
     <!-- 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"
@@ -298,7 +314,7 @@ import LoadingIcon from '@/scripts/components/icons/LoadingIcon.vue'
 import { useUserStore } from '../../../../stores/user.store'
 import { useDialogStore } from '../../../../stores/dialog.store'
 import { useModalStore } from '../../../../stores/modal.store'
-import type { Invoice } from '../../../../types/domain/invoice'
+import type { Invoice, InvoicePaymentAllocation } from '../../../../types/domain/invoice'
 
 interface Props {
   canEdit?: boolean
@@ -403,6 +419,8 @@ const isFullyCredited = computed<boolean>(() => {
   return invoiceData.value?.credited_status !== 'PARTIAL'
 })
 
+const invoicePaymentAllocations = computed<InvoicePaymentAllocation[]>(() => invoiceData.value?.payment_allocations ?? [])
+
 const getOrderBy = computed<boolean>(() => {
   return searchData.orderBy === 'asc' || searchData.orderBy === null
 })
diff --git a/resources/scripts/features/company/payments/store.ts b/resources/scripts/features/company/payments/store.ts
index 120b1ca1..55ac0e63 100644
--- a/resources/scripts/features/company/payments/store.ts
+++ b/resources/scripts/features/company/payments/store.ts
@@ -27,14 +27,13 @@ export interface PaymentFormData {
   customer_id: number | null
   customer: Customer | null
   selectedCustomer: Customer | null
-  invoice_id: number | null
+  allocations: Array<{ invoice_id: number; amount: number }>
   amount: number
   payment_method_id: number | null
   notes: string | null
   currency: Currency | Record<string, unknown> | null
   currency_id: number | null
   exchange_rate: number | null
-  maxPayableAmount: number
   selectedNote: Note | null
   customFields: CustomFieldValue[]
   fields: CustomFieldValue[]
@@ -49,14 +48,13 @@ function createPaymentStub(): PaymentFormData {
     customer_id: null,
     customer: null,
     selectedCustomer: null,
-    invoice_id: null,
+    allocations: [],
     amount: 0,
     payment_method_id: null,
     notes: '',
     currency: null,
     currency_id: null,
     exchange_rate: null,
-    maxPayableAmount: Number.MAX_SAFE_INTEGER,
     selectedNote: null,
     customFields: [],
     fields: [],
@@ -298,11 +296,9 @@ export const usePaymentStore = defineStore('payment', {
 
         if (isEdit) {
           const paymentRes = editRes as { data: { data: Payment } } | undefined
-          if (paymentRes?.data?.data?.invoice) {
-            this.currentPayment.maxPayableAmount = parseInt(
-              String(paymentRes.data.data.invoice.due_amount),
-            )
-          }
+          this.currentPayment.allocations = paymentRes?.data?.data?.allocations?.map(
+            ({ invoice_id, amount }) => ({ invoice_id, amount }),
+          ) ?? []
         } else if (!isEdit && nextNumRes) {
           const now = new Date()
           this.currentPayment.payment_date = formatDate(now)
diff --git a/resources/scripts/features/company/payments/views/PaymentCreateView.vue b/resources/scripts/features/company/payments/views/PaymentCreateView.vue
index 1ace0ff8..0909c607 100644
--- a/resources/scripts/features/company/payments/views/PaymentCreateView.vue
+++ b/resources/scripts/features/company/payments/views/PaymentCreateView.vue
@@ -1,77 +1,34 @@
 <template>
   <BasePage class="relative payment-create">
-    <form action="" @submit.prevent="submitPaymentData">
+    <form @submit.prevent="submitPaymentData">
       <BasePageHeader :title="pageTitle" class="mb-5">
         <BaseBreadcrumb>
-          <BaseBreadcrumbItem
-            :title="$t('general.home')"
-            to="/admin/dashboard"
-          />
-          <BaseBreadcrumbItem
-            :title="$t('payments.payment', 2)"
-            to="/admin/payments"
-          />
+          <BaseBreadcrumbItem :title="$t('general.home')" to="/admin/dashboard" />
+          <BaseBreadcrumbItem :title="$t('payments.payment', 2)" to="/admin/payments" />
           <BaseBreadcrumbItem :title="pageTitle" to="#" active />
         </BaseBreadcrumb>
 
         <template #actions>
-          <BaseButton
-            :loading="isSaving"
-            :disabled="isSaving"
-            variant="primary"
-            type="submit"
-            class="hidden sm:flex"
-          >
+          <BaseButton :loading="isSaving" :disabled="isSaving" variant="primary" type="submit" class="hidden sm:flex">
             <template #left="slotProps">
-              <BaseIcon
-                v-if="!isSaving"
-                name="ArrowDownOnSquareIcon"
-                :class="slotProps.class"
-              />
+              <BaseIcon v-if="!isSaving" name="ArrowDownOnSquareIcon" :class="slotProps.class" />
             </template>
-            {{
-              isEdit
-                ? $t('payments.update_payment')
-                : $t('payments.save_payment')
-            }}
+            {{ isEdit ? $t('payments.update_payment') : $t('payments.save_payment') }}
           </BaseButton>
         </template>
       </BasePageHeader>
 
       <BaseCard>
         <BaseInputGrid>
-          <!-- Payment Date -->
-          <BaseInputGroup
-            :label="$t('payments.date')"
-            :content-loading="isLoadingContent"
-            required
-          >
-            <BaseDatePicker
-              v-model="paymentStore.currentPayment.payment_date"
-              :content-loading="isLoadingContent"
-              :calendar-button="true"
-              calendar-button-icon="calendar"
-            />
+          <BaseInputGroup :label="$t('payments.date')" :content-loading="isLoadingContent" required>
+            <BaseDatePicker v-model="paymentStore.currentPayment.payment_date" :content-loading="isLoadingContent" :calendar-button="true" calendar-button-icon="calendar" />
           </BaseInputGroup>
 
-          <!-- Payment Number -->
-          <BaseInputGroup
-            :label="$t('payments.payment_number')"
-            :content-loading="isLoadingContent"
-            required
-          >
-            <BaseInput
-              v-model="paymentStore.currentPayment.payment_number"
-              :content-loading="isLoadingContent"
-            />
+          <BaseInputGroup :label="$t('payments.payment_number')" :content-loading="isLoadingContent" required>
+            <BaseInput v-model="paymentStore.currentPayment.payment_number" :content-loading="isLoadingContent" />
           </BaseInputGroup>
 
-          <!-- Customer -->
-          <BaseInputGroup
-            :label="$t('payments.customer')"
-            :content-loading="isLoadingContent"
-            required
-          >
+          <BaseInputGroup :label="$t('payments.customer')" :content-loading="isLoadingContent" required>
             <BaseCustomerSelectInput
               v-if="!isLoadingContent"
               v-model="paymentStore.currentPayment.customer_id"
@@ -82,43 +39,17 @@
             />
           </BaseInputGroup>
 
-          <!-- Invoice -->
-          <BaseInputGroup
-            :content-loading="isLoadingContent"
-            :label="$t('payments.invoice')"
-          >
-            <BaseMultiselect
-              v-model="paymentStore.currentPayment.invoice_id"
+          <BaseInputGroup :label="$t('payments.amount')" :content-loading="isLoadingContent" required>
+            <BaseMoney
+              :key="String(paymentStore.currentPayment.currency)"
+              v-model="amount"
+              :currency="paymentStore.currentPayment.currency"
               :content-loading="isLoadingContent"
-              value-prop="id"
-              track-by="invoice_number"
-              label="invoice_number"
-              :options="invoiceList"
-              :loading="isLoadingInvoices"
-              :placeholder="$t('invoices.select_invoice')"
-              @select="onSelectInvoice"
             />
           </BaseInputGroup>
 
-          <!-- Amount -->
-          <BaseInputGroup
-            :label="$t('payments.amount')"
-            :content-loading="isLoadingContent"
-            required
-          >
-            <div class="relative w-full">
-              <BaseMoney
-                :key="String(paymentStore.currentPayment.currency)"
-                v-model="amount"
-                :currency="paymentStore.currentPayment.currency"
-                :content-loading="isLoadingContent"
-              />
-            </div>
-          </BaseInputGroup>
-
-          <!-- Exchange Rate -->
           <ExchangeRateConverter
-            :store="paymentStore"
+            :store="exchangeRateStore"
             store-prop="currentPayment"
             :v="{ exchange_rate: { $error: false, $errors: [], $touch: () => {} } }"
             :is-loading="isLoadingContent"
@@ -126,11 +57,7 @@
             :customer-currency="paymentStore.currentPayment.currency_id"
           />
 
-          <!-- Payment Mode -->
-          <BaseInputGroup
-            :content-loading="isLoadingContent"
-            :label="$t('payments.payment_mode')"
-          >
+          <BaseInputGroup :content-loading="isLoadingContent" :label="$t('payments.payment_mode')">
             <BaseMultiselect
               v-model="paymentStore.currentPayment.payment_method_id"
               :content-loading="isLoadingContent"
@@ -144,40 +71,68 @@
           </BaseInputGroup>
         </BaseInputGrid>
 
-        <!-- Notes -->
-        <div class="relative mt-6">
-          <label class="mb-4 text-sm font-medium text-heading">
-            {{ $t('estimates.notes') }}
-          </label>
+        <section class="pt-6 mt-6 border-t border-line-default">
+          <div class="flex flex-wrap items-center justify-between gap-3 mb-4">
+            <div>
+              <h2 class="text-base font-semibold text-heading">{{ $t('payments.allocations') }}</h2>
+              <p class="mt-1 text-sm text-muted">{{ $t('payments.allocations_description') }}</p>
+            </div>
+            <div class="flex gap-2">
+              <BaseButton type="button" size="sm" variant="primary-outline" :disabled="!invoiceList.length || !amount" @click="allocateOldestFirst">
+                {{ $t('payments.allocate_oldest_first') }}
+              </BaseButton>
+              <BaseButton type="button" size="sm" variant="primary-outline" :disabled="!paymentStore.currentPayment.customer_id" @click="addAllocation">
+                <template #left="slotProps"><BaseIcon name="PlusIcon" :class="slotProps.class" /></template>
+                {{ $t('payments.add_allocation') }}
+              </BaseButton>
+            </div>
+          </div>
 
-          <BaseCustomInput
-            v-model="paymentStore.currentPayment.notes"
-            :content-loading="isLoadingContent"
-            :fields="paymentFields"
-            class="mt-1"
-          />
+          <div v-if="!paymentStore.currentPayment.customer_id" class="p-4 text-sm rounded-lg bg-surface-secondary text-muted">
+            {{ $t('payments.select_customer_to_allocate') }}
+          </div>
+
+          <div v-else-if="!paymentStore.currentPayment.allocations.length" class="p-4 text-sm rounded-lg bg-surface-secondary text-muted">
+            {{ $t('payments.no_allocations') }}
+          </div>
+
+          <div v-else class="space-y-3">
+            <div v-for="(allocation, index) in paymentStore.currentPayment.allocations" :key="`${allocation.invoice_id}-${index}`" class="grid items-end gap-3 p-3 rounded-lg bg-surface-secondary md:grid-cols-[minmax(0,1fr)_12rem_auto]">
+              <BaseInputGroup :label="$t('payments.invoice')">
+                <BaseMultiselect
+                  v-model="allocation.invoice_id"
+                  value-prop="id"
+                  track-by="invoice_number"
+                  label="invoice_number"
+                  :options="availableInvoices(allocation.invoice_id)"
+                  :loading="isLoadingInvoices"
+                  :placeholder="$t('invoices.select_invoice')"
+                />
+              </BaseInputGroup>
+              <BaseInputGroup :label="$t('payments.amount')">
+                <BaseMoney :model-value="allocation.amount / 100" :currency="paymentStore.currentPayment.currency" @update:model-value="setAllocationAmount(index, $event)" />
+              </BaseInputGroup>
+              <div class="justify-self-end">
+                <BaseButton type="button" size="sm" variant="gray" :aria-label="$t('payments.remove_allocation')" @click="removeAllocation(index)">
+                  <BaseIcon name="TrashIcon" />
+                </BaseButton>
+              </div>
+            </div>
+          </div>
+
+          <div class="flex flex-wrap justify-end gap-x-8 gap-y-2 pt-4 mt-4 text-sm border-t border-line-default">
+            <span class="text-muted">{{ $t('payments.allocated') }}: <BaseFormatMoney :amount="allocatedAmount" :currency="paymentStore.currentPayment.currency" /></span>
+            <span :class="unallocatedAmount < 0 ? 'text-status-red' : 'text-heading'">{{ $t('payments.unapplied_credit') }}: <BaseFormatMoney :amount="Math.max(unallocatedAmount, 0)" :currency="paymentStore.currentPayment.currency" /></span>
+          </div>
+        </section>
+
+        <div class="relative mt-6">
+          <label class="mb-4 text-sm font-medium text-heading">{{ $t('estimates.notes') }}</label>
+          <BaseCustomInput v-model="paymentStore.currentPayment.notes" :content-loading="isLoadingContent" :fields="paymentFields" class="mt-1" />
         </div>
 
-        <!-- Mobile Save Button -->
-        <BaseButton
-          :loading="isSaving"
-          :content-loading="isLoadingContent"
-          variant="primary"
-          type="submit"
-          class="flex justify-center w-full mt-4 sm:hidden md:hidden"
-        >
-          <template #left="slotProps">
-            <BaseIcon
-              v-if="!isSaving"
-              name="ArrowDownOnSquareIcon"
-              :class="slotProps.class"
-            />
-          </template>
-          {{
-            isEdit
-              ? $t('payments.update_payment')
-              : $t('payments.save_payment')
-          }}
+        <BaseButton :loading="isSaving" :content-loading="isLoadingContent" variant="primary" type="submit" class="flex justify-center w-full mt-4 sm:hidden">
+          {{ isEdit ? $t('payments.update_payment') : $t('payments.save_payment') }}
         </BaseButton>
       </BaseCard>
     </form>
@@ -185,17 +140,13 @@
 </template>
 
 <script setup lang="ts">
-import { ref, computed, watchEffect, onBeforeUnmount } from 'vue'
+import { computed, onBeforeUnmount, ref, watch } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 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 { 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'
@@ -205,126 +156,73 @@ const route = useRoute()
 const router = useRouter()
 const { t } = useI18n()
 const paymentStore = usePaymentStore()
+const exchangeRateStore = paymentStore as unknown as Record<string, unknown> & { showExchangeRate: boolean }
 const companyStore = useCompanyStore()
 const notificationStore = useNotificationStore()
 
-const isSaving = ref<boolean>(false)
-const isLoadingInvoices = ref<boolean>(false)
+const isSaving = ref(false)
+const isLoadingInvoices = ref(false)
 const invoiceList = ref<Invoice[]>([])
-const selectedInvoice = ref<Invoice | null>(null)
-
-const paymentFields = ref<string[]>([
-  'customer',
-  'company',
-  'customerCustom',
-  'payment',
-  'paymentCustom',
-])
+const paymentFields = ref(['customer', 'company', 'customerCustom', 'payment', 'paymentCustom'])
 
 const amount = computed<number>({
   get: () => paymentStore.currentPayment.amount / 100,
-  set: (value: number) => {
-    paymentStore.currentPayment.amount = Math.round(value * 100)
-  },
+  set: (value) => { paymentStore.currentPayment.amount = Math.round(value * 100) },
 })
 
-const isLoadingContent = computed<boolean>(
-  () => paymentStore.isFetchingInitialData,
-)
+const allocatedAmount = computed(() => paymentStore.currentPayment.allocations.reduce((total, allocation) => total + allocation.amount, 0))
+const unallocatedAmount = computed(() => paymentStore.currentPayment.amount - allocatedAmount.value)
+const isLoadingContent = computed(() => paymentStore.isFetchingInitialData)
+const isEdit = computed(() => route.name === 'payments.edit')
+const pageTitle = computed(() => isEdit.value ? t('payments.edit_payment') : t('payments.new_payment'))
 
-const isEdit = computed<boolean>(() => route.name === 'payments.edit')
-
-const pageTitle = computed<string>(() => {
-  return isEdit.value ? t('payments.edit_payment') : t('payments.new_payment')
-})
-
-// Reset state on create
 paymentStore.resetCurrentPayment()
 
-if (route.query.customer) {
-  paymentStore.currentPayment.customer_id = Number(route.query.customer)
-}
+if (route.query.customer) paymentStore.currentPayment.customer_id = Number(route.query.customer)
 
 paymentStore.fetchPaymentInitialData(
   isEdit.value,
-  { id: isEdit.value ? (route.params.id as string) : undefined },
+  { id: isEdit.value ? String(route.params.id) : undefined },
   companyStore.selectedCompanyCurrency ?? undefined,
 )
 
-// Create-from-invoice: pre-select the invoice and its customer
-if (route.params.id && !isEdit.value) {
-  setInvoiceFromUrl()
-}
+if (route.params.id && !isEdit.value) void setInvoiceFromUrl()
+
+watch(
+  () => paymentStore.currentPayment.customer_id,
+  (customerId, previousCustomerId) => {
+    if (!customerId) return
+    if (previousCustomerId && customerId !== previousCustomerId) paymentStore.currentPayment.allocations = []
+    void onCustomerChange(customerId)
+  },
+  { immediate: true },
+)
 
 async function setInvoiceFromUrl(): Promise<void> {
   try {
-    const response = await invoiceService.get(Number(route.params.id))
-    const invoice = response.data
-    paymentStore.currentPayment.customer_id = invoice.customer_id ?? (invoice.customer as Record<string, unknown>)?.id as number
-    paymentStore.currentPayment.invoice_id = invoice.id
+    const invoice = (await invoiceService.get(Number(route.params.id))).data
+    paymentStore.currentPayment.customer_id = invoice.customer_id
+    paymentStore.currentPayment.allocations = [{ invoice_id: invoice.id, amount: invoice.due_amount }]
+    if (paymentStore.currentPayment.amount === 0) paymentStore.currentPayment.amount = invoice.due_amount
   } catch {
-    // Invoice not found
+    // The normal form remains usable if the originating invoice no longer exists.
   }
 }
 
-// Reactively fetch invoices whenever customer_id changes
-// Handles: edit data load, manual selection, create-from-invoice
-watchEffect(() => {
-  if (paymentStore.currentPayment.customer_id) {
-    onCustomerChange(paymentStore.currentPayment.customer_id)
-  }
-})
-
 async function onCustomerChange(customerId: number): Promise<void> {
-  const params: Record<string, unknown> = {
-    customer_id: customerId,
-    status: isEdit.value ? '' : 'DUE',
-    limit: 'all',
-  }
-
   isLoadingInvoices.value = true
   try {
     const [invoiceResponse, customerResponse] = await Promise.all([
-      invoiceService.list(params as never),
+      invoiceService.list({ customer_id: customerId, limit: 'all' } as never),
       customerService.get(customerId),
     ])
-
     invoiceList.value = [...(invoiceResponse.data as unknown as Invoice[])]
-
-    // Set currency from customer
-    if (customerResponse.data) {
-      const customer = customerResponse.data
-      paymentStore.currentPayment.customer = customer
-      paymentStore.currentPayment.selectedCustomer = customer
-      if (customer.currency) {
-        paymentStore.currentPayment.currency = customer.currency
-        paymentStore.currentPayment.currency_id = customer.currency.id
-      }
-    }
-
-    if (paymentStore.currentPayment.invoice_id) {
-      selectedInvoice.value =
-        invoiceList.value.find(
-          (inv) => inv.id === paymentStore.currentPayment.invoice_id,
-        ) ?? null
-
-      if (selectedInvoice.value) {
-        paymentStore.currentPayment.maxPayableAmount =
-          selectedInvoice.value.due_amount +
-          paymentStore.currentPayment.amount
-
-        if (amount.value === 0) {
-          amount.value = selectedInvoice.value.due_amount / 100
-        }
-      }
-    }
-
-    if (isEdit.value) {
-      invoiceList.value = invoiceList.value.filter(
-        (v) =>
-          v.due_amount > 0 ||
-          v.id === paymentStore.currentPayment.invoice_id,
-      )
+    const customer = customerResponse.data
+    paymentStore.currentPayment.customer = customer
+    paymentStore.currentPayment.selectedCustomer = customer
+    if (customer.currency) {
+      paymentStore.currentPayment.currency = customer.currency
+      paymentStore.currentPayment.currency_id = customer.currency.id
     }
   } catch {
     invoiceList.value = []
@@ -333,59 +231,87 @@ async function onCustomerChange(customerId: number): Promise<void> {
   }
 }
 
-function onManualCustomerSelect(): void {
-  const params: Record<string, unknown> = {
-    userId: paymentStore.currentPayment.customer_id,
-  }
-  if (route.params.id) {
-    params.model_id = route.params.id
-  }
-
-  paymentStore.currentPayment.invoice_id = null
-  selectedInvoice.value = null
-  paymentStore.currentPayment.amount = 0
-  paymentStore.getNextNumber(params, true)
+function availableInvoices(selectedInvoiceId: number): Invoice[] {
+  const chosenInvoiceIds = paymentStore.currentPayment.allocations
+    .map(({ invoice_id }) => invoice_id)
+    .filter((id) => id !== selectedInvoiceId)
+  return invoiceList.value
+    .filter((invoice) => isEligibleInvoice(invoice) || invoice.id === selectedInvoiceId)
+    .filter((invoice) => !chosenInvoiceIds.includes(invoice.id))
 }
 
-function onSelectInvoice(id: number): void {
-  if (id) {
-    selectedInvoice.value =
-      invoiceList.value.find((inv) => inv.id === id) ?? null
-    if (selectedInvoice.value) {
-      amount.value = selectedInvoice.value.due_amount / 100
-      paymentStore.currentPayment.maxPayableAmount =
-        selectedInvoice.value.due_amount
-    }
+function isEligibleInvoice(invoice: Invoice): boolean {
+  return invoice.type === 'INVOICE' && invoice.status !== 'DRAFT' && invoice.due_amount > 0
+}
+
+function onManualCustomerSelect(): void {
+  paymentStore.currentPayment.allocations = []
+  paymentStore.currentPayment.amount = 0
+  const params: Record<string, unknown> = { userId: paymentStore.currentPayment.customer_id }
+  if (route.params.id) params.model_id = route.params.id
+  void paymentStore.getNextNumber(params, true)
+}
+
+function addAllocation(): void {
+  const firstInvoice = availableInvoices(0)[0]
+  if (firstInvoice) paymentStore.currentPayment.allocations.push({ invoice_id: firstInvoice.id, amount: 0 })
+}
+
+function removeAllocation(index: number): void {
+  paymentStore.currentPayment.allocations.splice(index, 1)
+}
+
+function setAllocationAmount(index: number, value: number): void {
+  const allocation = paymentStore.currentPayment.allocations[index]
+  if (allocation) allocation.amount = Math.round(value * 100)
+}
+
+function allocateOldestFirst(): void {
+  let remaining = paymentStore.currentPayment.amount
+  const allocations: Array<{ invoice_id: number; amount: number }> = []
+  for (const invoice of [...invoiceList.value]
+    .filter(isEligibleInvoice)
+    .sort((a, b) => (a.due_date ?? '9999-12-31').localeCompare(b.due_date ?? '9999-12-31') || a.id - b.id)) {
+    if (remaining <= 0) break
+    const allocated = Math.min(remaining, invoice.due_amount)
+    allocations.push({ invoice_id: invoice.id, amount: allocated })
+    remaining -= allocated
   }
+  paymentStore.currentPayment.allocations = allocations
 }
 
 async function submitPaymentData(): Promise<void> {
-  isSaving.value = true
+  if (unallocatedAmount.value < 0) {
+    notificationStore.showNotification({ type: 'error', message: t('payments.allocation_exceeds_amount') })
+    return
+  }
 
+  isSaving.value = true
+  const current = paymentStore.currentPayment
   const data = {
-    ...cloneDeep(paymentStore.currentPayment),
+    ...(isEdit.value ? { id: current.id } : {}),
+    payment_date: current.payment_date,
+    payment_number: current.payment_number,
+    customer_id: current.customer_id,
+    amount: current.amount,
+    payment_method_id: current.payment_method_id,
+    notes: current.notes,
+    currency_id: current.currency_id,
+    exchange_rate: current.exchange_rate,
+    customFields: current.customFields,
+    fields: current.fields,
+    allocations: current.allocations.filter(({ invoice_id, amount }) => invoice_id && amount > 0),
   }
 
   try {
-    const action = isEdit.value
-      ? paymentStore.updatePayment
-      : paymentStore.addPayment
-
-    const response = await action(data)
-    router.push(`/admin/payments/${response.data.data.id}/view`)
-  } 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 response = await (isEdit.value ? paymentStore.updatePayment(data) : paymentStore.addPayment(data))
+    await router.push(`/admin/payments/${response.data.data.id}/view`)
+  } catch (error) {
+    const normalized = handleApiError(error)
     const translationKey = getErrorTranslationKey(normalized.message)
-
-    notificationStore.showNotification({
-      type: 'error',
-      message: translationKey ? t(translationKey) : normalized.message,
-    })
+    notificationStore.showNotification({ type: 'error', message: translationKey ? t(translationKey) : normalized.message })
+  } finally {
+    isSaving.value = false
   }
 }
 
diff --git a/resources/scripts/features/company/payments/views/PaymentDetailView.vue b/resources/scripts/features/company/payments/views/PaymentDetailView.vue
index 56c5bc32..dc687623 100644
--- a/resources/scripts/features/company/payments/views/PaymentDetailView.vue
+++ b/resources/scripts/features/company/payments/views/PaymentDetailView.vue
@@ -150,6 +150,26 @@
       </div>
     </div>
 
+    <BaseCard v-if="currentPayment.id" class="mb-4">
+      <div class="flex flex-wrap items-center justify-between gap-4 mb-3">
+        <h2 class="text-base font-semibold text-heading">{{ $t('payments.allocations') }}</h2>
+        <div class="text-sm text-muted">
+          {{ $t('payments.unapplied_credit') }}:
+          <BaseFormatMoney :amount="paymentUnallocatedAmount" :currency="currentPayment.customer?.currency" />
+        </div>
+      </div>
+      <div v-if="paymentAllocations.length" class="divide-y divide-line-light">
+        <div v-for="allocation in paymentAllocations" :key="allocation.id ?? allocation.invoice_id" class="flex items-center justify-between gap-4 py-3 text-sm">
+          <router-link v-if="allocation.invoice" :to="`/admin/invoices/${allocation.invoice.id}/view`" class="font-medium text-primary-500">
+            {{ allocation.invoice.invoice_number }}
+          </router-link>
+          <span v-else class="font-medium text-heading">{{ $t('payments.invoice') }}</span>
+          <BaseFormatMoney :amount="allocation.amount" :currency="currentPayment.customer?.currency" class="font-medium text-heading" />
+        </div>
+      </div>
+      <p v-else class="py-2 text-sm text-muted">{{ $t('payments.no_allocations') }}</p>
+    </BaseCard>
+
     <!-- PDF Preview -->
     <BasePdfPreview :src="shareableLink" />
 
@@ -167,7 +187,7 @@ import SendPaymentModal from '../components/SendPaymentModal.vue'
 import LoadingIcon from '@/scripts/components/icons/LoadingIcon.vue'
 import { useUserStore } from '../../../../stores/user.store'
 import { useModalStore } from '../../../../stores/modal.store'
-import type { Payment } from '../../../../types/domain/payment'
+import type { Payment, PaymentAllocation } from '../../../../types/domain/payment'
 
 interface Props {
   canEdit?: boolean
@@ -246,6 +266,10 @@ const shareableLink = computed<string | false>(() => {
   return hash ? `/payments/pdf/${hash}` : false
 })
 
+const currentPayment = computed<Payment>(() => paymentData.value as Payment)
+const paymentAllocations = computed<PaymentAllocation[]>(() => (paymentData.value as Payment).allocations ?? [])
+const paymentUnallocatedAmount = computed<number>(() => (paymentData.value as Payment).unallocated_amount ?? 0)
+
 watch(route, () => {
   loadPayment()
 })
diff --git a/resources/scripts/features/company/payments/views/PaymentIndexView.vue b/resources/scripts/features/company/payments/views/PaymentIndexView.vue
index d7598ff8..e04c3b37 100644
--- a/resources/scripts/features/company/payments/views/PaymentIndexView.vue
+++ b/resources/scripts/features/company/payments/views/PaymentIndexView.vue
@@ -171,15 +171,23 @@
           </span>
         </template>
 
-        <template #cell-invoice_number="{ row }">
-          <router-link
-            v-if="row.data.invoice?.id"
-            :to="`/admin/invoices/${row.data.invoice.id}/view`"
-            class="font-medium text-primary-500 hover:text-primary-600"
-          >
-            {{ row.data.invoice.invoice_number }}
-          </router-link>
-          <span v-else>-</span>
+        <template #cell-allocations="{ row }">
+          <div v-if="row.data.allocations?.length" class="space-y-1">
+            <template v-for="allocation in row.data.allocations" :key="allocation.id ?? allocation.invoice_id">
+              <div v-if="allocation.invoice" class="flex items-center gap-2">
+                <router-link
+                  :to="`/admin/invoices/${allocation.invoice.id}/view`"
+                  class="font-medium text-primary-500 hover:text-primary-600"
+                >
+                  {{ allocation.invoice.invoice_number }}
+                </router-link>
+                <BasePaidStatusBadge :status="allocation.invoice.paid_status" class="px-1 py-0.5">
+                  <BaseInvoiceStatusLabel :status="allocation.invoice.paid_status" />
+                </BasePaidStatusBadge>
+              </div>
+            </template>
+          </div>
+          <span v-else>{{ $t('payments.unapplied_credit') }}</span>
         </template>
 
         <template #cell-amount="{ row }">
@@ -311,7 +319,7 @@ const paymentColumns = computed<TableColumn[]>(() => [
   { key: 'payment_number', label: t('payments.payment_number') },
   { key: 'name', label: t('payments.customer') },
   { key: 'payment_mode', label: t('payments.payment_mode') },
-  { key: 'invoice_number', label: t('payments.invoice') },
+  { key: 'allocations', label: t('payments.allocations'), sortable: false },
   { key: 'amount', label: t('payments.amount') },
   {
     key: 'actions',
@@ -374,7 +382,7 @@ async function fetchData({ page, sort }: FetchParams): Promise<FetchResult> {
       : undefined,
     payment_number: filters.payment_number || undefined,
     orderByField: sort.fieldName || 'created_at',
-    orderBy: sort.order || 'desc',
+    orderBy: sort.order === 'asc' ? 'asc' as const : 'desc' as const,
     page,
   }
 
diff --git a/resources/scripts/features/customer-portal/views/CustomerPaymentsView.vue b/resources/scripts/features/customer-portal/views/CustomerPaymentsView.vue
index e0b2343e..2402f483 100644
--- a/resources/scripts/features/customer-portal/views/CustomerPaymentsView.vue
+++ b/resources/scripts/features/customer-portal/views/CustomerPaymentsView.vue
@@ -87,10 +87,11 @@
           </span>
         </template>
 
-        <template #cell-invoice_number="{ row }">
-          <span>
-            {{ row.data.invoice?.invoice_number ?? $t('payments.no_invoice') }}
+        <template #cell-allocations="{ row }">
+          <span v-if="row.data.allocations?.length">
+            {{ allocationReferences(row.data.allocations) }}
           </span>
+          <span v-else>{{ $t('payments.no_invoice') }}</span>
         </template>
 
         <template #cell-amount="{ row }">
@@ -123,7 +124,7 @@ import { ref, computed, reactive } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { debouncedWatch } from '@vueuse/core'
 import { useCustomerPortalStore } from '../store'
-import type { Payment, PaymentMethod } from '../../../types/domain/payment'
+import type { Payment, PaymentAllocation, PaymentMethod } from '../../../types/domain/payment'
 
 const store = useCustomerPortalStore()
 const { t } = useI18n()
@@ -163,7 +164,7 @@ const paymentColumns = computed<TableColumn[]>(() => [
   },
   { key: 'payment_number', label: t('payments.payment_number') },
   { key: 'payment_mode', label: t('payments.payment_mode') },
-  { key: 'invoice_number', label: t('invoices.invoice_number') },
+  { key: 'allocations', label: t('invoices.invoice_number'), sortable: false },
   { key: 'amount', label: t('payments.amount') },
   {
     key: 'actions',
@@ -179,6 +180,13 @@ async function searchPaymentModes(search: string): Promise<PaymentMethod[]> {
   return store.fetchPaymentModes(search)
 }
 
+function allocationReferences(allocations: PaymentAllocation[] | undefined): string {
+  return allocations
+    ?.map((allocation) => allocation.invoice?.invoice_number)
+    .filter(Boolean)
+    .join(', ') ?? ''
+}
+
 interface FetchParams {
   page: number
   filter: Record<string, unknown>
diff --git a/resources/scripts/types/domain/customer.ts b/resources/scripts/types/domain/customer.ts
index 907164ee..99440bc2 100644
--- a/resources/scripts/types/domain/customer.ts
+++ b/resources/scripts/types/domain/customer.ts
@@ -31,6 +31,9 @@ export interface Customer {
   avatar: string | number
   due_amount: number | null
   base_due_amount: number | null
+  invoice_due_amount?: number | null
+  available_credit?: number | null
+  account_balance?: number | null
   prefix: string | null
   tax_id: string | null
   billing?: Address
diff --git a/resources/scripts/types/domain/invoice.ts b/resources/scripts/types/domain/invoice.ts
index 976677e7..10af108c 100644
--- a/resources/scripts/types/domain/invoice.ts
+++ b/resources/scripts/types/domain/invoice.ts
@@ -5,6 +5,18 @@ import type { Currency } from './currency'
 import type { Tax } from './tax'
 import type { CustomFieldValue } from './custom-field'
 
+export interface InvoicePaymentAllocation {
+  id: number
+  payment_id: number
+  amount: number
+  base_amount?: number
+  payment?: {
+    id: number
+    payment_number: string
+    formatted_payment_date?: string
+  }
+}
+
 export enum InvoiceStatus {
   DRAFT = 'DRAFT',
   SENT = 'SENT',
@@ -120,6 +132,7 @@ export interface Invoice {
   sales_tax_type: string | null
   sales_tax_address_type: string | null
   overdue: boolean | null
+  payment_allocations?: InvoicePaymentAllocation[]
   items?: InvoiceItem[]
   customer?: Customer
   creator?: User
diff --git a/resources/scripts/types/domain/payment.ts b/resources/scripts/types/domain/payment.ts
index da4cd865..27b308c4 100644
--- a/resources/scripts/types/domain/payment.ts
+++ b/resources/scripts/types/domain/payment.ts
@@ -31,7 +31,6 @@ export interface Payment {
   notes: string | null
   amount: number
   unique_hash: string
-  invoice_id: number | null
   company_id: number
   payment_method_id: number | null
   creator_id: number
@@ -45,7 +44,11 @@ export interface Payment {
   formatted_payment_date: string
   payment_pdf_url: string
   customer?: Customer
-  invoice?: Invoice
+  allocations?: PaymentAllocation[]
+  allocated_amount?: number
+  unallocated_amount?: number
+  base_allocated_amount?: number
+  base_unallocated_amount?: number
   payment_method?: PaymentMethod
   fields?: CustomFieldValue[]
   company?: Company
@@ -53,12 +56,20 @@ export interface Payment {
   transaction?: Transaction
 }
 
+export interface PaymentAllocation {
+  id?: number
+  invoice_id: number
+  amount: number
+  base_amount?: number
+  invoice?: Invoice
+}
+
 export interface CreatePaymentPayload {
   payment_date: string
   payment_number: string
   customer_id: number
   amount: number
-  invoice_id?: number | null
+  allocations?: Array<Pick<PaymentAllocation, 'invoice_id' | 'amount'>>
   payment_method_id?: number | null
   notes?: string | null
   exchange_rate?: number
diff --git a/resources/scripts/utils/error-handling.ts b/resources/scripts/utils/error-handling.ts
index c2c8814f..1107ba3b 100644
--- a/resources/scripts/utils/error-handling.ts
+++ b/resources/scripts/utils/error-handling.ts
@@ -58,6 +58,25 @@ const ERROR_TRANSLATION_MAP: Record<string, string> = {
   'credit_note_must_credit_something': 'errors.credit_note_must_credit_something',
   'payment_amount_exceeds_invoice_due_amount':
     'errors.payment_amount_exceeds_invoice_due_amount',
+  'payment_amount_must_be_positive': 'payments.invalid_amount_message',
+  'payment_allocation_required': 'errors.payment_allocation_required',
+  'payment_allocation_invalid': 'errors.payment_allocation_invalid',
+  'payment_allocation_duplicate_invoice': 'errors.payment_allocation_duplicate_invoice',
+  'payment_allocation_exceeds_payment_amount':
+    'errors.payment_allocation_exceeds_payment_amount',
+  'payment_allocation_payment_not_found':
+    'errors.payment_allocation_payment_not_found',
+  'payment_allocation_invoice_not_found':
+    'errors.payment_allocation_invoice_not_found',
+  'payment_allocation_invoice_mismatch':
+    'errors.payment_allocation_invoice_mismatch',
+  'payment_allocation_invoice_not_payable':
+    'errors.payment_allocation_invoice_not_payable',
+  'payment_allocation_exceeds_invoice_balance':
+    'errors.payment_allocation_exceeds_invoice_balance',
+  'payment_customer_change_requires_unallocated_credit':
+    'errors.payment_customer_change_requires_unallocated_credit',
+  'invoice_has_payment_allocations': 'errors.payment_attached',
   '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',
diff --git a/resources/views/app/pdf/payment/payment.blade.php b/resources/views/app/pdf/payment/payment.blade.php
index 35de3b75..529b9cb4 100644
--- a/resources/views/app/pdf/payment/payment.blade.php
+++ b/resources/views/app/pdf/payment/payment.blade.php
@@ -344,14 +344,23 @@
                         <td class="attribute-value">
                             &nbsp;{{ $payment->paymentMethod ? $payment->paymentMethod->name : '-' }}</td>
                     </tr>
-                    @if ($payment->invoice && $payment->invoice->invoice_number)
+                    @foreach ($payment->allocations as $allocation)
+                        @if ($allocation->invoice && $allocation->invoice->invoice_number)
+                            <tr>
+                                <td class="attribute-label">@lang('pdf_invoice_label')</td>
+                                <td class="attribute-value"> &nbsp;{{ $allocation->invoice->invoice_number }}</td>
+                            </tr>
+                            <tr>
+                                <td class="attribute-label">@lang('customers.applied')</td>
+                                <td class="attribute-value"> &nbsp;{!! format_money_pdf($allocation->amount, $allocation->invoice->currency) !!}</td>
+                            </tr>
+                        @endif
+                    @endforeach
+                    @php($unallocatedAmount = (int) $payment->amount - (int) $payment->allocations->sum('amount'))
+                    @if ($unallocatedAmount > 0)
                         <tr>
-                            <td class="attribute-label">@lang('pdf_invoice_label')</td>
-                            <td class="attribute-value"> &nbsp;{{ $payment->invoice->invoice_number }}</td>
-                        </tr>
-                        <tr>
-                            <td class="attribute-label">Invoice Amount</td>
-                            <td class="attribute-value"> &nbsp;{!! format_money_pdf($payment->invoice->total, $payment->invoice->currency) !!}</td>
+                            <td class="attribute-label">@lang('unapplied_credit')</td>
+                            <td class="attribute-value"> &nbsp;{!! format_money_pdf($unallocatedAmount, $payment->customer->currency) !!}</td>
                         </tr>
                     @endif
                 </table>
@@ -362,12 +371,6 @@
     <div class="total-display-box">
         <p class="total-display-label">@lang('pdf_payment_amount_received_label')</p>
         <span class="amount">{!! format_money_pdf($payment->amount, $payment->customer->currency) !!}</span>
-        @if ($payment->invoice && $payment->invoice->invoice_number)
-            <br><p class="total-display-label">Balance Due</p>
-            <span class="amount">{!! $payment->invoice->formattedDueAmount !!}</span>
-            <br><p class="total-display-label">Invoice Status</p>
-            <span class="amount">{{ str_replace('_', ' ', optional($payment->invoice)->paid_status ?? optional($payment->invoice)->status) }}</span>
-        @endif
     </div>
     <div class="notes">
         @if ($notes)
diff --git a/resources/views/app/pdf/reports/customer-statement.blade.php b/resources/views/app/pdf/reports/customer-statement.blade.php
new file mode 100644
index 00000000..b039eb7a
--- /dev/null
+++ b/resources/views/app/pdf/reports/customer-statement.blade.php
@@ -0,0 +1,129 @@
+<!DOCTYPE html>
+<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
+<head>
+    <title>{{ __('Customer Statement') }}</title>
+    @include('app.pdf.partials.fonts')
+    @include('app.pdf.reports.partials.styles')
+</head>
+<body>
+    <table class="report-header">
+        <tr>
+            <td>
+                @if (! empty($logo))
+                    <img class="report-logo" style="height:40px" src="{{ \App\Support\Pdf\ImageUtils::toBase64Src($logo) }}" alt="{{ $company->name }}">
+                @else
+                    <p class="report-company-name">{{ $company->name }}</p>
+                @endif
+            </td>
+            <td>
+                <p class="report-date-range">
+                    @if ($statement['type'] === 'activity')
+                        {{ $statement['from_date'] }} - {{ $statement['to_date'] }}
+                    @else
+                        {{ __('As of') }} {{ $statement['as_of'] }}
+                    @endif
+                </p>
+            </td>
+        </tr>
+    </table>
+
+    <p class="report-title">{{ __('Customer Statement') }} — {{ $customer->name }}</p>
+
+    @if ($statement['type'] === 'activity')
+        <div class="report-section">
+            <table class="report-table">
+                <thead>
+                    <tr>
+                        <th>{{ __('Date') }}</th>
+                        <th>{{ __('Description') }}</th>
+                        <th>{{ __('Reference') }}</th>
+                        <th class="report-amount">{{ __('Debit') }}</th>
+                        <th class="report-amount">{{ __('Credit') }}</th>
+                        <th class="report-amount">{{ __('Balance') }}</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td colspan="5" class="report-total">{{ __('Opening balance') }}</td>
+                        <td class="report-amount report-total">{!! format_money_pdf($statement['opening_balance'], $currency) !!}</td>
+                    </tr>
+                    @forelse ($statement['entries']->items() as $entry)
+                        <tr>
+                            <td>{{ $entry['date'] }}</td>
+                            <td>{{ $entry['description'] }}</td>
+                            <td>{{ $entry['reference'] }}</td>
+                            <td class="report-amount">{!! $entry['debit_amount'] ? format_money_pdf($entry['debit_amount'], $currency) : '' !!}</td>
+                            <td class="report-amount">{!! $entry['credit_amount'] ? format_money_pdf($entry['credit_amount'], $currency) : '' !!}</td>
+                            <td class="report-amount">{!! format_money_pdf($entry['balance'], $currency) !!}</td>
+                        </tr>
+                    @empty
+                        <tr><td class="report-muted" colspan="6">@lang('pdf_report_no_records')</td></tr>
+                    @endforelse
+                    <tr class="report-total-row">
+                        <td colspan="5" class="report-total">{{ __('Closing balance') }}</td>
+                        <td class="report-amount report-total">{!! format_money_pdf($statement['closing_balance'], $currency) !!}</td>
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+    @else
+        <div class="report-section">
+            <p class="report-section-heading">{{ __('Outstanding invoices') }}</p>
+            <table class="report-table">
+                <thead>
+                    <tr>
+                        <th>{{ __('Invoice') }}</th>
+                        <th>{{ __('Due date') }}</th>
+                        <th class="report-amount">{{ __('Original') }}</th>
+                        <th class="report-amount">{{ __('Applied') }}</th>
+                        <th class="report-amount">{{ __('Remaining') }}</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    @forelse ($statement['invoices'] as $invoice)
+                        <tr>
+                            <td>{{ $invoice['invoice_number'] }}</td>
+                            <td>{{ $invoice['due_date'] }}</td>
+                            <td class="report-amount">{!! format_money_pdf($invoice['original_amount'], $currency) !!}</td>
+                            <td class="report-amount">{!! format_money_pdf($invoice['applied_amount'], $currency) !!}</td>
+                            <td class="report-amount">{!! format_money_pdf($invoice['remaining_amount'], $currency) !!}</td>
+                        </tr>
+                    @empty
+                        <tr><td class="report-muted" colspan="5">@lang('pdf_report_no_records')</td></tr>
+                    @endforelse
+                </tbody>
+            </table>
+        </div>
+
+        <div class="report-section">
+            <p class="report-section-heading">{{ __('Available credit') }}</p>
+            <table class="report-table">
+                <thead><tr><th>{{ __('Payment') }}</th><th>{{ __('Date') }}</th><th class="report-amount">{{ __('Available') }}</th></tr></thead>
+                <tbody>
+                    @forelse ($statement['credits'] as $credit)
+                        <tr>
+                            <td>{{ $credit['payment_number'] }}</td>
+                            <td>{{ $credit['payment_date'] }}</td>
+                            <td class="report-amount">{!! format_money_pdf($credit['available_amount'], $currency) !!}</td>
+                        </tr>
+                    @empty
+                        <tr><td class="report-muted" colspan="3">@lang('pdf_report_no_records')</td></tr>
+                    @endforelse
+                    <tr>
+                        <td colspan="2" class="report-total">{{ __('Gross invoice due') }}</td>
+                        <td class="report-amount report-total">{!! format_money_pdf($statement['invoice_due_amount'], $currency) !!}</td>
+                    </tr>
+                    <tr>
+                        <td colspan="2" class="report-total">{{ __('Available credit') }}</td>
+                        <td class="report-amount report-total">{!! format_money_pdf($statement['available_credit'], $currency) !!}</td>
+                    </tr>
+                    <tr class="report-total-row">
+                        <td colspan="2" class="report-total">{{ __('Net account balance') }}</td>
+                        <td class="report-amount report-total">{!! format_money_pdf($statement['account_balance'], $currency) !!}</td>
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+    @endif
+</body>
+</html>
diff --git a/resources/views/emails/send/customer-statement.blade.php b/resources/views/emails/send/customer-statement.blade.php
new file mode 100644
index 00000000..2a12b12a
--- /dev/null
+++ b/resources/views/emails/send/customer-statement.blade.php
@@ -0,0 +1,19 @@
+@component('mail::layout')
+    @slot('header')
+        @component('mail::header', ['url' => ''])
+            {{ $data['customer']->company->name }}
+        @endcomponent
+    @endslot
+
+    @slot('subcopy')
+        @component('mail::subcopy')
+            {!! $data['body'] !!}
+        @endcomponent
+    @endslot
+
+    @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 e2fbef30..d6111e0b 100644
--- a/routes/api.php
+++ b/routes/api.php
@@ -24,7 +24,9 @@ use App\Http\Controllers\Company\Auth\ForgotPasswordController;
 use App\Http\Controllers\Company\Auth\InvitationRegistrationController;
 use App\Http\Controllers\Company\Auth\ResetPasswordController;
 use App\Http\Controllers\Company\Customer\CustomersController;
+use App\Http\Controllers\Company\Customer\CustomerStatementController;
 use App\Http\Controllers\Company\Customer\CustomerStatsController;
+use App\Http\Controllers\Company\Customer\SendCustomerStatementController;
 use App\Http\Controllers\Company\CustomField\CustomFieldsController;
 use App\Http\Controllers\Company\Dashboard\DashboardController;
 use App\Http\Controllers\Company\Estimate\EstimatesController;
@@ -46,6 +48,7 @@ use App\Http\Controllers\Company\Item\UnitsController;
 use App\Http\Controllers\Company\Members\MembersController;
 use App\Http\Controllers\Company\Modules\CompanyModulesController;
 use App\Http\Controllers\Company\Modules\ModuleSettingsController;
+use App\Http\Controllers\Company\Payment\CreditAllocationsController;
 use App\Http\Controllers\Company\Payment\PaymentMethodsController;
 use App\Http\Controllers\Company\Payment\PaymentsController;
 use App\Http\Controllers\Company\RecurringInvoice\RecurringInvoiceController;
@@ -259,6 +262,10 @@ Route::prefix('/v1')->group(function () {
 
             Route::get('customers/{customer}/stats', CustomerStatsController::class);
 
+            Route::get('customers/{customer}/statement', CustomerStatementController::class);
+            Route::post('customers/{customer}/statement/send', SendCustomerStatementController::class);
+            Route::post('customers/{customer}/credit-allocations', [CreditAllocationsController::class, 'store']);
+
             Route::resource('customers', CustomersController::class);
 
             // Items
@@ -339,6 +346,8 @@ Route::prefix('/v1')->group(function () {
 
             Route::post('/payments/{payment}/send', [PaymentsController::class, 'send']);
 
+            Route::put('/payments/{payment}/allocations', [PaymentsController::class, 'replaceAllocations']);
+
             Route::post('/payments/delete', [PaymentsController::class, 'delete']);
 
             Route::apiResource('payments', PaymentsController::class);
diff --git a/routes/web.php b/routes/web.php
index aca1a2ef..79b02648 100644
--- a/routes/web.php
+++ b/routes/web.php
@@ -3,6 +3,7 @@
 use App\Http\Controllers\Company\Auth\LoginController;
 use App\Http\Controllers\Company\Expense\ExpensesController;
 use App\Http\Controllers\Company\Report\CustomerSalesReportController;
+use App\Http\Controllers\Company\Report\CustomerStatementReportController;
 use App\Http\Controllers\Company\Report\ExpensesReportController;
 use App\Http\Controllers\Company\Report\ItemSalesReportController;
 use App\Http\Controllers\Company\Report\ProfitLossReportController;
@@ -52,6 +53,8 @@ Route::post('/{company:slug}/customer/logout', function () {
 
 Route::middleware('auth:sanctum')->prefix('reports')->group(function () {
 
+    Route::get('/customers/{customer}/statement', CustomerStatementReportController::class);
+
     // sales report by customer
     // ----------------------------------
     Route::get('/sales/customers/{hash}', CustomerSalesReportController::class);
diff --git a/tests/Feature/Admin/CreditNoteTest.php b/tests/Feature/Admin/CreditNoteTest.php
index 4f1fbc42..fabaec20 100644
--- a/tests/Feature/Admin/CreditNoteTest.php
+++ b/tests/Feature/Admin/CreditNoteTest.php
@@ -7,6 +7,7 @@ use App\Models\CompanySetting;
 use App\Models\Invoice;
 use App\Models\InvoiceItem;
 use App\Models\Payment;
+use App\Models\PaymentAllocation;
 use App\Models\Tax;
 use App\Models\User;
 use App\Services\Document\CreditNoteService;
@@ -138,11 +139,18 @@ function creditableTax(Invoice $invoice, array $tax, array $owner): Tax
 function creditablePayment(Invoice $invoice, int $amount): Payment
 {
     $payment = Payment::factory()->create([
-        'invoice_id' => $invoice->id,
+        'company_id' => $invoice->company_id,
         'customer_id' => $invoice->customer_id,
         'amount' => $amount,
     ]);
 
+    PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $invoice->id,
+        'amount' => $amount,
+        'base_amount' => (int) round($amount * $invoice->exchange_rate),
+    ]);
+
     $due = (int) $invoice->due_amount - $amount;
 
     $invoice->due_amount = $due;
diff --git a/tests/Feature/Admin/CustomerTest.php b/tests/Feature/Admin/CustomerTest.php
index a9dbe36e..8088eed3 100644
--- a/tests/Feature/Admin/CustomerTest.php
+++ b/tests/Feature/Admin/CustomerTest.php
@@ -33,6 +33,21 @@ test('get customers', function () {
     $response->assertOk();
 });
 
+test('get all customers hydrates account summaries without pagination', function () {
+    $customer = Customer::factory()->create([
+        'company_id' => User::find(1)->companies()->first()->id,
+    ]);
+
+    getJson('api/v1/customers?limit=all')
+        ->assertOk()
+        ->assertJsonFragment([
+            'id' => $customer->id,
+            'invoice_due_amount' => 0,
+            'available_credit' => 0,
+            'account_balance' => 0,
+        ]);
+});
+
 test('customer stats', function () {
     $customer = Customer::factory()->create();
 
diff --git a/tests/Feature/Admin/InvoicePaymentAllocationDetailTest.php b/tests/Feature/Admin/InvoicePaymentAllocationDetailTest.php
new file mode 100644
index 00000000..c27e0bf5
--- /dev/null
+++ b/tests/Feature/Admin/InvoicePaymentAllocationDetailTest.php
@@ -0,0 +1,47 @@
+<?php
+
+use App\Models\Customer;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
+use App\Models\User;
+use Illuminate\Support\Facades\Artisan;
+use Laravel\Sanctum\Sanctum;
+
+use function Pest\Laravel\getJson;
+
+beforeEach(function () {
+    Artisan::call('db:seed', ['--class' => 'DatabaseSeeder', '--force' => true]);
+    Artisan::call('db:seed', ['--class' => 'DemoSeeder', '--force' => true]);
+
+    $user = User::findOrFail(1);
+    $this->company = $user->companies()->firstOrFail();
+    $this->withHeaders(['company' => $this->company->id]);
+    Sanctum::actingAs($user, ['*']);
+});
+
+test('invoice detail returns allocation rows with their payments', function () {
+    $customer = Customer::factory()->create(['company_id' => $this->company->id]);
+    $invoice = Invoice::factory()->create([
+        'company_id' => $this->company->id,
+        'customer_id' => $customer->id,
+    ]);
+    $payment = Payment::factory()->create([
+        'company_id' => $this->company->id,
+        'customer_id' => $customer->id,
+    ]);
+    $allocation = PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $invoice->id,
+        'amount' => 500,
+        'base_amount' => 500,
+    ]);
+
+    getJson("api/v1/invoices/{$invoice->id}")
+        ->assertOk()
+        ->assertJsonPath('data.payment_allocations.0.id', $allocation->id)
+        ->assertJsonPath('data.payment_allocations.0.payment_id', $payment->id)
+        ->assertJsonPath('data.payment_allocations.0.amount', 500)
+        ->assertJsonPath('data.payment_allocations.0.payment.id', $payment->id)
+        ->assertJsonPath('data.payment_allocations.0.payment.payment_number', $payment->payment_number);
+});
diff --git a/tests/Feature/Admin/InvoiceTest.php b/tests/Feature/Admin/InvoiceTest.php
index cc33ae03..91fa96ac 100644
--- a/tests/Feature/Admin/InvoiceTest.php
+++ b/tests/Feature/Admin/InvoiceTest.php
@@ -8,6 +8,7 @@ use App\Models\Company;
 use App\Models\Invoice;
 use App\Models\InvoiceItem;
 use App\Models\Payment;
+use App\Models\PaymentAllocation;
 use App\Models\Tax;
 use App\Models\User;
 use Illuminate\Support\Facades\Artisan;
@@ -306,8 +307,13 @@ test('cannot complete a partially paid invoice', function () {
     $payment = Payment::factory()->create([
         'company_id' => $invoice->company_id,
         'customer_id' => $invoice->customer_id,
+        'amount' => 5000,
+    ]);
+    PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
         'invoice_id' => $invoice->id,
         'amount' => 5000,
+        'base_amount' => 5000,
     ]);
 
     $invoice->update(['paid_status' => Invoice::STATUS_PARTIALLY_PAID]);
@@ -344,8 +350,13 @@ test('completes a fully paid invoice idempotently without removing its payment',
     $payment = Payment::factory()->create([
         'company_id' => $invoice->company_id,
         'customer_id' => $invoice->customer_id,
+        'amount' => 10000,
+    ]);
+    PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
         'invoice_id' => $invoice->id,
         'amount' => 10000,
+        'base_amount' => 10000,
     ]);
 
     postJson("api/v1/invoices/{$invoice->id}/status", ['status' => Invoice::STATUS_COMPLETED])
diff --git a/tests/Feature/Admin/PaymentTest.php b/tests/Feature/Admin/PaymentTest.php
index 6a5c3b14..7fda2583 100644
--- a/tests/Feature/Admin/PaymentTest.php
+++ b/tests/Feature/Admin/PaymentTest.php
@@ -7,6 +7,7 @@ use App\Models\Invoice;
 use App\Models\Payment;
 use App\Models\User;
 use App\Services\Document\CreditNoteService;
+use App\Services\Document\PaymentAllocationService;
 use Illuminate\Support\Facades\Artisan;
 use Laravel\Sanctum\Sanctum;
 
@@ -85,17 +86,20 @@ function payableInvoice(int $lines = 2, int $price = 10000): Invoice
 }
 
 /**
- * A payment payload aimed at an invoice, with everything the cap depends on
- * pinned so the request is decided by the amount alone.
+ * A payment payload with an explicit allocation instead of the retired
+ * singular invoice_id field.
  */
 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,
+        'allocations' => [[
+            'invoice_id' => $invoice->id,
+            'amount' => $amount,
+        ]],
     ]);
 }
 
@@ -115,15 +119,28 @@ test('get payment', function () {
 
 test('create payment', function () {
     $invoice = Invoice::factory()->create([
+        'type' => Invoice::TYPE_INVOICE,
+        'status' => Invoice::STATUS_SENT,
+        'sent' => true,
+        'sub_total' => 100,
+        'total' => 100,
         'due_amount' => 100,
+        'base_sub_total' => 100,
+        'base_total' => 100,
+        'base_due_amount' => 100,
         'exchange_rate' => 1,
     ]);
 
     $payment = Payment::factory()->raw([
-        'invoice_id' => $invoice->id,
         'payment_number' => 'PAY-000001',
+        'customer_id' => $invoice->customer_id,
+        'currency_id' => $invoice->currency_id,
         'amount' => $invoice->due_amount,
         'exchange_rate' => 1,
+        'allocations' => [[
+            'invoice_id' => $invoice->id,
+            'amount' => $invoice->due_amount,
+        ]],
     ]);
 
     $response = postJson('api/v1/payments', $payment);
@@ -136,6 +153,35 @@ test('create payment', function () {
         'amount' => $payment['amount'],
         'company_id' => $payment['company_id'],
     ]);
+
+    $response->assertJsonMissingPath('data.invoice_id')
+        ->assertJsonMissingPath('data.invoice');
+});
+
+test('the retired singular invoice field is rejected', function () {
+    $invoice = payableInvoice();
+    $payment = Payment::factory()->raw([
+        'customer_id' => $invoice->customer_id,
+        'currency_id' => $invoice->currency_id,
+        'amount' => $invoice->due_amount,
+        'exchange_rate' => 1,
+        'invoice_id' => $invoice->id,
+    ]);
+
+    postJson('api/v1/payments', $payment)
+        ->assertUnprocessable()
+        ->assertJsonValidationErrors('invoice_id');
+});
+
+test('an explicitly null allocation list is rejected instead of causing a server error', function () {
+    $payment = Payment::factory()->raw([
+        'exchange_rate' => 1,
+        'allocations' => null,
+    ]);
+
+    postJson('api/v1/payments', $payment)
+        ->assertUnprocessable()
+        ->assertJsonValidationErrors('allocations');
 });
 
 test('store validates using a form request', function () {
@@ -152,6 +198,9 @@ test('update payment', function () {
     // 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([
+        'type' => Invoice::TYPE_INVOICE,
+        'status' => Invoice::STATUS_SENT,
+        'sent' => true,
         'sub_total' => 10000,
         'total' => 10000,
         'due_amount' => 4000,
@@ -163,17 +212,27 @@ test('update payment', function () {
 
     $payment = Payment::factory()->create([
         'payment_date' => '1988-08-18',
-        'invoice_id' => $invoice->id,
+        'company_id' => $invoice->company_id,
+        'customer_id' => $invoice->customer_id,
+        'currency_id' => $invoice->currency_id,
         'exchange_rate' => 1,
         'amount' => 6000,
     ]);
+    app(PaymentAllocationService::class)->replace($payment, [
+        ['invoice_id' => $invoice->id, '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,
+        'customer_id' => $invoice->customer_id,
+        'currency_id' => $invoice->currency_id,
         'exchange_rate' => 1,
         'amount' => 10000,
+        'allocations' => [[
+            'invoice_id' => $invoice->id,
+            'amount' => 10000,
+        ]],
     ]);
 
     putJson("api/v1/payments/{$payment->id}", $payment2)
@@ -187,6 +246,66 @@ test('update payment', function () {
     ]);
 });
 
+test('updating a payment without allocations preserves its existing allocations', function () {
+    $invoice = payableInvoice(1, 500);
+    $payment = Payment::factory()->create([
+        'company_id' => $invoice->company_id,
+        'customer_id' => $invoice->customer_id,
+        'currency_id' => $invoice->currency_id,
+        'amount' => 500,
+        'base_amount' => 500,
+        'exchange_rate' => 1,
+    ]);
+    app(PaymentAllocationService::class)->replace($payment, [
+        ['invoice_id' => $invoice->id, 'amount' => 500],
+    ]);
+
+    $payload = Payment::factory()->raw([
+        'payment_number' => $payment->payment_number,
+        'payment_date' => (string) $payment->payment_date,
+        'customer_id' => $payment->customer_id,
+        'currency_id' => $payment->currency_id,
+        'amount' => 500,
+        'exchange_rate' => 1,
+        'notes' => 'Updated without replacing allocations',
+    ]);
+
+    putJson("api/v1/payments/{$payment->id}", $payload)->assertOk();
+
+    expect($payment->fresh()->allocations()->count())->toBe(1)
+        ->and($payment->fresh()->allocations()->sum('amount'))->toBe(500)
+        ->and($invoice->fresh()->due_amount)->toBe(0);
+});
+
+test('replace allocations endpoint moves a payment between invoices', function () {
+    $first = payableInvoice(1, 500);
+    $second = payableInvoice(1, 500);
+    $second->update([
+        'company_id' => $first->company_id,
+        'customer_id' => $first->customer_id,
+        'currency_id' => $first->currency_id,
+    ]);
+    $payment = Payment::factory()->create([
+        'company_id' => $first->company_id,
+        'customer_id' => $first->customer_id,
+        'currency_id' => $first->currency_id,
+        'amount' => 500,
+        'base_amount' => 500,
+        'exchange_rate' => 1,
+    ]);
+    app(PaymentAllocationService::class)->replace($payment, [
+        ['invoice_id' => $first->id, 'amount' => 500],
+    ]);
+
+    putJson("api/v1/payments/{$payment->id}/allocations", [
+        'allocations' => [['invoice_id' => $second->id, 'amount' => 500]],
+    ])->assertOk()
+        ->assertJsonPath('data.allocations.0.invoice_id', $second->id);
+
+    expect($first->fresh()->due_amount)->toBe(500)
+        ->and($second->fresh()->due_amount)->toBe(0);
+});
+
 test('update validates using a form request', function () {
     $this->assertActionUsesFormRequest(
         PaymentsController::class,
@@ -265,16 +384,21 @@ test('create payment without invoice', function () {
 });
 
 test('create payment with invoice', function () {
-    $payment = Payment::factory()->raw([
-        'payment_number' => 'PAY-000001',
+    $invoice = Invoice::factory()->create([
+        'type' => Invoice::TYPE_INVOICE,
+        'status' => Invoice::STATUS_SENT,
+        'sent' => true,
     ]);
 
-    $invoice = Invoice::factory()->create();
-
     $payment = Payment::factory()->raw([
-        'invoice_id' => $invoice->id,
+        'customer_id' => $invoice->customer_id,
+        'currency_id' => $invoice->currency_id,
         'amount' => $invoice->due_amount,
         'exchange_rate' => 1,
+        'allocations' => [[
+            'invoice_id' => $invoice->id,
+            'amount' => $invoice->due_amount,
+        ]],
     ]);
 
     postJson('api/v1/payments', $payment)->assertOk();
@@ -282,7 +406,6 @@ test('create payment with invoice', function () {
     $this->assertDatabaseHas('payments', [
         'payment_number' => $payment['payment_number'],
         'customer_id' => $payment['customer_id'],
-        'invoice_id' => $payment['invoice_id'],
         'amount' => $payment['amount'],
         'company_id' => $payment['company_id'],
     ]);
@@ -290,6 +413,9 @@ test('create payment with invoice', function () {
 
 test('create payment with partially paid', function () {
     $invoice = Invoice::factory()->create([
+        'type' => Invoice::TYPE_INVOICE,
+        'status' => Invoice::STATUS_SENT,
+        'sent' => true,
         'sub_total' => 100,
         'total' => 100,
         'due_amount' => 100,
@@ -302,11 +428,14 @@ test('create payment with partially paid', function () {
     ]);
 
     $payment = Payment::factory()->raw([
-        'invoice_id' => $invoice->id,
         'customer_id' => $invoice->customer_id,
         'exchange_rate' => $invoice->exchange_rate,
         'amount' => 100,
         'currency_id' => $invoice->currency_id,
+        'allocations' => [[
+            'invoice_id' => $invoice->id,
+            'amount' => 100,
+        ]],
     ]);
 
     $response = postJson('api/v1/payments', $payment)->assertOk();
@@ -319,12 +448,12 @@ test('create payment with partially paid', function () {
 
     $this->assertDatabaseHas('invoices', [
         'id' => $invoice['id'],
-        'invoice_number' => $response['data']['invoice']['invoice_number'],
-        'total' => $response['data']['invoice']['total'],
-        'customer_id' => $response['data']['invoice']['customer_id'],
-        'exchange_rate' => $response['data']['invoice']['exchange_rate'],
-        'base_total' => $response['data']['invoice']['base_total'],
-        'paid_status' => $response['data']['invoice']['paid_status'],
+        'invoice_number' => $response['data']['allocations'][0]['invoice']['invoice_number'],
+        'total' => $response['data']['allocations'][0]['invoice']['total'],
+        'customer_id' => $response['data']['allocations'][0]['invoice']['customer_id'],
+        'exchange_rate' => $response['data']['allocations'][0]['invoice']['exchange_rate'],
+        'base_total' => $response['data']['allocations'][0]['invoice']['base_total'],
+        'paid_status' => $response['data']['allocations'][0]['invoice']['paid_status'],
     ]);
 });
 
@@ -338,7 +467,7 @@ test('rejects a payment worth more than the invoice due amount', function () {
 
     postJson('api/v1/payments', paymentPayloadFor($invoice, 20001))
         ->assertStatus(422)
-        ->assertJsonPath('errors.amount.0', 'payment_amount_exceeds_invoice_due_amount');
+        ->assertJsonPath('errors.allocations.0', 'payment_allocation_exceeds_invoice_balance');
 
     $invoice->refresh();
 
@@ -376,7 +505,7 @@ test('rejects a payment worth more than the balance a partial credit note left',
 
     postJson('api/v1/payments', paymentPayloadFor($invoice, 10001))
         ->assertStatus(422)
-        ->assertJsonPath('errors.amount.0', 'payment_amount_exceeds_invoice_due_amount');
+        ->assertJsonPath('errors.allocations.0', 'payment_allocation_exceeds_invoice_balance');
 
     $invoice->refresh();
 
diff --git a/tests/Feature/Ai/Tools/ListRecentPaymentsToolTest.php b/tests/Feature/Ai/Tools/ListRecentPaymentsToolTest.php
new file mode 100644
index 00000000..992a3d2f
--- /dev/null
+++ b/tests/Feature/Ai/Tools/ListRecentPaymentsToolTest.php
@@ -0,0 +1,50 @@
+<?php
+
+use App\Models\Company;
+use App\Models\Customer;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
+use App\Services\Ai\Tools\ListRecentPaymentsTool;
+use Illuminate\Support\Facades\Artisan;
+
+beforeEach(function () {
+    Artisan::call('db:seed', ['--class' => 'DatabaseSeeder', '--force' => true]);
+    Artisan::call('db:seed', ['--class' => 'DemoSeeder', '--force' => true]);
+});
+
+test('list recent payments returns all allocations and unapplied credit', function () {
+    $company = Company::first();
+    $customer = Customer::factory()->create(['company_id' => $company->id]);
+    $invoice = Invoice::factory()->create([
+        'company_id' => $company->id,
+        'customer_id' => $customer->id,
+    ]);
+    $payment = Payment::factory()->create([
+        'company_id' => $company->id,
+        'customer_id' => $customer->id,
+        'amount' => 1000,
+        'base_amount' => 1000,
+        'payment_date' => now()->toDateString(),
+    ]);
+    PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $invoice->id,
+        'amount' => 600,
+        'base_amount' => 600,
+    ]);
+
+    $result = (new ListRecentPaymentsTool)->execute(['days' => 1], $company->id, 1);
+    $row = collect($result['payments'])->firstWhere('id', $payment->id);
+
+    expect($row)
+        ->toMatchArray([
+            'allocated_amount' => 600,
+            'unallocated_amount' => 400,
+        ])
+        ->not->toHaveKey('invoice_id')
+        ->and($row['allocations'])->toContain([
+            'invoice_id' => $invoice->id,
+            'amount' => 600,
+        ]);
+});
diff --git a/tests/Feature/CustomerStatementTest.php b/tests/Feature/CustomerStatementTest.php
new file mode 100644
index 00000000..df67fc35
--- /dev/null
+++ b/tests/Feature/CustomerStatementTest.php
@@ -0,0 +1,239 @@
+<?php
+
+use App\Mail\SendCustomerStatementMail;
+use App\Models\Company;
+use App\Models\Customer;
+use App\Models\EmailLog;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
+use App\Models\User;
+use Carbon\Carbon;
+use Illuminate\Support\Facades\Artisan;
+use Illuminate\Support\Facades\Mail;
+use Laravel\Sanctum\Sanctum;
+use Silber\Bouncer\BouncerFacade;
+
+use function Pest\Laravel\get;
+use function Pest\Laravel\getJson;
+use function Pest\Laravel\postJson;
+
+beforeEach(function () {
+    Artisan::call('db:seed', ['--class' => 'DatabaseSeeder', '--force' => true]);
+    Artisan::call('db:seed', ['--class' => 'DemoSeeder', '--force' => true]);
+
+    $this->user = User::findOrFail(1);
+    $this->company = $this->user->companies()->firstOrFail();
+    $this->withHeaders(['company' => $this->company->id]);
+    Sanctum::actingAs($this->user, ['*']);
+});
+
+function statementCustomer(): Customer
+{
+    return Customer::factory()->create([
+        'company_id' => test()->company->id,
+    ]);
+}
+
+function statementInvoice(Customer $customer, string $date, array $attributes = []): Invoice
+{
+    return Invoice::factory()->create(array_merge([
+        'company_id' => $customer->company_id,
+        'customer_id' => $customer->id,
+        'invoice_date' => $date,
+        'due_date' => $date,
+        'type' => Invoice::TYPE_INVOICE,
+        'status' => Invoice::STATUS_SENT,
+        'total' => 1000,
+        'base_total' => 1000,
+        'due_amount' => 1000,
+        'base_due_amount' => 1000,
+    ], $attributes));
+}
+
+function statementPayment(Customer $customer, string $date, int $amount = 1000): Payment
+{
+    return Payment::factory()->create([
+        'company_id' => $customer->company_id,
+        'customer_id' => $customer->id,
+        'payment_date' => $date,
+        'amount' => $amount,
+        'base_amount' => $amount,
+    ]);
+}
+
+test('activity statements calculate opening and closing balances and include draft credit notes', function () {
+    $customer = statementCustomer();
+    statementInvoice($customer, '2026-01-20', ['total' => 500, 'base_total' => 500]);
+    $invoice = statementInvoice($customer, '2026-02-10', ['total' => 1000, 'base_total' => 1000]);
+    $creditNote = statementInvoice($customer, '2026-02-10', [
+        'type' => Invoice::TYPE_CREDIT_NOTE,
+        'status' => Invoice::STATUS_DRAFT,
+        'total' => -200,
+        'base_total' => -200,
+        'due_amount' => 0,
+        'base_due_amount' => 0,
+    ]);
+    $payment = statementPayment($customer, '2026-02-10', 300);
+    statementInvoice($customer, '2026-02-11', [
+        'status' => Invoice::STATUS_DRAFT,
+        'total' => 999,
+        'base_total' => 999,
+    ]);
+
+    $response = getJson("/api/v1/customers/{$customer->id}/statement?from_date=2026-02-01&to_date=2026-02-28");
+
+    $response->assertOk()
+        ->assertJsonPath('data.opening_balance', 500)
+        ->assertJsonPath('data.closing_balance', 1000)
+        ->assertJsonPath('data.entries.0.id', $invoice->id)
+        ->assertJsonPath('data.entries.0.entry_type', 'invoice')
+        ->assertJsonPath('data.entries.1.id', $creditNote->id)
+        ->assertJsonPath('data.entries.1.entry_type', 'credit_note')
+        ->assertJsonPath('data.entries.2.id', $payment->id)
+        ->assertJsonPath('data.entries.2.entry_type', 'payment')
+        ->assertJsonCount(3, 'data.entries');
+});
+
+test('outstanding statements respect allocation timing for historical as-of dates', function () {
+    $customer = statementCustomer();
+    $invoice = statementInvoice($customer, '2026-01-10');
+    $payment = statementPayment($customer, '2026-01-15');
+    $allocation = PaymentAllocation::create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $invoice->id,
+        'amount' => 1000,
+        'base_amount' => 1000,
+    ]);
+    $allocation->forceFill(['created_at' => Carbon::parse('2026-02-05 09:00:00')])->save();
+
+    getJson("/api/v1/customers/{$customer->id}/statement?type=outstanding&as_of=2026-01-31")
+        ->assertOk()
+        ->assertJsonPath('data.invoice_due_amount', 1000)
+        ->assertJsonPath('data.available_credit', 1000)
+        ->assertJsonPath('data.account_balance', 0)
+        ->assertJsonCount(1, 'data.invoices')
+        ->assertJsonCount(1, 'data.credits');
+
+    getJson("/api/v1/customers/{$customer->id}/statement?type=outstanding&as_of=2026-02-28")
+        ->assertOk()
+        ->assertJsonPath('data.invoice_due_amount', 0)
+        ->assertJsonPath('data.available_credit', 0)
+        ->assertJsonCount(0, 'data.invoices')
+        ->assertJsonCount(0, 'data.credits');
+});
+
+test('customer account aggregates preserve due amount compatibility and show available credit', function () {
+    $customer = statementCustomer();
+    statementInvoice($customer, '2026-01-10', ['due_amount' => 600, 'base_due_amount' => 600]);
+    $payment = statementPayment($customer, '2026-01-15', 500);
+    PaymentAllocation::create([
+        'payment_id' => $payment->id,
+        'invoice_id' => statementInvoice($customer, '2026-01-11')->id,
+        'amount' => 200,
+        'base_amount' => 200,
+    ]);
+
+    getJson("/api/v1/customers/{$customer->id}")
+        ->assertOk()
+        ->assertJsonPath('data.due_amount', 1600)
+        ->assertJsonPath('data.invoice_due_amount', 1600)
+        ->assertJsonPath('data.available_credit', 300)
+        ->assertJsonPath('data.account_balance', 1300);
+});
+
+test('statements require both customer and financial-report abilities', function () {
+    $customer = statementCustomer();
+    $user = User::factory()->create();
+    $user->companies()->attach($this->company->id);
+
+    BouncerFacade::scope()->to($this->company->id);
+    BouncerFacade::allow($user)->to('view-customer', Customer::class);
+    Sanctum::actingAs($user, ['*']);
+
+    getJson("/api/v1/customers/{$customer->id}/statement")
+        ->assertForbidden();
+});
+
+test('statements cannot be read across companies', function () {
+    $otherCompany = Company::factory()->create();
+    $customer = Customer::factory()->create(['company_id' => $otherCompany->id]);
+
+    getJson("/api/v1/customers/{$customer->id}/statement")
+        ->assertForbidden();
+});
+
+test('sending a statement attaches the live PDF and logs it against the customer', function () {
+    Mail::fake();
+    config([
+        'mail.from.address' => 'configured@example.test',
+        'mail.from.name' => 'Configured Sender',
+    ]);
+    $customer = statementCustomer();
+    statementInvoice($customer, '2026-01-10');
+
+    postJson("/api/v1/customers/{$customer->id}/statement/send", [
+        'subject' => 'January statement',
+        'body' => 'Your statement is attached.',
+        'to' => $customer->email,
+    ])->assertOk();
+
+    $sent = null;
+    Mail::assertSent(SendCustomerStatementMail::class, function (SendCustomerStatementMail $mail) use ($customer, &$sent) {
+        $sent = $mail;
+
+        return $mail->data['customer']->is($customer)
+            && $mail->data['from'] === 'configured@example.test'
+            && $mail->data['from_name'] === 'Configured Sender'
+            && str_ends_with($mail->data['filename'], '.pdf')
+            && $mail->data['pdf']->output() !== '';
+    });
+
+    $sent->build();
+
+    expect(EmailLog::query()
+        ->where('mailable_type', Customer::class)
+        ->where('mailable_id', $customer->id)
+        ->where('from', 'configured@example.test')
+        ->exists())->toBeTrue();
+});
+
+test('statement email ignores a submitted sender address', function () {
+    Mail::fake();
+    config([
+        'mail.from.address' => 'configured@example.test',
+        'mail.from.name' => 'Configured Sender',
+    ]);
+    $customer = statementCustomer();
+
+    postJson("/api/v1/customers/{$customer->id}/statement/send", [
+        'subject' => 'Statement',
+        'body' => 'Your statement is attached.',
+        'from' => 'spoofed@example.test',
+        'to' => $customer->email,
+    ])->assertOk();
+
+    Mail::assertSent(SendCustomerStatementMail::class, fn (SendCustomerStatementMail $mail) => $mail->data['from'] === 'configured@example.test'
+        && $mail->data['from_name'] === 'Configured Sender');
+});
+
+test('the authenticated report route streams the customer statement PDF', function () {
+    $customer = statementCustomer();
+    statementInvoice($customer, '2026-01-10');
+
+    get("/reports/customers/{$customer->id}/statement?from_date=2026-01-01&to_date=2026-01-31")
+        ->assertOk()
+        ->assertHeader('content-type', 'application/pdf');
+});
+
+test('outstanding statement PDF preview includes account totals', function () {
+    $customer = statementCustomer();
+    statementInvoice($customer, '2026-01-10');
+    statementPayment($customer, '2026-01-15', 250);
+
+    get("/reports/customers/{$customer->id}/statement?type=outstanding&as_of=2026-01-31&preview=1")
+        ->assertOk()
+        ->assertSee('Gross invoice due')
+        ->assertSee('Available credit')
+        ->assertSee('Net account balance');
+});
diff --git a/tests/Feature/PaymentAllocationTest.php b/tests/Feature/PaymentAllocationTest.php
new file mode 100644
index 00000000..e17ac3ca
--- /dev/null
+++ b/tests/Feature/PaymentAllocationTest.php
@@ -0,0 +1,370 @@
+<?php
+
+use App\Jobs\GeneratePaymentPdfJob;
+use App\Models\Currency;
+use App\Models\Customer;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
+use App\Models\User;
+use App\Services\Document\PaymentAllocationService;
+use Illuminate\Support\Facades\Artisan;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Queue;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Validation\ValidationException;
+use Laravel\Sanctum\Sanctum;
+use Silber\Bouncer\BouncerFacade;
+
+beforeEach(function () {
+    Artisan::call('db:seed', ['--class' => 'DatabaseSeeder', '--force' => true]);
+    Artisan::call('db:seed', ['--class' => 'DemoSeeder', '--force' => true]);
+});
+
+function allocatableInvoice(int $amount = 10000): Invoice
+{
+    return Invoice::factory()->create([
+        'type' => Invoice::TYPE_INVOICE,
+        'status' => Invoice::STATUS_SENT,
+        'sent' => true,
+        'viewed' => false,
+        'paid_status' => Invoice::STATUS_UNPAID,
+        'sub_total' => $amount,
+        'total' => $amount,
+        'due_amount' => $amount,
+        'exchange_rate' => 1,
+        'base_sub_total' => $amount,
+        'base_total' => $amount,
+        'base_due_amount' => $amount,
+    ]);
+}
+
+function allocationPayment(Invoice $invoice, int $amount): Payment
+{
+    return Payment::factory()->create([
+        'company_id' => $invoice->company_id,
+        'customer_id' => $invoice->customer_id,
+        'currency_id' => $invoice->currency_id,
+        'amount' => $amount,
+        'base_amount' => $amount,
+        'exchange_rate' => 1,
+    ]);
+}
+
+test('a payment can be allocated across multiple invoices and retain credit', function () {
+    $first = allocatableInvoice(300);
+    $second = allocatableInvoice(400);
+    $third = allocatableInvoice(200);
+
+    foreach ([$second, $third] as $invoice) {
+        $invoice->update([
+            'company_id' => $first->company_id,
+            'customer_id' => $first->customer_id,
+            'currency_id' => $first->currency_id,
+        ]);
+    }
+
+    $payment = allocationPayment($first, 1000);
+
+    app(PaymentAllocationService::class)->replace($payment, [
+        ['invoice_id' => $first->id, 'amount' => 300],
+        ['invoice_id' => $second->id, 'amount' => 400],
+        ['invoice_id' => $third->id, 'amount' => 200],
+    ]);
+
+    expect(PaymentAllocation::where('payment_id', $payment->id)->sum('amount'))->toBe(900)
+        ->and($first->fresh()->due_amount)->toBe(0)
+        ->and($second->fresh()->due_amount)->toBe(0)
+        ->and($third->fresh()->due_amount)->toBe(0)
+        ->and($payment->fresh()->amount - PaymentAllocation::where('payment_id', $payment->id)->sum('amount'))->toBe(100);
+});
+
+test('replacing allocations recalculates both old and new invoice balances', function () {
+    $first = allocatableInvoice(500);
+    $second = allocatableInvoice(500);
+    $second->update([
+        'company_id' => $first->company_id,
+        'customer_id' => $first->customer_id,
+        'currency_id' => $first->currency_id,
+    ]);
+    $payment = allocationPayment($first, 500);
+    $service = app(PaymentAllocationService::class);
+
+    $service->replace($payment, [['invoice_id' => $first->id, 'amount' => 500]]);
+    $service->replace($payment, [['invoice_id' => $second->id, 'amount' => 500]]);
+
+    expect($first->fresh()->due_amount)->toBe(500)
+        ->and($first->fresh()->paid_status)->toBe(Invoice::STATUS_UNPAID)
+        ->and($second->fresh()->due_amount)->toBe(0)
+        ->and($second->fresh()->paid_status)->toBe(Invoice::STATUS_PAID);
+});
+
+test('allocation over an invoice balance is rejected without changing allocations', function () {
+    $invoice = allocatableInvoice(100);
+    $payment = allocationPayment($invoice, 101);
+
+    expect(fn () => app(PaymentAllocationService::class)->replace($payment, [
+        ['invoice_id' => $invoice->id, 'amount' => 101],
+    ]))->toThrow(ValidationException::class);
+
+    expect(PaymentAllocation::where('payment_id', $payment->id)->exists())->toBeFalse()
+        ->and($invoice->fresh()->due_amount)->toBe(100);
+});
+
+test('allocations reject mismatched currencies, customers, drafts, and credit notes', function () {
+    $invoice = allocatableInvoice(100);
+    $payment = allocationPayment($invoice, 100);
+    $otherCustomer = Customer::factory()->create([
+        'company_id' => $invoice->company_id,
+        'currency_id' => $invoice->currency_id,
+    ]);
+    $otherCurrency = Currency::query()->whereKeyNot($invoice->currency_id)->firstOrFail();
+
+    $invalidInvoices = collect([
+        allocatableInvoice(100)->forceFill([
+            'company_id' => $invoice->company_id,
+            'customer_id' => $otherCustomer->id,
+            'currency_id' => $invoice->currency_id,
+        ]),
+        allocatableInvoice(100)->forceFill([
+            'company_id' => $invoice->company_id,
+            'customer_id' => $invoice->customer_id,
+            'currency_id' => $otherCurrency->id,
+        ]),
+        allocatableInvoice(100)->forceFill([
+            'company_id' => $invoice->company_id,
+            'customer_id' => $invoice->customer_id,
+            'currency_id' => $invoice->currency_id,
+            'status' => Invoice::STATUS_DRAFT,
+        ]),
+        allocatableInvoice(100)->forceFill([
+            'company_id' => $invoice->company_id,
+            'customer_id' => $invoice->customer_id,
+            'currency_id' => $invoice->currency_id,
+            'type' => Invoice::TYPE_CREDIT_NOTE,
+        ]),
+    ])->each->save();
+
+    foreach ($invalidInvoices as $invalidInvoice) {
+        expect(fn () => app(PaymentAllocationService::class)->replace($payment, [[
+            'invoice_id' => $invalidInvoice->id,
+            'amount' => 100,
+        ]]))->toThrow(ValidationException::class);
+    }
+
+    expect($payment->allocations()->exists())->toBeFalse();
+});
+
+test('duplicate targets and totals above the payment amount are rejected', function () {
+    $first = allocatableInvoice(100);
+    $second = allocatableInvoice(100);
+    $second->update([
+        'company_id' => $first->company_id,
+        'customer_id' => $first->customer_id,
+        'currency_id' => $first->currency_id,
+    ]);
+    $payment = allocationPayment($first, 100);
+    $service = app(PaymentAllocationService::class);
+
+    expect(fn () => $service->replace($payment, [
+        ['invoice_id' => $first->id, 'amount' => 50],
+        ['invoice_id' => $first->id, 'amount' => 50],
+    ]))->toThrow(ValidationException::class)
+        ->and(fn () => $service->replace($payment, [
+            ['invoice_id' => $first->id, 'amount' => 60],
+            ['invoice_id' => $second->id, 'amount' => 50],
+        ]))->toThrow(ValidationException::class);
+});
+
+test('payment PDF generation is deferred until a successful allocation transaction commits', function () {
+    Queue::fake();
+    $invoice = allocatableInvoice(100);
+
+    DB::transaction(function () use ($invoice): void {
+        $payment = allocationPayment($invoice, 100);
+        app(PaymentAllocationService::class)->replace($payment, [
+            ['invoice_id' => $invoice->id, 'amount' => 100],
+        ]);
+
+        Queue::assertNothingPushed();
+    });
+
+    Queue::assertPushed(GeneratePaymentPdfJob::class);
+
+    Queue::fake();
+
+    expect(fn () => DB::transaction(function () use ($invoice): void {
+        $payment = allocationPayment($invoice, 100);
+
+        app(PaymentAllocationService::class)->replace($payment, [
+            ['invoice_id' => $invoice->id, 'amount' => 101],
+        ]);
+    }))->toThrow(ValidationException::class);
+
+    Queue::assertNothingPushed();
+});
+
+test('customer credit can be applied atomically to multiple invoices', function () {
+    $first = allocatableInvoice(100);
+    $second = allocatableInvoice(200);
+    $second->update([
+        'company_id' => $first->company_id,
+        'customer_id' => $first->customer_id,
+        'currency_id' => $first->currency_id,
+    ]);
+    $payment = allocationPayment($first, 300);
+
+    app(PaymentAllocationService::class)->applyCustomerCredits(
+        $first->company_id,
+        $first->customer_id,
+        [
+            ['payment_id' => $payment->id, 'invoice_id' => $first->id, 'amount' => 100],
+            ['payment_id' => $payment->id, 'invoice_id' => $second->id, 'amount' => 200],
+        ],
+    );
+
+    expect(PaymentAllocation::where('payment_id', $payment->id)->sum('amount'))->toBe(300)
+        ->and($first->fresh()->due_amount)->toBe(0)
+        ->and($second->fresh()->due_amount)->toBe(0);
+});
+
+test('creating payments does not authorize reallocating existing customer credit', function () {
+    $invoice = allocatableInvoice(100);
+    $payment = allocationPayment($invoice, 100);
+    $user = User::factory()->create();
+    $user->companies()->attach($invoice->company_id);
+
+    BouncerFacade::scope()->to($invoice->company_id);
+    BouncerFacade::allow($user)->to('view-customer', Customer::class);
+    BouncerFacade::allow($user)->to('create-payment', Payment::class);
+    Sanctum::actingAs($user, ['*']);
+    $this->withHeaders(['company' => $invoice->company_id]);
+
+    $this->postJson("/api/v1/customers/{$invoice->customer_id}/credit-allocations", [
+        'allocations' => [[
+            'payment_id' => $payment->id,
+            'invoice_id' => $invoice->id,
+            'amount' => 100,
+        ]],
+    ])->assertForbidden();
+});
+
+test('the migration restores an invalid legacy link to unapplied credit and recalculates its invoice', function () {
+    $invoice = allocatableInvoice(100);
+    $invoice->update([
+        'due_amount' => 0,
+        'base_due_amount' => 0,
+        'status' => Invoice::STATUS_COMPLETED,
+        'paid_status' => Invoice::STATUS_PAID,
+    ]);
+    $otherCustomer = Customer::factory()->create([
+        'company_id' => $invoice->company_id,
+        'currency_id' => $invoice->currency_id,
+    ]);
+    $payment = Payment::factory()->create([
+        'company_id' => $invoice->company_id,
+        'customer_id' => $otherCustomer->id,
+        'currency_id' => $invoice->currency_id,
+        'amount' => 100,
+        'base_amount' => 100,
+        'exchange_rate' => 1,
+    ]);
+
+    Schema::table('payments', fn ($table) => $table->unsignedInteger('invoice_id')->nullable()->index());
+    Payment::query()->whereKey($payment->id)->update(['invoice_id' => $invoice->id]);
+
+    (require database_path('migrations/2026_08_02_230400_replace_payment_invoice_with_allocations.php'))->up();
+
+    expect(Schema::hasColumn('payments', 'invoice_id'))->toBeFalse()
+        ->and(PaymentAllocation::where('payment_id', $payment->id)->exists())->toBeFalse()
+        ->and($invoice->fresh()->due_amount)->toBe(100)
+        ->and($invoice->fresh()->status)->toBe(Invoice::STATUS_SENT)
+        ->and($invoice->fresh()->paid_status)->toBe(Invoice::STATUS_UNPAID);
+});
+
+test('the migration leaves an invalid legacy credit note target unchanged', function () {
+    $creditNote = allocatableInvoice(100);
+    $creditNote->update([
+        'type' => Invoice::TYPE_CREDIT_NOTE,
+        'status' => Invoice::STATUS_SENT,
+        'paid_status' => Invoice::STATUS_UNPAID,
+        'due_amount' => 100,
+        'base_due_amount' => 100,
+    ]);
+    $payment = allocationPayment($creditNote, 100);
+
+    Schema::table('payments', fn ($table) => $table->unsignedInteger('invoice_id')->nullable()->index());
+    Payment::query()->whereKey($payment->id)->update(['invoice_id' => $creditNote->id]);
+
+    (require database_path('migrations/2026_08_02_230400_replace_payment_invoice_with_allocations.php'))->up();
+
+    expect(Schema::hasColumn('payments', 'invoice_id'))->toBeFalse()
+        ->and(PaymentAllocation::where('payment_id', $payment->id)->exists())->toBeFalse()
+        ->and($creditNote->fresh()->status)->toBe(Invoice::STATUS_SENT)
+        ->and($creditNote->fresh()->paid_status)->toBe(Invoice::STATUS_UNPAID)
+        ->and($creditNote->fresh()->due_amount)->toBe(100);
+});
+
+test('the migration allocates only the payable portion of an overpaid legacy payment', function () {
+    $invoice = allocatableInvoice(100);
+    $payment = allocationPayment($invoice, 150);
+
+    Schema::table('payments', fn ($table) => $table->unsignedInteger('invoice_id')->nullable()->index());
+    Payment::query()->whereKey($payment->id)->update(['invoice_id' => $invoice->id]);
+
+    (require database_path('migrations/2026_08_02_230400_replace_payment_invoice_with_allocations.php'))->up();
+
+    expect(PaymentAllocation::where('payment_id', $payment->id)->sum('amount'))->toBe(100)
+        ->and($invoice->fresh()->due_amount)->toBe(0)
+        ->and($invoice->fresh()->status)->toBe(Invoice::STATUS_COMPLETED)
+        ->and($payment->amount - PaymentAllocation::where('payment_id', $payment->id)->sum('amount'))->toBe(50);
+});
+
+test('the migration refuses rollback when a payment retains unapplied credit', function () {
+    $invoice = allocatableInvoice(100);
+    $payment = allocationPayment($invoice, 150);
+    PaymentAllocation::create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $invoice->id,
+        'amount' => 100,
+        'base_amount' => 100,
+    ]);
+
+    $migration = require database_path('migrations/2026_08_02_230400_replace_payment_invoice_with_allocations.php');
+
+    expect(fn () => $migration->down())->toThrow(RuntimeException::class, 'Cannot roll back payment allocations with unapplied customer credit.');
+});
+
+test('a partial migration run with no legacy column still verifies existing allocations', function () {
+    $invoice = Invoice::factory()->create([
+        'type' => Invoice::TYPE_INVOICE,
+        'status' => Invoice::STATUS_DRAFT,
+    ]);
+    $payment = allocationPayment($invoice, 100);
+    PaymentAllocation::create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $invoice->id,
+        'amount' => 100,
+        'base_amount' => 100,
+    ]);
+
+    $migration = require database_path('migrations/2026_08_02_230400_replace_payment_invoice_with_allocations.php');
+
+    expect(Schema::hasColumn('payments', 'invoice_id'))->toBeFalse()
+        ->and(fn () => $migration->up())->toThrow(RuntimeException::class, 'allocation target is not payable');
+});
+
+test('a partial migration run rejects allocations whose payment no longer exists', function () {
+    $invoice = allocatableInvoice(100);
+    PaymentAllocation::create([
+        'payment_id' => 999999,
+        'invoice_id' => $invoice->id,
+        'amount' => 100,
+        'base_amount' => 100,
+    ]);
+
+    $migration = require database_path('migrations/2026_08_02_230400_replace_payment_invoice_with_allocations.php');
+
+    expect(Schema::hasColumn('payments', 'invoice_id'))->toBeFalse()
+        ->and(fn () => $migration->up())->toThrow(RuntimeException::class, 'allocation payment is missing');
+});
diff --git a/tests/Feature/Pdf/PaymentAllocationReceiptTest.php b/tests/Feature/Pdf/PaymentAllocationReceiptTest.php
new file mode 100644
index 00000000..fb8f2bb5
--- /dev/null
+++ b/tests/Feature/Pdf/PaymentAllocationReceiptTest.php
@@ -0,0 +1,53 @@
+<?php
+
+use App\Models\Customer;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
+use App\Services\Document\PaymentService;
+use Illuminate\Support\Facades\Artisan;
+
+beforeEach(function () {
+    Artisan::call('db:seed', ['--class' => 'DatabaseSeeder', '--force' => true]);
+    Artisan::call('db:seed', ['--class' => 'DemoSeeder', '--force' => true]);
+});
+
+test('payment receipt lists every allocated invoice and remaining credit', function () {
+    $customer = Customer::factory()->create();
+    $first = Invoice::factory()->create([
+        'company_id' => $customer->company_id,
+        'customer_id' => $customer->id,
+        'invoice_number' => 'INV-ALLOCATION-ONE',
+    ]);
+    $second = Invoice::factory()->create([
+        'company_id' => $customer->company_id,
+        'customer_id' => $customer->id,
+        'invoice_number' => 'INV-ALLOCATION-TWO',
+    ]);
+    $payment = Payment::factory()->create([
+        'company_id' => $customer->company_id,
+        'customer_id' => $customer->id,
+        'amount' => 1000,
+        'base_amount' => 1000,
+    ]);
+    PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $first->id,
+        'amount' => 300,
+        'base_amount' => 300,
+    ]);
+    PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $second->id,
+        'amount' => 400,
+        'base_amount' => 400,
+    ]);
+
+    request()->query->set('preview', true);
+    $html = app(PaymentService::class)->getPdfData($payment)->render();
+
+    expect($html)
+        ->toContain('INV-ALLOCATION-ONE')
+        ->toContain('INV-ALLOCATION-TWO')
+        ->toContain(__('unapplied_credit'));
+});
diff --git a/tests/Feature/RealisticDemoSeederTest.php b/tests/Feature/RealisticDemoSeederTest.php
new file mode 100644
index 00000000..102344e1
--- /dev/null
+++ b/tests/Feature/RealisticDemoSeederTest.php
@@ -0,0 +1,60 @@
+<?php
+
+use App\Models\Customer;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
+use App\Models\User;
+use App\Services\CustomerStatementService;
+use Carbon\Carbon;
+use Illuminate\Support\Facades\Artisan;
+use Illuminate\Support\Facades\Queue;
+
+beforeEach(function () {
+    Artisan::call('db:seed', ['--class' => 'DatabaseSeeder', '--force' => true]);
+    Artisan::call('db:seed', ['--class' => 'DemoSeeder', '--force' => true]);
+    Queue::fake();
+});
+
+test('realistic demo payments are allocated and leave invoice balances consistent', function () {
+    Artisan::call('db:seed', ['--class' => 'RealisticDemoSeeder', '--force' => true]);
+
+    $company = User::where('email', 'demo@invoiceshelf.com')->firstOrFail()->companies()->firstOrFail();
+    $payments = Payment::query()->where('company_id', $company->id)->with('allocations')->get();
+    $allocatedInvoices = Invoice::query()
+        ->where('company_id', $company->id)
+        ->whereHas('allocations')
+        ->with('allocations')
+        ->get();
+
+    expect($payments)->not->toBeEmpty()
+        ->and($payments->every(fn (Payment $payment) => $payment->allocations->isNotEmpty()))->toBeTrue()
+        ->and(PaymentAllocation::query()->whereIn('payment_id', $payments->modelKeys())->count())->toBe($payments->count());
+
+    foreach ($allocatedInvoices as $invoice) {
+        expect((int) $invoice->due_amount)
+            ->toBe(max(0, (int) $invoice->total - (int) $invoice->allocations->sum('amount')));
+    }
+});
+
+test('realistic demo provides current-month account activity for every customer', function () {
+    Artisan::call('db:seed', ['--class' => 'RealisticDemoSeeder', '--force' => true]);
+
+    $company = User::where('email', 'demo@invoiceshelf.com')->firstOrFail()->companies()->firstOrFail();
+    $from = Carbon::now()->startOfMonth();
+    $to = Carbon::now();
+    $statementService = app(CustomerStatementService::class);
+
+    Customer::query()
+        ->where('company_id', $company->id)
+        ->each(function (Customer $customer) use ($statementService, $from, $to): void {
+            $statement = $statementService->statement(
+                $customer,
+                CustomerStatementService::TYPE_ACTIVITY,
+                $from,
+                $to,
+            );
+
+            expect($statement['entries']->total())->toBeGreaterThan(0);
+        });
+});
diff --git a/tests/Unit/ExpenseTest.php b/tests/Unit/ExpenseTest.php
index a3060516..950b24bd 100644
--- a/tests/Unit/ExpenseTest.php
+++ b/tests/Unit/ExpenseTest.php
@@ -1,7 +1,11 @@
 <?php
 
 use App\Models\Company;
+use App\Models\Customer;
 use App\Models\Expense;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\PaymentAllocation;
 use App\Models\Tax;
 use App\Models\TaxType;
 use App\Models\User;
@@ -73,3 +77,46 @@ test('company deletion removes receipt taxes through expense model events', func
 
     $this->assertDatabaseMissing('taxes', ['id' => $tax->id]);
 });
+
+test('customer deletion removes payment allocations before bulk payment deletion', function () {
+    $customer = Customer::factory()->create();
+    $invoice = Invoice::factory()->create([
+        'company_id' => $customer->company_id,
+        'customer_id' => $customer->id,
+    ]);
+    $payment = Payment::factory()->create([
+        'company_id' => $customer->company_id,
+        'customer_id' => $customer->id,
+    ]);
+    $allocation = PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $invoice->id,
+    ]);
+
+    app(CustomerService::class)->delete(collect([$customer->id]));
+
+    $this->assertDatabaseMissing('payment_allocations', ['id' => $allocation->id]);
+});
+
+test('company deletion removes payment allocations before bulk payment deletion', function () {
+    $user = User::find(1);
+    $company = Company::factory()->create(['owner_id' => $user->id]);
+    $user->companies()->attach($company);
+    $customer = Customer::factory()->create(['company_id' => $company->id]);
+    $invoice = Invoice::factory()->create([
+        'company_id' => $company->id,
+        'customer_id' => $customer->id,
+    ]);
+    $payment = Payment::factory()->create([
+        'company_id' => $company->id,
+        'customer_id' => $customer->id,
+    ]);
+    $allocation = PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $invoice->id,
+    ]);
+
+    app(CompanyService::class)->delete($company, $user);
+
+    $this->assertDatabaseMissing('payment_allocations', ['id' => $allocation->id]);
+});
diff --git a/tests/Unit/InvoiceTest.php b/tests/Unit/InvoiceTest.php
index c7fed4f9..22a28468 100644
--- a/tests/Unit/InvoiceTest.php
+++ b/tests/Unit/InvoiceTest.php
@@ -3,6 +3,7 @@
 use App\Http\Requests\InvoicesRequest;
 use App\Models\Invoice;
 use App\Models\InvoiceItem;
+use App\Models\Payment;
 use App\Models\Tax;
 use App\Services\Document\DocumentItemService;
 use App\Services\Document\InvoiceService;
@@ -30,9 +31,21 @@ test('invoice has many taxes', function () {
 });
 
 test('invoice has many payments', function () {
-    $invoice = Invoice::factory()->hasPayments(5)->create();
+    $invoice = Invoice::factory()->create();
+    $payments = Payment::factory()->count(5)->create([
+        'company_id' => $invoice->company_id,
+        'customer_id' => $invoice->customer_id,
+        'currency_id' => $invoice->currency_id,
+    ]);
 
-    $this->assertCount(5, $invoice->payments);
+    foreach ($payments as $payment) {
+        $invoice->payments()->attach($payment->id, [
+            'amount' => $payment->amount,
+            'base_amount' => $payment->base_amount,
+        ]);
+    }
+
+    $this->assertCount(5, $invoice->fresh()->payments);
 
     $this->assertTrue($invoice->payments()->exists());
 });
diff --git a/tests/Unit/PaymentTest.php b/tests/Unit/PaymentTest.php
index 9d2bf577..80e46661 100644
--- a/tests/Unit/PaymentTest.php
+++ b/tests/Unit/PaymentTest.php
@@ -1,6 +1,8 @@
 <?php
 
+use App\Models\Invoice;
 use App\Models\Payment;
+use App\Models\PaymentAllocation;
 use Illuminate\Support\Facades\Artisan;
 
 beforeEach(function () {
@@ -8,10 +10,19 @@ beforeEach(function () {
     Artisan::call('db:seed', ['--class' => 'DemoSeeder', '--force' => true]);
 });
 
-test('payment belongs to invoice', function () {
-    $payment = Payment::factory()->forInvoice()->create();
+test('payment has invoice allocations', function () {
+    $payment = Payment::factory()->create();
+    $invoice = Invoice::factory()->create([
+        'company_id' => $payment->company_id,
+        'customer_id' => $payment->customer_id,
+        'currency_id' => $payment->currency_id,
+    ]);
+    PaymentAllocation::factory()->create([
+        'payment_id' => $payment->id,
+        'invoice_id' => $invoice->id,
+    ]);
 
-    $this->assertTrue($payment->invoice()->exists());
+    $this->assertTrue($payment->invoices()->exists());
 });
 
 test('payment belongs to customer', function () {