skilldrop-cli 0.16.29 → 0.16.31

package/packs/dev-team/skills/refactor-plan/evals/files/6/billing-service/src/main/kotlin/billing/InvoiceService.kt

@@ -0,0 +1,157 @@
+package billing
+
+import jakarta.persistence.EntityManager
+import jakarta.persistence.PersistenceContext
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import java.math.BigDecimal
+import java.math.RoundingMode
+import java.time.Clock
+import java.time.LocalDate
+
+@Service
+class InvoiceService(
+    private val invoiceRepository: InvoiceRepository,
+    private val taxRateRepository: TaxRateRepository,
+    private val customerRepository: CustomerRepository,
+    private val clock: Clock,
+) {
+
+    @PersistenceContext
+    private lateinit var em: EntityManager
+
+    // ---------------------------------------------------------------
+    // Creation
+    // ---------------------------------------------------------------
+
+    @Transactional
+    fun createInvoice(customerId: Long, lines: List<LineRequest>): Invoice {
+        val customer = customerRepository.findById(customerId)
+            .orElseThrow { IllegalArgumentException("unknown customer $customerId") }
+        require(lines.isNotEmpty()) { "invoice needs at least one line" }
+
+        val invoice = Invoice(
+            customer = customer,
+            issuedOn = LocalDate.now(clock),
+            dueOn = LocalDate.now(clock).plusDays(customer.paymentTermsDays.toLong()),
+            status = InvoiceStatus.OPEN,
+        )
+        lines.forEach { req ->
+            val rate = taxRateRepository.findByRegionAndCategory(customer.region, req.category)
+                ?: taxRateRepository.findDefault(customer.region)
+            invoice.lines.add(
+                InvoiceLine(
+                    invoice = invoice,
+                    description = req.description,
+                    quantity = req.quantity,
+                    unitPrice = req.unitPrice,
+                    taxRate = rate.percent,
+                )
+            )
+        }
+        recalculate(invoice)
+        return invoiceRepository.save(invoice)
+    }
+
+    // ---------------------------------------------------------------
+    // Totals and tax
+    // ---------------------------------------------------------------
+
+    fun recalculate(invoice: Invoice) {
+        var net = BigDecimal.ZERO
+        var tax = BigDecimal.ZERO
+        invoice.lines.forEach { line ->
+            val lineNet = line.unitPrice.multiply(BigDecimal(line.quantity))
+            net = net.add(lineNet)
+            tax = tax.add(computeLineTax(lineNet, line.taxRate))
+        }
+        invoice.netTotal = net.setScale(2, RoundingMode.HALF_EVEN)
+        invoice.taxTotal = tax
+        invoice.grossTotal = invoice.netTotal.add(invoice.taxTotal).add(invoice.lateFeeTotal)
+    }
+
+    // Tax is rounded per line (HALF_EVEN), not on the invoice total.
+    // Finance signed this off in 2023; do not change without them.
+    fun computeLineTax(lineNet: BigDecimal, percent: BigDecimal): BigDecimal =
+        lineNet.multiply(percent).divide(BigDecimal(100)).setScale(2, RoundingMode.HALF_EVEN)
+
+    // ---------------------------------------------------------------
+    // Overdue and late fees
+    // ---------------------------------------------------------------
+
+    fun findOverdue(asOf: LocalDate): List<Invoice> =
+        em.createQuery(
+            "select i from Invoice i join fetch i.customer " +
+                "where i.status in (:open, :dunning) and i.dueOn < :asOf",
+            Invoice::class.java,
+        )
+            .setParameter("open", InvoiceStatus.OPEN)
+            .setParameter("dunning", InvoiceStatus.IN_DUNNING)
+            .setParameter("asOf", asOf)
+            .resultList
+
+    @Transactional
+    fun applyLateFees(asOf: LocalDate): Int {
+        var count = 0
+        findOverdue(asOf).forEach { invoice ->
+            val daysLate = asOf.toEpochDay() - invoice.dueOn.toEpochDay()
+            if (daysLate < invoice.customer.lateFeeGraceDays) return@forEach
+            if (invoice.customer.lateFeeExempt) return@forEach
+
+            val fee = invoice.netTotal
+                .multiply(BigDecimal("0.015"))
+                .multiply(BigDecimal(daysLate / 30 + 1))
+                .setScale(2, RoundingMode.HALF_UP)
+            if (fee > invoice.lateFeeTotal) {
+                invoice.lateFeeTotal = fee
+                recalculate(invoice)
+                em.merge(invoice)
+                count++
+            }
+        }
+        return count
+    }
+
+    // ---------------------------------------------------------------
+    // Payment
+    // ---------------------------------------------------------------
+
+    @Transactional
+    fun markPaid(invoiceId: Long, amount: BigDecimal, paidOn: LocalDate) {
+        val invoice = invoiceRepository.findById(invoiceId)
+            .orElseThrow { IllegalArgumentException("unknown invoice $invoiceId") }
+        check(invoice.status != InvoiceStatus.VOID) { "cannot pay a void invoice" }
+
+        invoice.amountPaid = invoice.amountPaid.add(amount)
+        if (invoice.amountPaid >= invoice.grossTotal) {
+            invoice.status = InvoiceStatus.PAID
+            invoice.paidOn = paidOn
+        }
+        // native update keeps the customer balance in step; the ORM mapping
+        // for Customer.balance is read-only (see V31__customer_balance.sql)
+        em.createNativeQuery(
+            "update customer set balance = balance - :amount where id = :id"
+        )
+            .setParameter("amount", amount)
+            .setParameter("id", invoice.customer.id)
+            .executeUpdate()
+        invoiceRepository.save(invoice)
+    }
+
+    @Transactional
+    fun void(invoiceId: Long, reason: String) {
+        val invoice = invoiceRepository.findById(invoiceId)
+            .orElseThrow { IllegalArgumentException("unknown invoice $invoiceId") }
+        check(invoice.amountPaid.signum() == 0) { "cannot void a part-paid invoice" }
+        invoice.status = InvoiceStatus.VOID
+        invoice.voidReason = reason
+        invoiceRepository.save(invoice)
+    }
+}
+
+data class LineRequest(
+    val description: String,
+    val quantity: Int,
+    val unitPrice: BigDecimal,
+    val category: String,
+)

