Merge branch 'develop' into ximinez/lending-shortages

* XRPLF/develop:
  chore: Add custom cmake definitions for gersemi (6491)
  refactor: Update transaction folder structure (6483)
  chore: Apply gersemi changes (6486)
  chore: Use gersemi instead of ancient cmake-format (6486)
  Add Formats and Flags to `server_definitions` (6321)
  fix: Fix docs deployment for pull requests (6482)
  fix: Stop committing generated docs to prevent repo bloat (6474)

src/libxrpl/tx/transactors/lending/LendingHelpers.cpp

@@ -995,18 +995,34 @@ computePaymentComponents(
         XRPL_ASSERT_PARTS(
             excess >= beast::zero, "xrpl::detail::computePaymentComponents", "excess non-negative");
     };
-    // Helper to reduce deltas when they collectively exceed a limit.
-    // Order matters: we prefer to reduce interest first (most flexible),
-    // then management fee, then principal (least flexible).
+    auto giveTo = [](Number& component, Number& shortage, Number const& maximum) {
+        if (shortage > beast::zero)
+        {
+            // Put as much of the shortage as we can into the provided part
+            // and the total
+            auto part = std::min(maximum - component, shortage);
+            component += part;
+            shortage -= part;
+        }
+        // If the shortage goes negative, we put too much, which should be
+        // impossible
+        XRPL_ASSERT_PARTS(
+            shortage >= beast::zero,
+            "ripple::detail::computePaymentComponents",
+            "excess non-negative");
+    };
     auto addressExcess = [&takeFrom](LoanStateDeltas& deltas, Number& excess) {
         // This order is based on where errors are the least problematic
         takeFrom(deltas.interest, excess);
         takeFrom(deltas.managementFee, excess);
         takeFrom(deltas.principal, excess);
     };
-
-    // Check if deltas exceed the total outstanding value. This should never
-    // happen due to earlier caps, but handle it defensively.
+    auto addressShortage =
+        [&giveTo](LoanStateDeltas& deltas, Number& shortage, LoanState const& current) {
+            giveTo(deltas.interest, shortage, current.interestDue);
+            giveTo(deltas.managementFee, shortage, current.managementFeeDue);
+            giveTo(deltas.principal, shortage, current.principalOutstanding);
+        };
     Number totalOverpayment = deltas.total() - currentLedgerState.valueOutstanding;
 
     if (totalOverpayment > beast::zero)
@@ -1034,12 +1050,33 @@ computePaymentComponents(
         addressExcess(deltas, excess);
         shortage = -excess;
     }
+    else if (shortage > beast::zero && totalOverpayment < beast::zero)
+    {
+        // If there's a shortage, and there's room in the loan itself, we can
+        // top up the parts to make the payment correct.
+        shortage = std::min(-totalOverpayment, shortage);
+        addressShortage(deltas, shortage, currentLedgerState);
+    }
 
-    // At this point, shortage >= 0 means we're paying less than the full
-    // periodic payment (due to rounding or component caps).
-    // shortage < 0 would mean we're trying to pay more than allowed (bug).
+    // The shortage should never be negative, which indicates that the parts are
+    // trying to take more than the whole payment. The shortage should not be
+    // positive, either, which indicates that we're not going to take the whole
+    // payment amount. Only the last payment should be allowed to have a
+    // shortage, and that's handled in a special case above.
     XRPL_ASSERT_PARTS(
-        shortage >= beast::zero, "xrpl::detail::computePaymentComponents", "no shortage or excess");
+        shortage == beast::zero,
+        "ripple::detail::computePaymentComponents",
+        "no shortage or excess");
+#if LOANCOMPLETE
+    /*
+    // This used to be part of the above assert. It will eventually be removed
+    // if proved accurate
+    ||
+        (shortage > beast::zero &&
+         ((asset.integral() && shortage < 3) ||
+          (scale - shortage.exponent() > 14)))
+          */
+#endif
 
     // Final validation that all components are valid
     XRPL_ASSERT_PARTS(

src/test/app/Loan_test.cpp

@@ -2492,11 +2492,10 @@ protected:
                         state.paymentRemaining,
                         broker.params.managementFeeRate);
 
-                    BEAST_EXPECTS(
-                        paymentComponents.specialCase == detail::PaymentSpecialCase::final ||
-                            paymentComponents.trackedValueDelta <= roundedPeriodicPayment,
-                        "Delta: " + to_string(paymentComponents.trackedValueDelta) +
-                            ", periodic payment: " + to_string(roundedPeriodicPayment));
+                    BEAST_EXPECT(
+                        paymentComponents.trackedValueDelta == roundedPeriodicPayment ||
+                        (paymentComponents.specialCase == detail::PaymentSpecialCase::final &&
+                         paymentComponents.trackedValueDelta < roundedPeriodicPayment));
 
                     xrpl::LoanState const nextTrueState = computeTheoreticalLoanState(
                         state.periodicPayment,