package/packs/dev-team/skills/refactor-plan/evals/files/6/billing-service/src/main/kotlin/billing/pdf/InvoicePdfRenderer.kt

@@ -0,0 +1,36 @@
+package billing.pdf
+
+import billing.Invoice
+import org.springframework.stereotype.Component
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+@Component
+class InvoicePdfRenderer(private val templates: PdfTemplates) {
+
+    fun render(invoice: Invoice): ByteArray {
+        val rows = invoice.lines.map { line ->
+            val lineNet = line.unitPrice.multiply(BigDecimal(line.quantity))
+            PdfRow(
+                description = line.description,
+                quantity = line.quantity,
+                unitPrice = line.unitPrice,
+                net = lineNet,
+                tax = taxFor(lineNet, line.taxRate),
+            )
+        }
+        return templates.invoice(
+            number = invoice.number,
+            customerName = invoice.customer.name,
+            rows = rows,
+            net = invoice.netTotal,
+            tax = rows.fold(BigDecimal.ZERO) { acc, r -> acc.add(r.tax) },
+            lateFees = invoice.lateFeeTotal,
+            gross = invoice.grossTotal,
+        )
+    }
+
+    // copied from InvoiceService.computeLineTax so the renderer has no service dependency
+    private fun taxFor(lineNet: BigDecimal, percent: BigDecimal): BigDecimal =
+        lineNet.multiply(percent).divide(BigDecimal(100)).setScale(2, RoundingMode.HALF_UP)
+}

package/packs/dev-team/skills/refactor-plan/evals/files/6/billing-service/src/test/kotlin/billing/InvoiceServiceTest.kt

@@ -0,0 +1,40 @@
+package billing
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.transaction.annotation.Transactional
+import java.math.BigDecimal
+
+@SpringBootTest
+@Transactional
+class InvoiceServiceTest @Autowired constructor(
+    private val invoiceService: InvoiceService,
+    private val fixtures: TestFixtures,
+) {
+
+    @Test
+    fun `creates an open invoice with totals`() {
+        val customer = fixtures.customer(region = "DE", paymentTermsDays = 30)
+        fixtures.taxRate(region = "DE", category = "service", percent = "19")
+
+        val invoice = invoiceService.createInvoice(
+            customer.id,
+            listOf(LineRequest("Consulting", 2, BigDecimal("100.00"), "service")),
+        )
+
+        assertThat(invoice.status).isEqualTo(InvoiceStatus.OPEN)
+        assertThat(invoice.netTotal).isEqualByComparingTo("200.00")
+        assertThat(invoice.taxTotal).isEqualByComparingTo("38.00")
+        assertThat(invoice.grossTotal).isEqualByComparingTo("238.00")
+    }
+
+    @Test
+    fun `rejects an invoice with no lines`() {
+        val customer = fixtures.customer(region = "DE", paymentTermsDays = 30)
+        org.junit.jupiter.api.assertThrows<IllegalArgumentException> {
+            invoiceService.createInvoice(customer.id, emptyList())
+        }
+    }
+}

package/packs/dev-team/skills/refactor-plan/evals/files/6/docs/adr-007-persistence.md

@@ -0,0 +1,26 @@
+# ADR-007: Move billing-service persistence from Hibernate to jOOQ
+
+Status: Accepted (2026-09-14)
+
+## Context
+
+Hibernate has bitten us three times this year: lazy-loading surprises in the
+PDF renderer, a dirty-checking flush that wrote a half-updated invoice during an
+exception, and slow startup from entity scanning. Most of our queries are
+already hand-written JPQL or native SQL.
+
+## Decision
+
+Replace Hibernate/Spring Data JPA with jOOQ in billing-service during Q1 2027.
+
+## Precondition
+
+The ORM swap must be a persistence-only change. Before it starts, invoice
+business rules (totals, tax, late fees, payment state transitions) must live in
+code that does not import `jakarta.persistence` or depend on `EntityManager`,
+and must be testable without a database.
+
+## Out of scope
+
+- Changing tax or late-fee rules.
+- The reporting database (separate service).

package/packs/dev-team/skills/refactor-plan/evals/files/6/docs/open-prs.md

@@ -0,0 +1,9 @@
+# Open PRs touching billing-service (as of 2026-10-19)
+
+| PR   | Title                                   | Author  | Files                                              | State                         |
+|------|-----------------------------------------|---------|----------------------------------------------------|-------------------------------|
+| #412 | Cap late fees at 10% of net for EU      | priya.n | InvoiceService.kt (applyLateFees), InvoiceServiceTest.kt | Approved, waiting on finance sign-off, expected to merge this week |
+| #415 | Credit notes                            | tomasz  | InvoiceService.kt (new issueCreditNote, changes void), CreditNote.kt, V44__credit_notes.sql | Draft, ~3 weeks out |
+| #409 | Bump Spring Boot 3.3.4 -> 3.3.5         | bot     | build.gradle.kts                                   | Green, ready                  |
+
+Feature work continues on billing-service through Q4; no freeze is planned.

package/packs/dev-team/skills/refactor-plan/evals/files/7/notes/open-work.md

@@ -0,0 +1,19 @@
+# web: open work (updated Mon 19 Oct 2026)
+
+## Release
+- **v4.8 ships Tue 3 Nov.** Code freeze Fri 30 Oct, 17:00. After freeze only
+  release-blocker fixes go to main.
+
+## Open PRs
+- **#231 Gift cards at checkout** (dana) - adds gift card entry + balance
+  deduction to `CheckoutPanel.tsx` (new state, changes the totals block and
+  `submit()`). In v4.8 scope. Review this week, expected merge by Wed 28 Oct.
+- **#236 Address autocomplete** (lee) - swaps the address inputs in
+  `CheckoutPanel.tsx` for a lookup widget. NOT in v4.8; parked until after release.
+- **#238 Bump vite 5.4 -> 5.5** (bot) - unrelated.
+
+## Tickets
+- **WEB-512** Checkout total in header cart sometimes 1p different from the
+  checkout page. Reported twice by support. Unassigned.
+- **WEB-530** Second payment provider (pay-by-bank) in Q1 2027. Needs the
+  payment step to stop assuming card fields.

package/packs/dev-team/skills/refactor-plan/evals/files/7/web/src/components/CheckoutPanel.tsx

@@ -0,0 +1,207 @@
+import React, { useEffect, useState } from "react";
+import { api } from "../lib/api";
+import { CartItem, Address, ShippingOption } from "../types";
+
+type Props = {
+  items: CartItem[];
+  onComplete: (orderId: string) => void;
+};
+
+export default function CheckoutPanel({ items, onComplete }: Props) {
+  const [step, setStep] = useState<"address" | "shipping" | "payment">("address");
+  const [email, setEmail] = useState("");
+  const [address, setAddress] = useState<Address>({
+    line1: "", line2: "", city: "", postcode: "", country: "GB",
+  });
+  const [addressErrors, setAddressErrors] = useState<Record<string, string>>({});
+  const [shippingOptions, setShippingOptions] = useState<ShippingOption[]>([]);
+  const [shipping, setShipping] = useState<ShippingOption | null>(null);
+  const [promoCode, setPromoCode] = useState("");
+  const [promoPercent, setPromoPercent] = useState(0);
+  const [promoError, setPromoError] = useState("");
+  const [cardNumber, setCardNumber] = useState("");
+  const [cardExpiry, setCardExpiry] = useState("");
+  const [cardCvc, setCardCvc] = useState("");
+  const [submitting, setSubmitting] = useState(false);
+  const [submitError, setSubmitError] = useState("");
+
+  // ---- totals (all money in pence) ----------------------------------
+  const subtotal = items.reduce((sum, i) => sum + i.unitPence * i.qty, 0);
+  const discount = Math.round(subtotal * (promoPercent / 100));
+  const afterDiscount = subtotal - discount;
+  const freeShipping = afterDiscount > 5000;
+  const shippingPence = freeShipping ? 0 : shipping ? shipping.pence : 0;
+  const total = afterDiscount + shippingPence;
+
+  // ---- draft persistence ---------------------------------------------
+  // keeps the form if the user navigates away
+  useEffect(() => {
+    localStorage.setItem(
+      "checkout_draft",
+      JSON.stringify({ email, address, promoCode, total })
+    );
+  }, [email, address, promoCode, total]);
+
+  useEffect(() => {
+    const raw = localStorage.getItem("checkout_draft");
+    if (raw) {
+      const d = JSON.parse(raw);
+      setEmail(d.email || "");
+      if (d.address) setAddress(d.address);
+      if (d.promoCode) setPromoCode(d.promoCode);
+    }
+  }, []);
+
+  // ---- address --------------------------------------------------------
+  function validateAddress(): boolean {
+    const errs: Record<string, string> = {};
+    if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)) errs.email = "Enter a valid email";
+    if (!address.line1.trim()) errs.line1 = "Required";
+    if (!address.city.trim()) errs.city = "Required";
+    if (address.country === "GB" && !/^[A-Z]{1,2}\d[A-Z\d]? ?\d[A-Z]{2}$/i.test(address.postcode)) {
+      errs.postcode = "Enter a valid UK postcode";
+    }
+    if (address.country !== "GB" && !address.postcode.trim()) errs.postcode = "Required";
+    setAddressErrors(errs);
+    return Object.keys(errs).length === 0;
+  }
+
+  async function goToShipping() {
+    if (!validateAddress()) return;
+    const res = await api.get(`/shipping/options?country=${address.country}&postcode=${address.postcode}`);
+    setShippingOptions(res.data);
+    setShipping(res.data[0] ?? null);
+    setStep("shipping");
+  }
+
+  // ---- promo ----------------------------------------------------------
+  async function applyPromo() {
+    setPromoError("");
+    if (!promoCode.trim()) return;
+    try {
+      const res = await api.get(`/promos/${encodeURIComponent(promoCode.trim().toUpperCase())}`);
+      if (res.data.expired) {
+        setPromoError("That code has expired");
+        setPromoPercent(0);
+      } else {
+        setPromoPercent(res.data.percent);
+      }
+    } catch {
+      setPromoError("Code not recognised");
+      setPromoPercent(0);
+    }
+  }
+
+  // ---- payment --------------------------------------------------------
+  function validateCard(): string | null {
+    const digits = cardNumber.replace(/\s/g, "");
+    if (!/^\d{13,19}$/.test(digits)) return "Card number looks wrong";
+    let sum = 0;
+    for (let i = 0; i < digits.length; i++) {
+      let d = parseInt(digits[digits.length - 1 - i], 10);
+      if (i % 2 === 1) { d *= 2; if (d > 9) d -= 9; }
+      sum += d;
+    }
+    if (sum % 10 !== 0) return "Card number looks wrong";
+    if (!/^(0[1-9]|1[0-2])\/\d{2}$/.test(cardExpiry)) return "Expiry should be MM/YY";
+    if (!/^\d{3,4}$/.test(cardCvc)) return "CVC should be 3 or 4 digits";
+    return null;
+  }
+
+  async function submit() {
+    const cardErr = validateCard();
+    if (cardErr) { setSubmitError(cardErr); return; }
+    setSubmitting(true);
+    setSubmitError("");
+    try {
+      const tokenRes = await api.post("/payments/tokenise", {
+        number: cardNumber.replace(/\s/g, ""), expiry: cardExpiry, cvc: cardCvc,
+      });
+      const orderRes = await api.post("/orders", {
+        email, address, shippingId: shipping?.id, promoCode: promoPercent ? promoCode : null,
+        items: items.map((i) => ({ sku: i.sku, qty: i.qty })),
+        expectedTotalPence: total,
+        paymentToken: tokenRes.data.token,
+      });
+      onComplete(orderRes.data.id);
+    } catch (e: any) {
+      setSubmitError(e?.response?.data?.message || "Payment failed, please try again");
+    } finally {
+      setSubmitting(false);
+    }
+  }
+
+  const fmt = (p: number) => `£${(p / 100).toFixed(2)}`;
+
+  // ---- render ---------------------------------------------------------
+  return (
+    <div className="checkout">
+      <aside className="checkout__summary">
+        {items.map((i) => (
+          <div key={i.sku} className="row">
+            <span>{i.name} x {i.qty}</span>
+            <span>{fmt(i.unitPence * i.qty)}</span>
+          </div>
+        ))}
+        {discount > 0 && <div className="row"><span>Discount</span><span>-{fmt(discount)}</span></div>}
+        <div className="row"><span>Shipping</span><span>{freeShipping ? "Free" : fmt(shippingPence)}</span></div>
+        <div className="row row--total"><span>Total</span><span>{fmt(total)}</span></div>
+        <div className="promo">
+          <input value={promoCode} onChange={(e) => setPromoCode(e.target.value)} placeholder="Promo code" />
+          <button onClick={applyPromo}>Apply</button>
+          {promoError && <p className="error">{promoError}</p>}
+        </div>
+      </aside>
+
+      {step === "address" && (
+        <section>
+          <h2>Where should we send it?</h2>
+          <label>Email<input value={email} onChange={(e) => setEmail(e.target.value)} /></label>
+          {addressErrors.email && <p className="error">{addressErrors.email}</p>}
+          <label>Address line 1<input value={address.line1} onChange={(e) => setAddress({ ...address, line1: e.target.value })} /></label>
+          {addressErrors.line1 && <p className="error">{addressErrors.line1}</p>}
+          <label>Address line 2<input value={address.line2} onChange={(e) => setAddress({ ...address, line2: e.target.value })} /></label>
+          <label>City<input value={address.city} onChange={(e) => setAddress({ ...address, city: e.target.value })} /></label>
+          {addressErrors.city && <p className="error">{addressErrors.city}</p>}
+          <label>Postcode<input value={address.postcode} onChange={(e) => setAddress({ ...address, postcode: e.target.value })} /></label>
+          {addressErrors.postcode && <p className="error">{addressErrors.postcode}</p>}
+          <label>Country
+            <select value={address.country} onChange={(e) => setAddress({ ...address, country: e.target.value })}>
+              <option value="GB">United Kingdom</option>
+              <option value="IE">Ireland</option>
+              <option value="FR">France</option>
+              <option value="DE">Germany</option>
+            </select>
+          </label>
+          <button onClick={goToShipping}>Continue to shipping</button>
+        </section>
+      )}
+
+      {step === "shipping" && (
+        <section>
+          <h2>Delivery</h2>
+          {shippingOptions.map((o) => (
+            <label key={o.id} className="radio">
+              <input type="radio" checked={shipping?.id === o.id} onChange={() => setShipping(o)} />
+              {o.label} - {freeShipping ? "Free" : fmt(o.pence)}
+            </label>
+          ))}
+          <button onClick={() => setStep("address")}>Back</button>
+          <button onClick={() => setStep("payment")} disabled={!shipping}>Continue to payment</button>
+        </section>
+      )}
+
+      {step === "payment" && (
+        <section>
+          <h2>Payment</h2>
+          <label>Card number<input value={cardNumber} onChange={(e) => setCardNumber(e.target.value)} inputMode="numeric" /></label>
+          <label>Expiry (MM/YY)<input value={cardExpiry} onChange={(e) => setCardExpiry(e.target.value)} /></label>
+          <label>CVC<input value={cardCvc} onChange={(e) => setCardCvc(e.target.value)} inputMode="numeric" /></label>
+          {submitError && <p className="error">{submitError}</p>}
+          <button onClick={() => setStep("shipping")}>Back</button>
+          <button onClick={submit} disabled={submitting}>{submitting ? "Paying..." : `Pay ${fmt(total)}`}</button>
+        </section>
+      )}
+    </div>
+  );
+}

package/packs/dev-team/skills/refactor-plan/evals/files/7/web/src/components/MiniCart.tsx

@@ -0,0 +1,33 @@
+import React from "react";
+import { CartItem } from "../types";
+
+type Props = {
+  items: CartItem[];
+  promoPercent: number;
+  shippingPence: number;
+};
+
+// header dropdown cart; same maths as CheckoutPanel
+export default function MiniCart({ items, promoPercent, shippingPence }: Props) {
+  const afterDiscount = items.reduce(
+    (sum, i) => sum + Math.round(i.unitPence * i.qty * (1 - promoPercent / 100)),
+    0
+  );
+  const discount = items.reduce((s, i) => s + i.unitPence * i.qty, 0) - afterDiscount;
+  const freeShipping = afterDiscount >= 5000;
+  const total = afterDiscount + (freeShipping ? 0 : shippingPence);
+  const fmt = (p: number) => `£${(p / 100).toFixed(2)}`;
+
+  return (
+    <div className="minicart">
+      {items.map((i) => (
+        <div key={i.sku} className="minicart__row">
+          {i.name} x {i.qty} <span>{fmt(i.unitPence * i.qty)}</span>
+        </div>
+      ))}
+      {discount > 0 && <div className="minicart__row">Discount -{fmt(discount)}</div>}
+      <div className="minicart__total">Total {fmt(total)}</div>
+      {freeShipping && <p className="minicart__hint">You've got free delivery</p>}
+    </div>
+  );
+}

package/packs/dev-team/skills/refactor-plan/evals/files/7/web/src/components/__tests__/CheckoutPanel.test.tsx

@@ -0,0 +1,13 @@
+import React from "react";
+import { render } from "@testing-library/react";
+import CheckoutPanel from "../CheckoutPanel";
+
+const items = [
+  { sku: "MUG-01", name: "Mug", unitPence: 1299, qty: 2 },
+  { sku: "TEA-04", name: "Loose tea", unitPence: 850, qty: 1 },
+];
+
+it("renders", () => {
+  const { container } = render(<CheckoutPanel items={items} onComplete={() => {}} />);
+  expect(container).toMatchSnapshot();
+});

package/packs/dev-team/skills/refactor-plan/evals/files/7/web/src/pages/OrderReview.tsx

@@ -0,0 +1,24 @@
+import React from "react";
+import { useNavigate } from "react-router-dom";
+
+// Shown when a returning visitor lands on /checkout/review from the
+// "you left something behind" email.
+export default function OrderReview() {
+  const navigate = useNavigate();
+  const raw = localStorage.getItem("checkout_draft");
+  const draft = raw ? JSON.parse(raw) : null;
+
+  if (!draft || !draft.email) {
+    navigate("/cart");
+    return null;
+  }
+
+  return (
+    <main className="review">
+      <h1>Pick up where you left off</h1>
+      <p>We saved your details for {draft.email}.</p>
+      <p>Your total was <strong>£{(draft.total / 100).toFixed(2)}</strong>.</p>
+      <button onClick={() => navigate("/checkout")}>Continue to checkout</button>
+    </main>
+  );
+}