diff --git a/frontend/app/[locale]/shop/checkout/payment/StripePaymentClient.tsx b/frontend/app/[locale]/shop/checkout/payment/StripePaymentClient.tsx
index 3d33a743..51fcb73b 100644
--- a/frontend/app/[locale]/shop/checkout/payment/StripePaymentClient.tsx
+++ b/frontend/app/[locale]/shop/checkout/payment/StripePaymentClient.tsx
@@ -1,10 +1,8 @@
-// frontend/app/[locale]/shop/checkout/payment/StripePaymentClient.tsx
 'use client';
 
 import { useMemo, useState } from 'react';
-import { Link } from '@/i18n/routing';
+import { Link, useRouter } from '@/i18n/routing';
 
-import { useRouter } from 'next/navigation';
 import {
   Elements,
   PaymentElement,
@@ -50,14 +48,21 @@ function toCurrencyCode(
     : resolveCurrencyFromLocale(locale);
 }
 
+function buildShopBase(locale: string) {
+  return `/${locale}/shop`;
+}
+
 function nextRouteForPaymentResult(params: {
   locale: string;
   orderId: string;
   status?: string | null;
 }) {
-  const { orderId, status } = params;
-  const success = `/shop/checkout/success?orderId=${orderId}`;
-  const failure = `/shop/checkout/error?orderId=${orderId}`;
+  const { locale, orderId, status } = params;
+  const shopBase = buildShopBase(locale);
+  const id = encodeURIComponent(orderId);
+
+  const success = `${shopBase}/checkout/success?orderId=${id}`;
+  const failure = `${shopBase}/checkout/error?orderId=${id}`;
 
   if (!status) return success;
   if (
@@ -75,6 +80,9 @@ function StripePaymentForm({ orderId, locale }: PaymentFormProps) {
   const stripe = useStripe();
   const elements = useElements();
   const router = useRouter();
+
+  const shopBase = useMemo(() => buildShopBase(locale), [locale]);
+
   const [submitting, setSubmitting] = useState(false);
   const [errorMessage, setErrorMessage] = useState<string | null>(null);
 
@@ -92,17 +100,20 @@ function StripePaymentForm({ orderId, locale }: PaymentFormProps) {
     setSubmitting(true);
 
     try {
+      const id = encodeURIComponent(orderId);
+
       const { error, paymentIntent } = await stripe.confirmPayment({
         elements,
         redirect: 'if_required',
         confirmParams: {
-          return_url: `${window.location.origin}/shop/checkout/success?orderId=${orderId}`,
+          // Stripe redirect comes from outside Next.js routing — must include locale.
+          return_url: `${window.location.origin}${shopBase}/checkout/success?orderId=${id}`,
         },
       });
 
       if (error) {
         setErrorMessage(error.message ?? 'Unable to confirm payment.');
-        router.push(`/shop/checkout/error?orderId=${orderId}`);
+        router.push(`${shopBase}/checkout/error?orderId=${id}`);
         return;
       }
 
@@ -111,11 +122,14 @@ function StripePaymentForm({ orderId, locale }: PaymentFormProps) {
         orderId,
         status: paymentIntent?.status ?? null,
       });
+
       router.push(next);
     } catch (error) {
       logError('stripe_payment_confirm_failed', error, { orderId });
       setErrorMessage('We couldn’t confirm your payment. Please try again.');
-      router.push(`/shop/checkout/error?orderId=${orderId}`);
+      router.push(
+        `${shopBase}/checkout/error?orderId=${encodeURIComponent(orderId)}`
+      );
     } finally {
       setSubmitting(false);
     }
@@ -161,6 +175,8 @@ export default function StripePaymentClient({
     [currency, locale]
   );
 
+  const shopBase = useMemo(() => buildShopBase(locale), [locale]);
+
   const stripePromise = useMemo(() => {
     if (!paymentsEnabled || !publishableKey) return null;
     return loadStripe(publishableKey);
@@ -183,13 +199,15 @@ export default function StripePaymentClient({
         <p>Payments are disabled in this environment.</p>
         <nav className="flex gap-3" aria-label="Next steps">
           <Link
-            href={`/shop/checkout/success?orderId=${orderId}`}
+            href={`${shopBase}/checkout/success?orderId=${encodeURIComponent(
+              orderId
+            )}`}
             className="inline-flex items-center justify-center rounded-md bg-accent px-4 py-2 text-sm font-semibold uppercase tracking-wide text-accent-foreground hover:bg-accent/90"
           >
             Continue
           </Link>
           <Link
-            href="/shop/cart"
+            href={`${shopBase}/cart`}
             className="inline-flex items-center justify-center rounded-md border border-border px-4 py-2 text-sm font-semibold uppercase tracking-wide text-foreground hover:bg-secondary"
           >
             Back to cart
@@ -207,7 +225,7 @@ export default function StripePaymentClient({
       >
         <p>Payment cannot be initialized. Please try again later.</p>
         <Link
-          href="/shop/cart"
+          href={`${shopBase}/cart`}
           className="inline-flex items-center justify-center rounded-md border border-border px-4 py-2 text-sm font-semibold uppercase tracking-wide text-foreground hover:bg-secondary"
         >
           Return to cart
diff --git a/frontend/app/[locale]/shop/checkout/payment/[orderId]/page.tsx b/frontend/app/[locale]/shop/checkout/payment/[orderId]/page.tsx
index eb23ce80..7b1c7858 100644
--- a/frontend/app/[locale]/shop/checkout/payment/[orderId]/page.tsx
+++ b/frontend/app/[locale]/shop/checkout/payment/[orderId]/page.tsx
@@ -6,9 +6,8 @@ import { getOrderSummary } from '@/lib/services/orders';
 import { OrderNotFoundError } from '@/lib/services/errors';
 import { orderIdParamSchema } from '@/lib/validation/shop';
 import { getStripeEnv } from '@/lib/env/stripe';
-import { createPaymentIntent, retrievePaymentIntent } from '@/lib/psp/stripe';
-import { setOrderPaymentIntent } from '@/lib/services/orders';
 import { logError } from '@/lib/logging';
+import { ensureStripePaymentIntentForOrder } from '@/lib/services/orders/payment-attempts';
 
 export const dynamic = 'force-dynamic';
 export const revalidate = 0;
@@ -90,6 +89,7 @@ export default async function PaymentPage(props: PaymentPageProps) {
   const clearCart = shouldClearCart(searchParams);
   const cc = clearCart ? '&clearCart=1' : '';
   const { locale } = params;
+  const shopBase = `/${locale}/shop`;
 
   const orderId = getOrderId(params);
 
@@ -101,13 +101,13 @@ export default async function PaymentPage(props: PaymentPageProps) {
       >
         <nav className="mt-6 flex justify-center gap-3" aria-label="Next steps">
           <Link
-            href="/shop/cart"
+            href={`${shopBase}/cart`}
             className="inline-flex items-center justify-center rounded-md border border-border px-4 py-2 text-sm font-semibold uppercase tracking-wide text-foreground hover:bg-secondary"
           >
             Go to cart
           </Link>
           <Link
-            href="/shop/products"
+            href={`${shopBase}/products`}
             className="inline-flex items-center justify-center rounded-md bg-accent px-4 py-2 text-sm font-semibold uppercase tracking-wide text-accent-foreground hover:bg-accent/90"
           >
             Continue shopping
@@ -133,13 +133,13 @@ export default async function PaymentPage(props: PaymentPageProps) {
             aria-label="Next steps"
           >
             <Link
-              href="/shop/cart"
+              href={`${shopBase}/cart`}
               className="inline-flex items-center justify-center rounded-md border border-border px-4 py-2 text-sm font-semibold uppercase tracking-wide text-foreground hover:bg-secondary"
             >
               Go to cart
             </Link>
             <Link
-              href="/shop/products"
+              href={`${shopBase}/products`}
               className="inline-flex items-center justify-center rounded-md bg-accent px-4 py-2 text-sm font-semibold uppercase tracking-wide text-accent-foreground hover:bg-accent/90"
             >
               Continue shopping
@@ -163,50 +163,28 @@ export default async function PaymentPage(props: PaymentPageProps) {
   let clientSecret = resolveClientSecret(searchParams);
   const publishableKey = paymentsEnabled ? stripeEnv.publishableKey : null;
 
-  // Ensure we have a clientSecret even when URL doesn't include ?clientSecret=...
-  // Source of truth for payment finality is webhook; this only initializes Elements.
   if (
     paymentsEnabled &&
     publishableKey &&
     (!clientSecret || !clientSecret.trim())
   ) {
     const existingPi = order.paymentIntentId?.trim() ?? '';
-    let phase:
-      | 'retrievePaymentIntent'
-      | 'createPaymentIntent'
-      | 'setOrderPaymentIntent'
-      | 'unknown' = 'unknown';
+    let phase: 'ensureStripePaymentIntentForOrder' | 'unknown' = 'unknown';
 
     try {
-      if (existingPi) {
-        phase = 'retrievePaymentIntent';
-        const retrieved = await retrievePaymentIntent(existingPi);
-        clientSecret = retrieved.clientSecret;
-      } else {
-        phase = 'createPaymentIntent';
-        const created = await createPaymentIntent({
-          amount: order.totalAmountMinor,
-          currency: order.currency,
-          orderId: order.id,
-          idempotencyKey: `pi:${order.id}`,
-        });
-
-        phase = 'setOrderPaymentIntent';
-        await setOrderPaymentIntent({
-          orderId: order.id,
-          paymentIntentId: created.paymentIntentId,
-        });
+      phase = 'ensureStripePaymentIntentForOrder';
+      const ensured = await ensureStripePaymentIntentForOrder({
+        orderId: order.id,
+        existingPaymentIntentId: existingPi || null,
+      });
 
-        clientSecret = created.clientSecret;
-      }
+      clientSecret = ensured.clientSecret;
     } catch (error) {
       logError('payment_page_failed', error, {
         orderId: order.id,
         existingPi,
         phase,
       });
-
-      // Leave clientSecret empty -> UI shows "Payment cannot be initialized"
     }
   }
 
@@ -223,13 +201,13 @@ export default async function PaymentPage(props: PaymentPageProps) {
             aria-label="Next steps"
           >
             <Link
-              href={`/shop/checkout/success?orderId=${order.id}${cc}`}
+              href={`${shopBase}/checkout/success?orderId=${order.id}${cc}`}
               className="inline-flex items-center justify-center rounded-md bg-accent px-4 py-2 text-sm font-semibold uppercase tracking-wide text-accent-foreground hover:bg-accent/90"
             >
               View confirmation
             </Link>
             <Link
-              href="/shop/products"
+              href={`${shopBase}/products`}
               className="inline-flex items-center justify-center rounded-md border border-border px-4 py-2 text-sm font-semibold uppercase tracking-wide text-foreground hover:bg-secondary"
             >
               Continue shopping
diff --git a/frontend/app/api/shop/admin/products/[id]/route.ts b/frontend/app/api/shop/admin/products/[id]/route.ts
index 055599b9..e09333eb 100644
--- a/frontend/app/api/shop/admin/products/[id]/route.ts
+++ b/frontend/app/api/shop/admin/products/[id]/route.ts
@@ -7,10 +7,14 @@ import {
   AdminUnauthorizedError,
   requireAdminApi,
 } from '@/lib/auth/admin';
+import {
+  InvalidPayloadError,
+  SlugConflictError,
+  PriceConfigError,
+} from '@/lib/services/errors';
 
 import { parseAdminProductForm } from '@/lib/admin/parseAdminProductForm';
 import { logError } from '@/lib/logging';
-import { InvalidPayloadError, SlugConflictError } from '@/lib/services/errors';
 import {
   deleteProduct,
   getAdminProductByIdWithPrices,
@@ -217,6 +221,19 @@ export async function PATCH(
     } catch (error) {
       logError('Failed to update product', error);
 
+      if (error instanceof PriceConfigError) {
+        return NextResponse.json(
+          {
+            error: error.message,
+            code: error.code, // PRICE_CONFIG_ERROR
+            productId: error.productId,
+            currency: error.currency,
+            field: 'prices',
+          },
+          { status: 400 }
+        );
+      }
+
       if (error instanceof InvalidPayloadError) {
         const anyErr = error as any;
         return NextResponse.json(
diff --git a/frontend/app/api/shop/checkout/route.ts b/frontend/app/api/shop/checkout/route.ts
index b5539c43..7ed814db 100644
--- a/frontend/app/api/shop/checkout/route.ts
+++ b/frontend/app/api/shop/checkout/route.ts
@@ -6,7 +6,6 @@ import { logError, logWarn } from '@/lib/logging';
 import { resolveRequestLocale } from '@/lib/shop/request-locale';
 import { IdempotencyConflictError } from '@/lib/services/errors';
 import { MoneyValueError } from '@/db/queries/shop/orders';
-import { createPaymentIntent, retrievePaymentIntent } from '@/lib/psp/stripe';
 import {
   InsufficientStockError,
   InvalidPayloadError,
@@ -14,17 +13,17 @@ import {
   PriceConfigError,
   OrderStateInvalidError,
 } from '@/lib/services/errors';
-
-import {
-  createOrderWithItems,
-  restockOrder,
-  setOrderPaymentIntent,
-} from '@/lib/services/orders';
 import {
   checkoutPayloadSchema,
   idempotencyKeySchema,
 } from '@/lib/validation/shop';
 import { type PaymentProvider, type PaymentStatus } from '@/lib/shop/payments';
+import {
+  PaymentAttemptsExhaustedError,
+  ensureStripePaymentIntentForOrder,
+} from '@/lib/services/orders/payment-attempts';
+
+import { createOrderWithItems, restockOrder } from '@/lib/services/orders';
 
 const EXPECTED_BUSINESS_ERROR_CODES = new Set([
   'IDEMPOTENCY_CONFLICT',
@@ -32,6 +31,7 @@ const EXPECTED_BUSINESS_ERROR_CODES = new Set([
   'INVALID_VARIANT',
   'INSUFFICIENT_STOCK',
   'PRICE_CONFIG_ERROR',
+  'PAYMENT_ATTEMPTS_EXHAUSTED',
 ]);
 
 function getErrorCode(err: unknown): string | null {
@@ -157,7 +157,11 @@ export async function POST(request: NextRequest) {
     logWarn('Failed to parse cart payload', {
       reason: error instanceof Error ? error.message : String(error),
     });
-    return errorResponse('INVALID_PAYLOAD', 'Unable to process cart data.', 400);
+    return errorResponse(
+      'INVALID_PAYLOAD',
+      'Unable to process cart data.',
+      400
+    );
   }
 
   const idempotencyKey = getIdempotencyKey(request);
@@ -232,18 +236,29 @@ export async function POST(request: NextRequest) {
       locale,
     });
 
-    const { order, totalCents } = result;
+    const { order } = result;
 
     const paymentsEnabled = isPaymentsEnabled();
 
     if (!paymentsEnabled) {
-      if (order.paymentProvider === 'none' && order.paymentStatus === 'failed') {
-        return errorResponse('CHECKOUT_FAILED', 'Order could not be completed.', 409, {
-          orderId: order.id,
-        });
+      if (
+        order.paymentProvider === 'none' &&
+        order.paymentStatus === 'failed'
+      ) {
+        return errorResponse(
+          'CHECKOUT_FAILED',
+          'Order could not be completed.',
+          409,
+          {
+            orderId: order.id,
+          }
+        );
       }
 
-      if (order.paymentProvider === 'stripe' && order.paymentStatus !== 'paid') {
+      if (
+        order.paymentProvider === 'stripe' &&
+        order.paymentStatus !== 'paid'
+      ) {
         return errorResponse(
           'PAYMENTS_DISABLED',
           'Payments are disabled. This order requires payment and cannot be processed.',
@@ -253,9 +268,16 @@ export async function POST(request: NextRequest) {
       }
 
       if (order.paymentProvider === 'none') {
-        if (!['paid', 'failed'].includes(order.paymentStatus) || order.paymentIntentId) {
+        if (
+          !['paid', 'failed'].includes(order.paymentStatus) ||
+          order.paymentIntentId
+        ) {
           logError(
-            `Payments disabled but order is not paid/none. orderId=${order.id} provider=${order.paymentProvider} status=${order.paymentStatus} intent=${order.paymentIntentId ?? 'null'}`,
+            `Payments disabled but order is not paid/none. orderId=${
+              order.id
+            } provider=${order.paymentProvider} status=${
+              order.paymentStatus
+            } intent=${order.paymentIntentId ?? 'null'}`,
             new Error('ORDER_STATE_INVALID')
           );
           return errorResponse(
@@ -267,16 +289,20 @@ export async function POST(request: NextRequest) {
       }
     }
 
-    const stripePaymentFlow = paymentsEnabled && order.paymentProvider === 'stripe';
+    const stripePaymentFlow =
+      paymentsEnabled && order.paymentProvider === 'stripe';
 
     // =========================
     // Existing order path
     // =========================
     if (!result.isNew) {
-      // Existing order already has PI: retrieve client_secret
-      if (stripePaymentFlow && order.paymentIntentId) {
+      if (stripePaymentFlow) {
         try {
-          const paymentIntent = await retrievePaymentIntent(order.paymentIntentId);
+          const ensured = await ensureStripePaymentIntentForOrder({
+            orderId: order.id,
+            existingPaymentIntentId: order.paymentIntentId ?? null,
+          });
+
           return buildCheckoutResponse({
             order: {
               id: order.id,
@@ -284,61 +310,36 @@ export async function POST(request: NextRequest) {
               totalAmount: order.totalAmount,
               paymentStatus: order.paymentStatus,
               paymentProvider: order.paymentProvider,
-              paymentIntentId: order.paymentIntentId ?? null,
+              paymentIntentId: ensured.paymentIntentId,
             },
             itemCount,
-            clientSecret: paymentIntent.clientSecret,
+            clientSecret: ensured.clientSecret,
             status: 200,
           });
         } catch (error) {
-          logError('Checkout payment intent retrieval failed', error);
-          return errorResponse('STRIPE_ERROR', 'Unable to initiate payment.', 502);
-        }
-      }
-
-      // Existing order without PI: create PI then attach (post-create => never 400)
-      if (stripePaymentFlow && !order.paymentIntentId) {
-        let paymentIntent: { paymentIntentId: string; clientSecret: string };
-
-        try {
-          paymentIntent = await createPaymentIntent({
-            amount: totalCents,
-            currency: order.currency,
-            orderId: order.id,
-            idempotencyKey,
-          });
-        } catch (error) {
-          logError('Checkout payment intent creation failed', error);
-          return errorResponse('STRIPE_ERROR', 'Unable to initiate payment.', 502);
-        }
-
-        try {
-          const updatedOrder = await setOrderPaymentIntent({
-            orderId: order.id,
-            paymentIntentId: paymentIntent.paymentIntentId,
-          });
-
-          return buildCheckoutResponse({
-            order: {
-              id: updatedOrder.id,
-              currency: updatedOrder.currency,
-              totalAmount: updatedOrder.totalAmount,
-              paymentStatus: updatedOrder.paymentStatus,
-              paymentProvider: updatedOrder.paymentProvider,
-              paymentIntentId: updatedOrder.paymentIntentId ?? null,
-            },
-            itemCount,
-            clientSecret: paymentIntent.clientSecret,
-            status: 200,
-          });
-        } catch (error) {
-          logError('Checkout payment intent attach failed', error);
+          if (error instanceof PaymentAttemptsExhaustedError) {
+            // Best-effort release to avoid holding reserved stock indefinitely.
+            try {
+              await restockOrder(order.id, { reason: 'failed' });
+            } catch (restockError) {
+              logError(
+                'Restoring stock after attempts exhausted failed',
+                restockError
+              );
+            }
+            return errorResponse(
+              'PAYMENT_ATTEMPTS_EXHAUSTED',
+              'Payment attempts exhausted for this order.',
+              409,
+              { orderId: error.orderId, provider: error.provider }
+            );
+          }
 
-          // Post-create => conflict, not 400
+          // Post-create/state conflict must be 409 (not 502)
           if (error instanceof InvalidPayloadError) {
             return errorResponse(
               'CHECKOUT_CONFLICT',
-              'Order state conflict while attaching payment intent. Retry with the same Idempotency-Key.',
+              'Order state conflict while initializing payment. Retry with the same Idempotency-Key.',
               409,
               { orderId: order.id }
             );
@@ -351,7 +352,12 @@ export async function POST(request: NextRequest) {
             });
           }
 
-          return errorResponse('INTERNAL_ERROR', 'Unable to process checkout.', 500);
+          logError('Checkout payment initialization failed', error);
+          return errorResponse(
+            'STRIPE_ERROR',
+            'Unable to initiate payment.',
+            502
+          );
         }
       }
 
@@ -390,77 +396,71 @@ export async function POST(request: NextRequest) {
       });
     }
 
-    // Stripe new order: Phase 1 PSP call (if fails => restock best-effort, return 502)
-    let paymentIntent: { paymentIntentId: string; clientSecret: string };
-
+    // Stripe new order: durable attempt layer (bounded + audited)
     try {
-      paymentIntent = await createPaymentIntent({
-        amount: totalCents,
-        currency: order.currency,
+      const ensured = await ensureStripePaymentIntentForOrder({
         orderId: order.id,
-        idempotencyKey,
-      });
-    } catch (error) {
-      logError('Checkout payment intent creation failed', error);
-
-      try {
-        await restockOrder(order.id, { reason: 'failed' });
-      } catch (restockError) {
-        logError('Restoring stock after payment intent failure failed', restockError);
-      }
-
-      return errorResponse('STRIPE_ERROR', 'Unable to initiate payment.', 502);
-    }
-
-    // Stripe new order: Phase 2 attach PI (post-create => never 400)
-    try {
-      const updatedOrder = await setOrderPaymentIntent({
-        orderId: order.id,
-        paymentIntentId: paymentIntent.paymentIntentId,
+        existingPaymentIntentId: order.paymentIntentId ?? null,
       });
 
       return buildCheckoutResponse({
         order: {
-          id: updatedOrder.id,
-          currency: updatedOrder.currency,
-          totalAmount: updatedOrder.totalAmount,
-          paymentStatus: updatedOrder.paymentStatus,
-          paymentProvider: updatedOrder.paymentProvider,
-          paymentIntentId: updatedOrder.paymentIntentId ?? null,
+          id: order.id,
+          currency: order.currency,
+          totalAmount: order.totalAmount,
+          paymentStatus: order.paymentStatus,
+          paymentProvider: order.paymentProvider,
+          paymentIntentId: ensured.paymentIntentId,
         },
         itemCount,
-        clientSecret: paymentIntent.clientSecret,
+        clientSecret: ensured.clientSecret,
         status: 201,
       });
     } catch (error) {
-      logError('Checkout payment intent attach failed', error);
-
+      // Conflict => 409 and DO NOT restock (leave reserved; retry/janitor)
       if (error instanceof InvalidPayloadError) {
-        // Conflict/race/state issue. Do NOT return 400.
-        // Leave inventory reserved; retry with same idempotency key or janitor will sweep.
         return errorResponse(
           'CHECKOUT_CONFLICT',
-          'Order state conflict while attaching payment intent. Retry with the same Idempotency-Key.',
+          'Order state conflict while initializing payment. Retry with the same Idempotency-Key.',
           409,
           { orderId: order.id }
         );
       }
+      if (error instanceof PaymentAttemptsExhaustedError) {
+        // Best-effort release to avoid holding reserved stock indefinitely
+        try {
+          await restockOrder(order.id, { reason: 'failed' });
+        } catch (restockError) {
+          logError(
+            'Restoring stock after attempts exhausted failed',
+            restockError
+          );
+        }
+        return errorResponse(
+          'PAYMENT_ATTEMPTS_EXHAUSTED',
+          'Payment attempts exhausted for this order.',
+          409,
+          { orderId: error.orderId, provider: error.provider }
+        );
+      }
+
+      logError('Checkout payment initialization failed', error);
 
-      // For non-conflict attach failures: best-effort release to avoid stock lock
       try {
         await restockOrder(order.id, { reason: 'failed' });
       } catch (restockError) {
-        logError('Restoring stock after payment intent attach failure failed', restockError);
+        logError(
+          'Restoring stock after payment init failure failed',
+          restockError
+        );
       }
-
       if (error instanceof OrderStateInvalidError) {
         return errorResponse(error.code, error.message, 500, {
           orderId: error.orderId,
           ...(error.details ? { details: error.details } : {}),
         });
       }
-
-      return errorResponse('INTERNAL_ERROR', 'Unable to process checkout.', 500);
+      return errorResponse('STRIPE_ERROR', 'Unable to initiate payment.', 502);
     }
   } catch (error) {
     if (isExpectedBusinessError(error)) {
@@ -473,7 +473,11 @@ export async function POST(request: NextRequest) {
     }
 
     if (error instanceof InvalidPayloadError) {
-      return errorResponse(error.code, error.message || 'Invalid checkout payload', 400);
+      return errorResponse(
+        error.code,
+        error.message || 'Invalid checkout payload',
+        400
+      );
     }
 
     if (error instanceof InvalidVariantError) {
@@ -524,4 +528,4 @@ export async function POST(request: NextRequest) {
 
     return errorResponse('INTERNAL_ERROR', 'Unable to process checkout.', 500);
   }
-}
\ No newline at end of file
+}
diff --git a/frontend/app/api/shop/webhooks/stripe/route.ts b/frontend/app/api/shop/webhooks/stripe/route.ts
index 12748241..f466a360 100644
--- a/frontend/app/api/shop/webhooks/stripe/route.ts
+++ b/frontend/app/api/shop/webhooks/stripe/route.ts
@@ -11,6 +11,7 @@ import {
   type RefundMetaRecord,
   appendRefundToMeta,
 } from '@/lib/services/orders/psp-metadata/refunds';
+import { markStripeAttemptFinal } from '@/lib/services/orders/payment-attempts';
 
 const REFUND_FULLNESS_UNDETERMINED = 'REFUND_FULLNESS_UNDETERMINED' as const;
 
@@ -525,6 +526,13 @@ export async function POST(request: NextRequest) {
           reason: mismatchReason,
         });
 
+        await markStripeAttemptFinal({
+          paymentIntentId,
+          status: 'succeeded',
+          errorCode: mismatchReason,
+          errorMessage: 'webhook_succeeded_but_mismatch',
+        });
+
         return ack();
       }
 
@@ -574,6 +582,10 @@ export async function POST(request: NextRequest) {
           ne(orders.paymentStatus, 'refunded')
         ),
       });
+      await markStripeAttemptFinal({
+        paymentIntentId,
+        status: 'succeeded',
+      });
 
       logWebhookEvent({
         orderId: order.id,
@@ -647,6 +659,16 @@ export async function POST(request: NextRequest) {
         await restockOrder(order.id, { reason: 'failed' });
       }
 
+      await markStripeAttemptFinal({
+        paymentIntentId,
+        status: 'failed',
+        errorCode:
+          paymentIntent?.last_payment_error?.decline_code ??
+          paymentIntent?.last_payment_error?.code ??
+          null,
+        errorMessage: paymentIntent?.last_payment_error?.message ?? null,
+      });
+
       logWebhookEvent({
         orderId: order.id,
         paymentIntentId,
@@ -716,7 +738,12 @@ export async function POST(request: NextRequest) {
       if (shouldRestockFromWebhook(order)) {
         await restockOrder(order.id, { reason: 'canceled' });
       }
-
+      await markStripeAttemptFinal({
+        paymentIntentId,
+        status: 'canceled',
+        errorCode: paymentIntent?.cancellation_reason ?? null,
+        errorMessage: 'payment_intent_canceled',
+      });
       logWebhookEvent({
         orderId: order.id,
         paymentIntentId,
diff --git a/frontend/components/shop/cart-provider.tsx b/frontend/components/shop/cart-provider.tsx
index 7c04a429..cf3802db 100644
--- a/frontend/components/shop/cart-provider.tsx
+++ b/frontend/components/shop/cart-provider.tsx
@@ -86,6 +86,7 @@ export function CartProvider({ children }: CartProviderProps) {
 
     try {
       const nextCart = await rehydrateCart(items);
+
       setCart(nextCart);
       return;
     } catch (error) {
@@ -107,6 +108,7 @@ export function CartProvider({ children }: CartProviderProps) {
 
             try {
               const retriedCart = await rehydrateCart(filtered);
+
               setCart(retriedCart);
 
               logWarn('cart_rehydrate_recovered_by_removing_item', {
diff --git a/frontend/db/schema/shop.ts b/frontend/db/schema/shop.ts
index 73c416eb..dd3a92ad 100644
--- a/frontend/db/schema/shop.ts
+++ b/frontend/db/schema/shop.ts
@@ -371,8 +371,76 @@ export const internalJobState = pgTable('internal_job_state', {
     .defaultNow(),
 });
 
+export const paymentAttempts = pgTable(
+  'payment_attempts',
+  {
+    id: uuid('id').defaultRandom().primaryKey(),
+
+    orderId: uuid('order_id')
+      .notNull()
+      .references(() => orders.id, { onDelete: 'cascade' }),
+
+    provider: text('provider').notNull(), // 'stripe'
+    status: text('status').notNull().default('active'), // active|succeeded|failed|canceled
+    attemptNumber: integer('attempt_number').notNull(),
+
+    idempotencyKey: text('idempotency_key').notNull(),
+    providerPaymentIntentId: text('provider_payment_intent_id'),
+
+    lastErrorCode: text('last_error_code'),
+    lastErrorMessage: text('last_error_message'),
+    metadata: jsonb('metadata')
+      .notNull()
+      .default(sql`'{}'::jsonb`),
+
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+
+    updatedAt: timestamp('updated_at', { withTimezone: true })
+      .notNull()
+      .defaultNow()
+      .$onUpdate(() => new Date()),
+
+    finalizedAt: timestamp('finalized_at', { withTimezone: true }),
+  },
+  t => [
+    // CHECKs (match SQL migration)
+    check(
+      'payment_attempts_status_check',
+      sql`${t.status} in ('active','succeeded','failed','canceled')`
+    ),
+    check(
+      'payment_attempts_attempt_number_check',
+      sql`${t.attemptNumber} >= 1`
+    ),
+
+    // UNIQUE / INDEX (match SQL migration)
+    uniqueIndex('payment_attempts_order_provider_attempt_unique').on(
+      t.orderId,
+      t.provider,
+      t.attemptNumber
+    ),
+    uniqueIndex('payment_attempts_idempotency_key_unique').on(t.idempotencyKey),
+    uniqueIndex('payment_attempts_provider_pi_unique').on(
+      t.providerPaymentIntentId
+    ),
+    index('payment_attempts_order_provider_status_idx').on(
+      t.orderId,
+      t.provider,
+      t.status
+    ),
+
+    // Critical: at most ONE active attempt per (order, provider)
+    uniqueIndex('payment_attempts_order_provider_active_unique')
+      .on(t.orderId, t.provider)
+      .where(sql`${t.status} = 'active'`),
+  ]
+);
+
 export type DbProductPrice = typeof productPrices.$inferSelect;
 export type DbOrder = typeof orders.$inferSelect;
 export type DbOrderItem = typeof orderItems.$inferSelect;
 export type DbInventoryMove = typeof inventoryMoves.$inferSelect;
 export type DbInternalJobState = typeof internalJobState.$inferSelect;
+export type DbPaymentAttempt = typeof paymentAttempts.$inferSelect;
diff --git a/frontend/drizzle/0001_add_payment_attempts.sql b/frontend/drizzle/0001_add_payment_attempts.sql
new file mode 100644
index 00000000..91a4571b
--- /dev/null
+++ b/frontend/drizzle/0001_add_payment_attempts.sql
@@ -0,0 +1,25 @@
+CREATE TABLE "payment_attempts" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"order_id" uuid NOT NULL,
+	"provider" text NOT NULL,
+	"status" text DEFAULT 'active' NOT NULL,
+	"attempt_number" integer NOT NULL,
+	"idempotency_key" text NOT NULL,
+	"provider_payment_intent_id" text,
+	"last_error_code" text,
+	"last_error_message" text,
+	"metadata" jsonb DEFAULT '{}'::jsonb NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"finalized_at" timestamp with time zone,
+	CONSTRAINT "payment_attempts_provider_check" CHECK ("payment_attempts"."provider" in ('stripe')),
+	CONSTRAINT "payment_attempts_status_check" CHECK ("payment_attempts"."status" in ('active','succeeded','failed','canceled')),
+	CONSTRAINT "payment_attempts_attempt_number_check" CHECK ("payment_attempts"."attempt_number" >= 1)
+);
+--> statement-breakpoint
+ALTER TABLE "payment_attempts" ADD CONSTRAINT "payment_attempts_order_id_orders_id_fk" FOREIGN KEY ("order_id") REFERENCES "public"."orders"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE UNIQUE INDEX "payment_attempts_order_provider_attempt_unique" ON "payment_attempts" USING btree ("order_id","provider","attempt_number");--> statement-breakpoint
+CREATE UNIQUE INDEX "payment_attempts_idempotency_key_unique" ON "payment_attempts" USING btree ("idempotency_key");--> statement-breakpoint
+CREATE UNIQUE INDEX "payment_attempts_provider_pi_unique" ON "payment_attempts" USING btree ("provider_payment_intent_id");--> statement-breakpoint
+CREATE INDEX "payment_attempts_order_provider_status_idx" ON "payment_attempts" USING btree ("order_id","provider","status");--> statement-breakpoint
+CREATE UNIQUE INDEX "payment_attempts_order_provider_active_unique" ON "payment_attempts" USING btree ("order_id","provider") WHERE "payment_attempts"."status" = 'active';
\ No newline at end of file
diff --git a/frontend/drizzle/meta/0001_snapshot.json b/frontend/drizzle/meta/0001_snapshot.json
new file mode 100644
index 00000000..50cd427b
--- /dev/null
+++ b/frontend/drizzle/meta/0001_snapshot.json
@@ -0,0 +1,2667 @@
+{
+  "id": "5ec892bf-3144-420f-9088-e3da34eac2c9",
+  "prevId": "c518aedf-2c17-41cb-b212-06227fe6dcb4",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.categories": {
+      "name": "categories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "categories_slug_unique": {
+          "name": "categories_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.category_translations": {
+      "name": "category_translations",
+      "schema": "",
+      "columns": {
+        "category_id": {
+          "name": "category_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(5)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "category_translations_category_id_categories_id_fk": {
+          "name": "category_translations_category_id_categories_id_fk",
+          "tableFrom": "category_translations",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "category_translations_category_id_locale_pk": {
+          "name": "category_translations_category_id_locale_pk",
+          "columns": [
+            "category_id",
+            "locale"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.question_translations": {
+      "name": "question_translations",
+      "schema": "",
+      "columns": {
+        "question_id": {
+          "name": "question_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(5)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "question": {
+          "name": "question",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "answer_blocks": {
+          "name": "answer_blocks",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "question_translations_question_id_questions_id_fk": {
+          "name": "question_translations_question_id_questions_id_fk",
+          "tableFrom": "question_translations",
+          "tableTo": "questions",
+          "columnsFrom": [
+            "question_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "question_translations_question_id_locale_pk": {
+          "name": "question_translations_question_id_locale_pk",
+          "columns": [
+            "question_id",
+            "locale"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.questions": {
+      "name": "questions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "difficulty": {
+          "name": "difficulty",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'medium'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "questions_category_sort_order_idx": {
+          "name": "questions_category_sort_order_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sort_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "questions_category_id_categories_id_fk": {
+          "name": "questions_category_id_categories_id_fk",
+          "tableFrom": "questions",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quiz_answer_translations": {
+      "name": "quiz_answer_translations",
+      "schema": "",
+      "columns": {
+        "quiz_answer_id": {
+          "name": "quiz_answer_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(5)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "answer_text": {
+          "name": "answer_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "quiz_answer_translations_quiz_answer_id_quiz_answers_id_fk": {
+          "name": "quiz_answer_translations_quiz_answer_id_quiz_answers_id_fk",
+          "tableFrom": "quiz_answer_translations",
+          "tableTo": "quiz_answers",
+          "columnsFrom": [
+            "quiz_answer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "quiz_answer_translations_quiz_answer_id_locale_pk": {
+          "name": "quiz_answer_translations_quiz_answer_id_locale_pk",
+          "columns": [
+            "quiz_answer_id",
+            "locale"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quiz_answers": {
+      "name": "quiz_answers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "quiz_question_id": {
+          "name": "quiz_question_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_correct": {
+          "name": "is_correct",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        }
+      },
+      "indexes": {
+        "quiz_answers_question_display_order_idx": {
+          "name": "quiz_answers_question_display_order_idx",
+          "columns": [
+            {
+              "expression": "quiz_question_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "quiz_answers_quiz_question_id_quiz_questions_id_fk": {
+          "name": "quiz_answers_quiz_question_id_quiz_questions_id_fk",
+          "tableFrom": "quiz_answers",
+          "tableTo": "quiz_questions",
+          "columnsFrom": [
+            "quiz_question_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quiz_attempt_answers": {
+      "name": "quiz_attempt_answers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "attempt_id": {
+          "name": "attempt_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "quiz_question_id": {
+          "name": "quiz_question_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "selected_answer_id": {
+          "name": "selected_answer_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_correct": {
+          "name": "is_correct",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "answered_at": {
+          "name": "answered_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "quiz_attempt_answers_attempt_idx": {
+          "name": "quiz_attempt_answers_attempt_idx",
+          "columns": [
+            {
+              "expression": "attempt_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "quiz_attempt_answers_attempt_id_quiz_attempts_id_fk": {
+          "name": "quiz_attempt_answers_attempt_id_quiz_attempts_id_fk",
+          "tableFrom": "quiz_attempt_answers",
+          "tableTo": "quiz_attempts",
+          "columnsFrom": [
+            "attempt_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "quiz_attempt_answers_quiz_question_id_quiz_questions_id_fk": {
+          "name": "quiz_attempt_answers_quiz_question_id_quiz_questions_id_fk",
+          "tableFrom": "quiz_attempt_answers",
+          "tableTo": "quiz_questions",
+          "columnsFrom": [
+            "quiz_question_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "quiz_attempt_answers_selected_answer_id_quiz_answers_id_fk": {
+          "name": "quiz_attempt_answers_selected_answer_id_quiz_answers_id_fk",
+          "tableFrom": "quiz_attempt_answers",
+          "tableTo": "quiz_answers",
+          "columnsFrom": [
+            "selected_answer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quiz_attempts": {
+      "name": "quiz_attempts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "quiz_id": {
+          "name": "quiz_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "score": {
+          "name": "score",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_questions": {
+          "name": "total_questions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "percentage": {
+          "name": "percentage",
+          "type": "numeric(5, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "time_spent_seconds": {
+          "name": "time_spent_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "integrity_score": {
+          "name": "integrity_score",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 100
+        },
+        "points_earned": {
+          "name": "points_earned",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'{}'::jsonb"
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "quiz_attempts_user_id_idx": {
+          "name": "quiz_attempts_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "quiz_attempts_quiz_id_idx": {
+          "name": "quiz_attempts_quiz_id_idx",
+          "columns": [
+            {
+              "expression": "quiz_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "quiz_attempts_user_completed_at_idx": {
+          "name": "quiz_attempts_user_completed_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "completed_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "quiz_attempts_quiz_percentage_completed_at_idx": {
+          "name": "quiz_attempts_quiz_percentage_completed_at_idx",
+          "columns": [
+            {
+              "expression": "quiz_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "percentage",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "completed_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "quiz_attempts_quiz_integrity_score_idx": {
+          "name": "quiz_attempts_quiz_integrity_score_idx",
+          "columns": [
+            {
+              "expression": "quiz_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "integrity_score",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "quiz_attempts_user_id_users_id_fk": {
+          "name": "quiz_attempts_user_id_users_id_fk",
+          "tableFrom": "quiz_attempts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "quiz_attempts_quiz_id_quizzes_id_fk": {
+          "name": "quiz_attempts_quiz_id_quizzes_id_fk",
+          "tableFrom": "quiz_attempts",
+          "tableTo": "quizzes",
+          "columnsFrom": [
+            "quiz_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quiz_question_content": {
+      "name": "quiz_question_content",
+      "schema": "",
+      "columns": {
+        "quiz_question_id": {
+          "name": "quiz_question_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(5)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "question_text": {
+          "name": "question_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "explanation": {
+          "name": "explanation",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "quiz_question_content_quiz_question_id_quiz_questions_id_fk": {
+          "name": "quiz_question_content_quiz_question_id_quiz_questions_id_fk",
+          "tableFrom": "quiz_question_content",
+          "tableTo": "quiz_questions",
+          "columnsFrom": [
+            "quiz_question_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "quiz_question_content_quiz_question_id_locale_pk": {
+          "name": "quiz_question_content_quiz_question_id_locale_pk",
+          "columns": [
+            "quiz_question_id",
+            "locale"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quiz_questions": {
+      "name": "quiz_questions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "quiz_id": {
+          "name": "quiz_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_question_id": {
+          "name": "source_question_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "difficulty": {
+          "name": "difficulty",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'medium'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "quiz_questions_quiz_display_order_idx": {
+          "name": "quiz_questions_quiz_display_order_idx",
+          "columns": [
+            {
+              "expression": "quiz_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "quiz_questions_quiz_id_quizzes_id_fk": {
+          "name": "quiz_questions_quiz_id_quizzes_id_fk",
+          "tableFrom": "quiz_questions",
+          "tableTo": "quizzes",
+          "columnsFrom": [
+            "quiz_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quiz_translations": {
+      "name": "quiz_translations",
+      "schema": "",
+      "columns": {
+        "quiz_id": {
+          "name": "quiz_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "locale": {
+          "name": "locale",
+          "type": "varchar(5)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "quiz_translations_quiz_id_quizzes_id_fk": {
+          "name": "quiz_translations_quiz_id_quizzes_id_fk",
+          "tableFrom": "quiz_translations",
+          "tableTo": "quizzes",
+          "columnsFrom": [
+            "quiz_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "quiz_translations_quiz_id_locale_pk": {
+          "name": "quiz_translations_quiz_id_locale_pk",
+          "columns": [
+            "quiz_id",
+            "locale"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quizzes": {
+      "name": "quizzes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "questions_count": {
+          "name": "questions_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 10
+        },
+        "time_limit_seconds": {
+          "name": "time_limit_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "quizzes_slug_idx": {
+          "name": "quizzes_slug_idx",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "quizzes_category_id_categories_id_fk": {
+          "name": "quizzes_category_id_categories_id_fk",
+          "tableFrom": "quizzes",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "quizzes_category_id_slug_unique": {
+          "name": "quizzes_category_id_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "category_id",
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'credentials'"
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'user'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "users_provider_provider_id_unique": {
+          "name": "users_provider_provider_id_unique",
+          "columns": [
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "provider_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "users_email_unique": {
+          "name": "users_email_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "email"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.point_transactions": {
+      "name": "point_transactions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "points": {
+          "name": "points",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'quiz'"
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'{}'::jsonb"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "point_transactions_user_id_idx": {
+          "name": "point_transactions_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "point_transactions_user_id_users_id_fk": {
+          "name": "point_transactions_user_id_users_id_fk",
+          "tableFrom": "point_transactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.internal_job_state": {
+      "name": "internal_job_state",
+      "schema": "",
+      "columns": {
+        "job_name": {
+          "name": "job_name",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "next_allowed_at": {
+          "name": "next_allowed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_run_id": {
+          "name": "last_run_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.inventory_moves": {
+      "name": "inventory_moves",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "move_key": {
+          "name": "move_key",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "order_id": {
+          "name": "order_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "product_id": {
+          "name": "product_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "inventory_move_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "inventory_moves_move_key_uq": {
+          "name": "inventory_moves_move_key_uq",
+          "columns": [
+            {
+              "expression": "move_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "inventory_moves_order_id_idx": {
+          "name": "inventory_moves_order_id_idx",
+          "columns": [
+            {
+              "expression": "order_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "inventory_moves_product_id_idx": {
+          "name": "inventory_moves_product_id_idx",
+          "columns": [
+            {
+              "expression": "product_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "inventory_moves_order_id_orders_id_fk": {
+          "name": "inventory_moves_order_id_orders_id_fk",
+          "tableFrom": "inventory_moves",
+          "tableTo": "orders",
+          "columnsFrom": [
+            "order_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "inventory_moves_product_id_products_id_fk": {
+          "name": "inventory_moves_product_id_products_id_fk",
+          "tableFrom": "inventory_moves",
+          "tableTo": "products",
+          "columnsFrom": [
+            "product_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "inventory_moves_quantity_gt_0": {
+          "name": "inventory_moves_quantity_gt_0",
+          "value": "\"inventory_moves\".\"quantity\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.order_items": {
+      "name": "order_items",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "order_id": {
+          "name": "order_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "product_id": {
+          "name": "product_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "selected_size": {
+          "name": "selected_size",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "selected_color": {
+          "name": "selected_color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "unit_price_minor": {
+          "name": "unit_price_minor",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "line_total_minor": {
+          "name": "line_total_minor",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "unit_price": {
+          "name": "unit_price",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "line_total": {
+          "name": "line_total",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "product_title": {
+          "name": "product_title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "product_slug": {
+          "name": "product_slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "product_sku": {
+          "name": "product_sku",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "order_items_order_id_idx": {
+          "name": "order_items_order_id_idx",
+          "columns": [
+            {
+              "expression": "order_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "order_items_order_variant_uq": {
+          "name": "order_items_order_variant_uq",
+          "columns": [
+            {
+              "expression": "order_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "product_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "selected_size",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "selected_color",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "order_items_order_id_orders_id_fk": {
+          "name": "order_items_order_id_orders_id_fk",
+          "tableFrom": "order_items",
+          "tableTo": "orders",
+          "columnsFrom": [
+            "order_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "order_items_product_id_products_id_fk": {
+          "name": "order_items_product_id_products_id_fk",
+          "tableFrom": "order_items",
+          "tableTo": "products",
+          "columnsFrom": [
+            "product_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "order_items_quantity_positive": {
+          "name": "order_items_quantity_positive",
+          "value": "\"order_items\".\"quantity\" > 0"
+        },
+        "order_items_unit_price_minor_non_negative": {
+          "name": "order_items_unit_price_minor_non_negative",
+          "value": "\"order_items\".\"unit_price_minor\" >= 0"
+        },
+        "order_items_line_total_minor_non_negative": {
+          "name": "order_items_line_total_minor_non_negative",
+          "value": "\"order_items\".\"line_total_minor\" >= 0"
+        },
+        "order_items_line_total_consistent": {
+          "name": "order_items_line_total_consistent",
+          "value": "\"order_items\".\"line_total_minor\" = \"order_items\".\"unit_price_minor\" * \"order_items\".\"quantity\""
+        },
+        "order_items_unit_price_mirror_consistent": {
+          "name": "order_items_unit_price_mirror_consistent",
+          "value": "\"order_items\".\"unit_price\" = (\"order_items\".\"unit_price_minor\"::numeric / 100)"
+        },
+        "order_items_line_total_mirror_consistent": {
+          "name": "order_items_line_total_mirror_consistent",
+          "value": "\"order_items\".\"line_total\" = (\"order_items\".\"line_total_minor\"::numeric / 100)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.orders": {
+      "name": "orders",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "total_amount_minor": {
+          "name": "total_amount_minor",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_amount": {
+          "name": "total_amount",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "currency": {
+          "name": "currency",
+          "type": "currency",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'USD'"
+        },
+        "payment_status": {
+          "name": "payment_status",
+          "type": "payment_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "payment_provider": {
+          "name": "payment_provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'stripe'"
+        },
+        "payment_intent_id": {
+          "name": "payment_intent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "psp_charge_id": {
+          "name": "psp_charge_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "psp_payment_method": {
+          "name": "psp_payment_method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "psp_status_reason": {
+          "name": "psp_status_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "psp_metadata": {
+          "name": "psp_metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "status": {
+          "name": "status",
+          "type": "order_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'CREATED'"
+        },
+        "inventory_status": {
+          "name": "inventory_status",
+          "type": "inventory_status",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'none'"
+        },
+        "failure_code": {
+          "name": "failure_code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "failure_message": {
+          "name": "failure_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "idempotency_request_hash": {
+          "name": "idempotency_request_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "stock_restored": {
+          "name": "stock_restored",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "restocked_at": {
+          "name": "restocked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "varchar(128)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "sweep_claimed_at": {
+          "name": "sweep_claimed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sweep_claim_expires_at": {
+          "name": "sweep_claim_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sweep_run_id": {
+          "name": "sweep_run_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sweep_claimed_by": {
+          "name": "sweep_claimed_by",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "orders_sweep_claim_expires_idx": {
+          "name": "orders_sweep_claim_expires_idx",
+          "columns": [
+            {
+              "expression": "sweep_claim_expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "orders_user_id_users_id_fk": {
+          "name": "orders_user_id_users_id_fk",
+          "tableFrom": "orders",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "orders_idempotency_key_unique": {
+          "name": "orders_idempotency_key_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "idempotency_key"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "orders_payment_provider_valid": {
+          "name": "orders_payment_provider_valid",
+          "value": "\"orders\".\"payment_provider\" in ('stripe', 'none')"
+        },
+        "orders_total_amount_minor_non_negative": {
+          "name": "orders_total_amount_minor_non_negative",
+          "value": "\"orders\".\"total_amount_minor\" >= 0"
+        },
+        "orders_payment_intent_id_null_when_none": {
+          "name": "orders_payment_intent_id_null_when_none",
+          "value": "\"orders\".\"payment_provider\" <> 'none' OR \"orders\".\"payment_intent_id\" IS NULL"
+        },
+        "orders_psp_fields_null_when_none": {
+          "name": "orders_psp_fields_null_when_none",
+          "value": "\"orders\".\"payment_provider\" <> 'none' OR (\n        \"orders\".\"psp_charge_id\" IS NULL AND\n        \"orders\".\"psp_payment_method\" IS NULL AND\n        \"orders\".\"psp_status_reason\" IS NULL\n      )"
+        },
+        "orders_total_amount_mirror_consistent": {
+          "name": "orders_total_amount_mirror_consistent",
+          "value": "\"orders\".\"total_amount\" = (\"orders\".\"total_amount_minor\"::numeric / 100)"
+        },
+        "orders_payment_status_valid_when_none": {
+          "name": "orders_payment_status_valid_when_none",
+          "value": "\"orders\".\"payment_provider\" <> 'none' OR \"orders\".\"payment_status\" in ('paid','failed')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.payment_attempts": {
+      "name": "payment_attempts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "order_id": {
+          "name": "order_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        },
+        "attempt_number": {
+          "name": "attempt_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_payment_intent_id": {
+          "name": "provider_payment_intent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error_code": {
+          "name": "last_error_code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error_message": {
+          "name": "last_error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "finalized_at": {
+          "name": "finalized_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "payment_attempts_order_provider_attempt_unique": {
+          "name": "payment_attempts_order_provider_attempt_unique",
+          "columns": [
+            {
+              "expression": "order_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "attempt_number",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "payment_attempts_idempotency_key_unique": {
+          "name": "payment_attempts_idempotency_key_unique",
+          "columns": [
+            {
+              "expression": "idempotency_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "payment_attempts_provider_pi_unique": {
+          "name": "payment_attempts_provider_pi_unique",
+          "columns": [
+            {
+              "expression": "provider_payment_intent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "payment_attempts_order_provider_status_idx": {
+          "name": "payment_attempts_order_provider_status_idx",
+          "columns": [
+            {
+              "expression": "order_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "payment_attempts_order_provider_active_unique": {
+          "name": "payment_attempts_order_provider_active_unique",
+          "columns": [
+            {
+              "expression": "order_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"payment_attempts\".\"status\" = 'active'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "payment_attempts_order_id_orders_id_fk": {
+          "name": "payment_attempts_order_id_orders_id_fk",
+          "tableFrom": "payment_attempts",
+          "tableTo": "orders",
+          "columnsFrom": [
+            "order_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "payment_attempts_status_check": {
+          "name": "payment_attempts_status_check",
+          "value": "\"payment_attempts\".\"status\" in ('active','succeeded','failed','canceled')"
+        },
+        "payment_attempts_attempt_number_check": {
+          "name": "payment_attempts_attempt_number_check",
+          "value": "\"payment_attempts\".\"attempt_number\" >= 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.product_prices": {
+      "name": "product_prices",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "product_id": {
+          "name": "product_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "currency": {
+          "name": "currency",
+          "type": "currency",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "price_minor": {
+          "name": "price_minor",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "original_price_minor": {
+          "name": "original_price_minor",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "price": {
+          "name": "price",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "original_price": {
+          "name": "original_price",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "product_prices_product_id_idx": {
+          "name": "product_prices_product_id_idx",
+          "columns": [
+            {
+              "expression": "product_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "product_prices_product_currency_uq": {
+          "name": "product_prices_product_currency_uq",
+          "columns": [
+            {
+              "expression": "product_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "currency",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "product_prices_product_id_products_id_fk": {
+          "name": "product_prices_product_id_products_id_fk",
+          "tableFrom": "product_prices",
+          "tableTo": "products",
+          "columnsFrom": [
+            "product_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "product_prices_price_positive": {
+          "name": "product_prices_price_positive",
+          "value": "\"product_prices\".\"price_minor\" > 0"
+        },
+        "product_prices_original_price_valid": {
+          "name": "product_prices_original_price_valid",
+          "value": "\"product_prices\".\"original_price_minor\" is null or \"product_prices\".\"original_price_minor\" > \"product_prices\".\"price_minor\""
+        },
+        "product_prices_price_mirror_consistent": {
+          "name": "product_prices_price_mirror_consistent",
+          "value": "\"product_prices\".\"price\" = (\"product_prices\".\"price_minor\"::numeric / 100)"
+        },
+        "product_prices_original_price_null_coupled": {
+          "name": "product_prices_original_price_null_coupled",
+          "value": "(\"product_prices\".\"original_price_minor\" is null) = (\"product_prices\".\"original_price\" is null)"
+        },
+        "product_prices_original_price_mirror_consistent": {
+          "name": "product_prices_original_price_mirror_consistent",
+          "value": "\"product_prices\".\"original_price_minor\" is null or \"product_prices\".\"original_price\" = (\"product_prices\".\"original_price_minor\"::numeric / 100)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.products": {
+      "name": "products",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "image_url": {
+          "name": "image_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "image_public_id": {
+          "name": "image_public_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "price": {
+          "name": "price",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "original_price": {
+          "name": "original_price",
+          "type": "numeric(10, 2)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "currency": {
+          "name": "currency",
+          "type": "currency",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'USD'"
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "colors": {
+          "name": "colors",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::text[]"
+        },
+        "sizes": {
+          "name": "sizes",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::text[]"
+        },
+        "badge": {
+          "name": "badge",
+          "type": "product_badge",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'NONE'"
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "is_featured": {
+          "name": "is_featured",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "stock": {
+          "name": "stock",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "sku": {
+          "name": "sku",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "products_slug_unique": {
+          "name": "products_slug_unique",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "products_stock_non_negative": {
+          "name": "products_stock_non_negative",
+          "value": "\"products\".\"stock\" >= 0"
+        },
+        "products_currency_usd_only": {
+          "name": "products_currency_usd_only",
+          "value": "\"products\".\"currency\" = 'USD'"
+        },
+        "products_price_positive": {
+          "name": "products_price_positive",
+          "value": "\"products\".\"price\" > 0"
+        },
+        "products_original_price_valid": {
+          "name": "products_original_price_valid",
+          "value": "\"products\".\"original_price\" is null or \"products\".\"original_price\" > \"products\".\"price\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.stripe_events": {
+      "name": "stripe_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'stripe'"
+        },
+        "event_id": {
+          "name": "event_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "payment_intent_id": {
+          "name": "payment_intent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "order_id": {
+          "name": "order_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_type": {
+          "name": "event_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "payment_status": {
+          "name": "payment_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "processed_at": {
+          "name": "processed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "stripe_events_event_id_idx": {
+          "name": "stripe_events_event_id_idx",
+          "columns": [
+            {
+              "expression": "event_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "stripe_events_order_id_orders_id_fk": {
+          "name": "stripe_events_order_id_orders_id_fk",
+          "tableFrom": "stripe_events",
+          "tableTo": "orders",
+          "columnsFrom": [
+            "order_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.email_verification_tokens": {
+      "name": "email_verification_tokens",
+      "schema": "",
+      "columns": {
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "email_verification_tokens_user_id_idx": {
+          "name": "email_verification_tokens_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.password_reset_tokens": {
+      "name": "password_reset_tokens",
+      "schema": "",
+      "columns": {
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "password_reset_tokens_user_id_idx": {
+          "name": "password_reset_tokens_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.currency": {
+      "name": "currency",
+      "schema": "public",
+      "values": [
+        "USD",
+        "UAH"
+      ]
+    },
+    "public.inventory_move_type": {
+      "name": "inventory_move_type",
+      "schema": "public",
+      "values": [
+        "reserve",
+        "release"
+      ]
+    },
+    "public.inventory_status": {
+      "name": "inventory_status",
+      "schema": "public",
+      "values": [
+        "none",
+        "reserving",
+        "reserved",
+        "release_pending",
+        "released",
+        "failed"
+      ]
+    },
+    "public.order_status": {
+      "name": "order_status",
+      "schema": "public",
+      "values": [
+        "CREATED",
+        "INVENTORY_RESERVED",
+        "INVENTORY_FAILED",
+        "PAID",
+        "CANCELED"
+      ]
+    },
+    "public.payment_status": {
+      "name": "payment_status",
+      "schema": "public",
+      "values": [
+        "pending",
+        "requires_payment",
+        "paid",
+        "failed",
+        "refunded"
+      ]
+    },
+    "public.product_badge": {
+      "name": "product_badge",
+      "schema": "public",
+      "values": [
+        "NEW",
+        "SALE",
+        "NONE"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
\ No newline at end of file
diff --git a/frontend/drizzle/meta/_journal.json b/frontend/drizzle/meta/_journal.json
index ccbdea88..ed7f75df 100644
--- a/frontend/drizzle/meta/_journal.json
+++ b/frontend/drizzle/meta/_journal.json
@@ -8,6 +8,13 @@
       "when": 1768412528916,
       "tag": "0000_dry_young_avengers",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1768608742386,
+      "tag": "0001_add_payment_attempts",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/frontend/lib/psp/stripe.ts b/frontend/lib/psp/stripe.ts
index b3d9c213..72e8185d 100644
--- a/frontend/lib/psp/stripe.ts
+++ b/frontend/lib/psp/stripe.ts
@@ -20,11 +20,20 @@ type CreateRefundInput = {
 let _stripe: Stripe | null = null;
 let _stripeKey: string | null = null;
 
+class StripePspError extends Error {
+  readonly code: string;
+  readonly cause: unknown;
+
+  constructor(code: string, cause: unknown) {
+    super(code);
+    this.name = 'StripePspError';
+    this.code = code;
+    this.cause = cause;
+  }
+}
+
 function withCause(code: string, cause: unknown): Error {
-  const err = new Error(code);
-  // Preserve original error for logs/diagnostics without relying on ES2022 ErrorOptions.
-  (err as any).cause = cause;
-  return err;
+  return new StripePspError(code, cause);
 }
 
 export async function createRefund({
@@ -134,6 +143,7 @@ export async function createPaymentIntent({
 export async function retrievePaymentIntent(paymentIntentId: string): Promise<{
   clientSecret: string;
   paymentIntentId: string;
+  status: Stripe.PaymentIntent['status'];
 }> {
   const { paymentsEnabled } = getStripeEnv();
   const stripe = getStripeClient();
@@ -149,7 +159,11 @@ export async function retrievePaymentIntent(paymentIntentId: string): Promise<{
   try {
     const intent = await stripe.paymentIntents.retrieve(paymentIntentId);
     if (!intent.client_secret) throw new Error('STRIPE_CLIENT_SECRET_MISSING');
-    return { clientSecret: intent.client_secret, paymentIntentId: intent.id };
+    return {
+      clientSecret: intent.client_secret,
+      paymentIntentId: intent.id,
+      status: intent.status,
+    };
   } catch (error) {
     logError('Stripe payment intent retrieval failed', error);
     throw withCause('STRIPE_PAYMENT_INTENT_FAILED', error);
diff --git a/frontend/lib/services/errors.ts b/frontend/lib/services/errors.ts
index b05b257a..529eca16 100644
--- a/frontend/lib/services/errors.ts
+++ b/frontend/lib/services/errors.ts
@@ -35,10 +35,12 @@ export class OrderNotFoundError extends Error {
 //   code = "SLUG_CONFLICT" as const
 // }
 export class InvalidPayloadError extends Error {
-  code = 'INVALID_PAYLOAD' as const;
-  constructor(message = 'Invalid payload') {
+  code: string;
+
+  constructor(message = 'Invalid payload', opts?: { code?: string }) {
     super(message);
     this.name = 'InvalidPayloadError';
+    this.code = opts?.code ?? 'INVALID_PAYLOAD';
   }
 }
 
@@ -91,26 +93,27 @@ export class SlugConflictError extends Error {
 }
 
 export class OrderStateInvalidError extends Error {
-  code = 'ORDER_STATE_INVALID' as const;
-  orderId?: string;
-  field?: string;
-  rawValue?: unknown;
-  details?: Record<string, unknown>;
+  readonly code = 'ORDER_STATE_INVALID' as const;
+
+  readonly orderId?: string;
+  readonly field?: string;
+  readonly rawValue?: unknown;
+  readonly details?: unknown;
 
   constructor(
-    message = 'Order state is invalid.',
-    options?: {
+    message: string,
+    opts?: {
       orderId?: string;
       field?: string;
       rawValue?: unknown;
-      details?: Record<string, unknown>;
+      details?: unknown;
     }
   ) {
     super(message);
     this.name = 'OrderStateInvalidError';
-    this.orderId = options?.orderId;
-    this.field = options?.field;
-    this.rawValue = options?.rawValue;
-    this.details = options?.details;
+    this.orderId = opts?.orderId;
+    this.field = opts?.field;
+    this.rawValue = opts?.rawValue;
+    this.details = opts?.details;
   }
 }
diff --git a/frontend/lib/services/orders/payment-attempts.ts b/frontend/lib/services/orders/payment-attempts.ts
new file mode 100644
index 00000000..8bcbfa83
--- /dev/null
+++ b/frontend/lib/services/orders/payment-attempts.ts
@@ -0,0 +1,378 @@
+import 'server-only';
+
+import { and, eq, sql } from 'drizzle-orm';
+
+import { db } from '@/db';
+import { paymentAttempts } from '@/db/schema';
+import { readStripePaymentIntentParams } from '@/lib/services/orders/payment-intent';
+import { createPaymentIntent, retrievePaymentIntent } from '@/lib/psp/stripe';
+import { setOrderPaymentIntent } from '@/lib/services/orders';
+import { logError } from '@/lib/logging';
+import { OrderStateInvalidError } from '@/lib/services/errors';
+
+export type PaymentProvider = 'stripe';
+export type PaymentAttemptStatus =
+  | 'active'
+  | 'succeeded'
+  | 'failed'
+  | 'canceled';
+
+const DEFAULT_MAX_ATTEMPTS = 3;
+
+export class PaymentAttemptsExhaustedError extends Error {
+  readonly code = 'PAYMENT_ATTEMPTS_EXHAUSTED';
+  constructor(
+    public readonly orderId: string,
+    public readonly provider: PaymentProvider
+  ) {
+    super(`Payment attempts exhausted for order ${orderId} (${provider})`);
+  }
+}
+
+type PaymentAttemptRow = typeof paymentAttempts.$inferSelect;
+
+async function getActiveAttempt(
+  orderId: string,
+  provider: PaymentProvider
+): Promise<PaymentAttemptRow | null> {
+  const rows = await db
+    .select()
+    .from(paymentAttempts)
+    .where(
+      and(
+        eq(paymentAttempts.orderId, orderId),
+        eq(paymentAttempts.provider, provider),
+        eq(paymentAttempts.status, 'active')
+      )
+    )
+    .limit(1);
+
+  return rows[0] ?? null;
+}
+
+async function getMaxAttemptNumber(
+  orderId: string,
+  provider: PaymentProvider
+): Promise<number> {
+  const rows = await db
+    .select({
+      max: sql<number>`coalesce(max(${paymentAttempts.attemptNumber}), 0)`,
+    })
+    .from(paymentAttempts)
+    .where(
+      and(
+        eq(paymentAttempts.orderId, orderId),
+        eq(paymentAttempts.provider, provider)
+      )
+    );
+
+  return rows[0]?.max ?? 0;
+}
+
+async function createActiveAttempt(
+  orderId: string,
+  provider: PaymentProvider,
+  maxAttempts: number
+): Promise<PaymentAttemptRow> {
+  const next = (await getMaxAttemptNumber(orderId, provider)) + 1;
+
+  if (next > maxAttempts) {
+    throw new PaymentAttemptsExhaustedError(orderId, provider);
+  }
+
+  const idempotencyKey = `pi:${provider}:${orderId}:${next}`;
+
+  try {
+    const inserted = await db
+      .insert(paymentAttempts)
+      .values({
+        orderId,
+        provider,
+        status: 'active',
+        attemptNumber: next,
+        idempotencyKey,
+        metadata: {},
+      })
+      .returning();
+
+    const row = inserted[0];
+    if (!row) throw new Error('Failed to insert payment_attempts row');
+    return row;
+  } catch (e) {
+    // race: another request may have created active attempt, return it
+    const existing = await getActiveAttempt(orderId, provider);
+    if (existing) return existing;
+    throw e;
+  }
+}
+
+async function upsertBackfillAttemptForExistingPI(args: {
+  orderId: string;
+  provider: PaymentProvider;
+  paymentIntentId: string;
+  maxAttempts: number;
+}): Promise<PaymentAttemptRow> {
+  const { orderId, provider, paymentIntentId, maxAttempts } = args;
+
+  // If an attempt already references this PI, reuse it.
+  const found = await db
+    .select()
+    .from(paymentAttempts)
+    .where(
+      and(
+        eq(paymentAttempts.provider, provider),
+        eq(paymentAttempts.providerPaymentIntentId, paymentIntentId)
+      )
+    )
+    .limit(1);
+
+  const existingAttempt = found[0] ?? null;
+  if (existingAttempt) {
+    // Guard: never reuse attempt that belongs to a different order (cross-order PI reuse).
+    if (existingAttempt.orderId === orderId) return existingAttempt;
+
+    // Fail-closed: PI is already linked to another order. Do NOT create a new attempt
+    // that would bind this PI to a second order.
+    throw new OrderStateInvalidError(
+      'PaymentIntent is already associated with a different order.',
+      {
+        orderId,
+        field: 'providerPaymentIntentId',
+        rawValue: paymentIntentId,
+        details: {
+          provider,
+          paymentIntentId,
+          existingOrderId: existingAttempt.orderId,
+        },
+      }
+    );
+  }
+
+  const max = await getMaxAttemptNumber(orderId, provider);
+  const next = max + 1;
+
+  if (next > maxAttempts) {
+    throw new PaymentAttemptsExhaustedError(orderId, provider);
+  }
+
+  const idempotencyKey = `pi:${provider}:${orderId}:${next}`;
+
+  try {
+    const inserted = await db
+      .insert(paymentAttempts)
+      .values({
+        orderId,
+        provider,
+        status: 'active',
+        attemptNumber: next,
+        idempotencyKey,
+        providerPaymentIntentId: paymentIntentId,
+        metadata: { backfilled: true },
+      })
+      .returning();
+
+    return inserted[0]!;
+  } catch (e) {
+    // On conflict (active unique), return active attempt.
+    const active = await getActiveAttempt(orderId, provider);
+    if (active) return active;
+    throw e;
+  }
+}
+
+/**
+ * P0.7 entrypoint:
+ * - no infinite PaymentIntents per order (durable attempt)
+ * - controlled init (one active attempt)
+ * - audit trail (payment_attempts)
+ *
+ * Returns clientSecret to initialize Stripe Elements.
+ */
+export async function ensureStripePaymentIntentForOrder(args: {
+  orderId: string;
+  existingPaymentIntentId?: string | null;
+  maxAttempts?: number;
+}): Promise<{
+  paymentIntentId: string;
+  clientSecret: string;
+  attemptId: string;
+  attemptNumber: number;
+}> {
+  const { orderId, existingPaymentIntentId } = args;
+  const provider: PaymentProvider = 'stripe';
+  const maxAttempts = args.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+
+  // 1) If we already have an active attempt, prefer it.
+  let attempt = await getActiveAttempt(orderId, provider);
+
+  // 2) If order already has a PI, ensure there is an attempt row for it (audit/backfill).
+  if (!attempt && existingPaymentIntentId && existingPaymentIntentId.trim()) {
+    attempt = await upsertBackfillAttemptForExistingPI({
+      orderId,
+      provider,
+      paymentIntentId: existingPaymentIntentId.trim(),
+      maxAttempts,
+    });
+  }
+  // 3) If still none — create new attempt (with limit).
+  if (!attempt) {
+    attempt = await createActiveAttempt(orderId, provider, maxAttempts);
+  }
+
+  // 4) If attempt already has PI — retrieve (and handle canceled).
+  if (
+    attempt.providerPaymentIntentId &&
+    attempt.providerPaymentIntentId.trim()
+  ) {
+    const pi = await retrievePaymentIntent(
+      attempt.providerPaymentIntentId.trim()
+    );
+
+    // If PI was canceled, mark attempt canceled and create a new attempt (bounded by maxAttempts).
+    if (pi.status === 'canceled') {
+      await db
+        .update(paymentAttempts)
+        .set({
+          status: 'canceled',
+          finalizedAt: new Date(),
+          updatedAt: new Date(),
+          lastErrorCode: 'canceled',
+          lastErrorMessage: 'PaymentIntent canceled',
+        })
+        .where(eq(paymentAttempts.id, attempt.id));
+
+      const nextAttempt = await createActiveAttempt(
+        orderId,
+        provider,
+        maxAttempts
+      );
+
+      const snapshot = await readStripePaymentIntentParams(orderId);
+      const created = await createPaymentIntent({
+        amount: snapshot.amountMinor,
+        currency: snapshot.currency,
+        orderId,
+        idempotencyKey: nextAttempt.idempotencyKey,
+      });
+
+      await db
+        .update(paymentAttempts)
+        .set({
+          providerPaymentIntentId: created.paymentIntentId,
+          updatedAt: new Date(),
+        })
+        .where(eq(paymentAttempts.id, nextAttempt.id));
+
+      await setOrderPaymentIntent({
+        orderId,
+        paymentIntentId: created.paymentIntentId,
+      });
+
+      return {
+        paymentIntentId: created.paymentIntentId,
+        clientSecret: created.clientSecret,
+        attemptId: nextAttempt.id,
+        attemptNumber: nextAttempt.attemptNumber,
+      };
+    }
+
+    return {
+      paymentIntentId: attempt.providerPaymentIntentId.trim(),
+      clientSecret: pi.clientSecret,
+      attemptId: attempt.id,
+      attemptNumber: attempt.attemptNumber,
+    };
+  }
+
+  // 5) No PI yet -> create PI using DB readback (P0.6 invariant), idempotent by attempt.
+  try {
+    const snapshot = await readStripePaymentIntentParams(orderId);
+
+    const created = await createPaymentIntent({
+      amount: snapshot.amountMinor,
+      currency: snapshot.currency,
+      orderId,
+      idempotencyKey: attempt.idempotencyKey,
+    });
+
+    await db
+      .update(paymentAttempts)
+      .set({
+        providerPaymentIntentId: created.paymentIntentId,
+        updatedAt: new Date(),
+      })
+      .where(eq(paymentAttempts.id, attempt.id));
+
+    await setOrderPaymentIntent({
+      orderId,
+      paymentIntentId: created.paymentIntentId,
+    });
+
+    return {
+      paymentIntentId: created.paymentIntentId,
+      clientSecret: created.clientSecret,
+      attemptId: attempt.id,
+      attemptNumber: attempt.attemptNumber,
+    };
+  } catch (error) {
+    logError('payment_attempt_pi_create_failed', error, {
+      orderId,
+      attemptId: attempt.id,
+    });
+
+    await db
+      .update(paymentAttempts)
+      .set({
+        status: 'failed',
+        finalizedAt: new Date(),
+        updatedAt: new Date(),
+        lastErrorCode: 'pi_create_failed',
+        lastErrorMessage:
+          error instanceof Error ? error.message : 'Unknown error',
+      })
+      .where(eq(paymentAttempts.id, attempt.id));
+
+    throw error;
+  }
+}
+
+/**
+ * Webhook helper: mark attempt final by Stripe PI id.
+ * Call this from stripe webhook route for succeeded/failed/canceled.
+ */
+export async function markStripeAttemptFinal(args: {
+  paymentIntentId: string;
+  status: 'succeeded' | 'failed' | 'canceled';
+  errorCode?: string | null;
+  errorMessage?: string | null;
+}) {
+  try {
+    const { paymentIntentId, status, errorCode, errorMessage } = args;
+
+    const mapped: PaymentAttemptStatus =
+      status === 'succeeded'
+        ? 'succeeded'
+        : status === 'canceled'
+        ? 'canceled'
+        : 'failed';
+
+    await db
+      .update(paymentAttempts)
+      .set({
+        status: mapped,
+        finalizedAt: new Date(),
+        updatedAt: new Date(),
+        lastErrorCode:
+          errorCode ?? (mapped === 'failed' ? 'payment_failed' : null),
+        lastErrorMessage: errorMessage ?? null,
+      })
+      .where(eq(paymentAttempts.providerPaymentIntentId, paymentIntentId));
+  } catch (error) {
+    // IMPORTANT: fail-open — не ламаємо webhook через audit layer
+    logError('payment_attempt_finalize_failed', error, {
+      paymentIntentId: args.paymentIntentId,
+      status: args.status,
+    });
+    return;
+  }
+}
diff --git a/frontend/lib/services/orders/payment-intent.ts b/frontend/lib/services/orders/payment-intent.ts
index 0041e84f..45019e5d 100644
--- a/frontend/lib/services/orders/payment-intent.ts
+++ b/frontend/lib/services/orders/payment-intent.ts
@@ -2,10 +2,13 @@ import { eq } from 'drizzle-orm';
 
 import { db } from '@/db';
 import { orders } from '@/db/schema/shop';
-import { type PaymentStatus } from '@/lib/shop/payments';
+import { type PaymentProvider, type PaymentStatus } from '@/lib/shop/payments';
 import { type OrderSummaryWithMinor } from '@/lib/types/shop';
-
-import { InvalidPayloadError, OrderNotFoundError } from '../errors';
+import {
+  InvalidPayloadError,
+  OrderNotFoundError,
+  OrderStateInvalidError,
+} from '../errors';
 import { resolvePaymentProvider } from './_shared';
 import { getOrderItems, parseOrderSummary } from './summary';
 import { guardedPaymentStatusUpdate } from './payment-state';
@@ -86,3 +89,61 @@ export async function setOrderPaymentIntent({
   const items = await getOrderItems(orderId);
   return parseOrderSummary(updated, items);
 }
+
+export async function readStripePaymentIntentParams(orderId: string): Promise<{
+  amountMinor: number;
+  currency: (typeof orders.$inferSelect)['currency'];
+}> {
+  const [existing] = await db
+    .select()
+    .from(orders)
+    .where(eq(orders.id, orderId))
+    .limit(1);
+
+  if (!existing) throw new OrderNotFoundError('Order not found');
+
+  const provider: PaymentProvider = resolvePaymentProvider(existing);
+
+  if (provider !== 'stripe') {
+    throw new InvalidPayloadError(
+      'Payment intent can only be created for stripe orders.'
+    );
+  }
+
+  // Payable-state gate: fail-closed for paid/failed/refunded/canceled/etc.
+  const allowed: PaymentStatus[] = ['pending', 'requires_payment'];
+  if (!allowed.includes(existing.paymentStatus as PaymentStatus)) {
+    throw new OrderStateInvalidError(
+      'Order is not payable; Stripe PaymentIntent initialization is not allowed in the current state.',
+      {
+        orderId,
+        field: 'paymentStatus',
+        rawValue: existing.paymentStatus,
+        details: {
+          allowed,
+          provider,
+          paymentIntentId: existing.paymentIntentId ?? null,
+        },
+      }
+    );
+  }
+
+  const amountMinor = existing.totalAmountMinor;
+
+  // Canonical money source = DB minor units. Fail-closed on invalid totals.
+  if (!Number.isSafeInteger(amountMinor) || amountMinor <= 0) {
+    throw new OrderStateInvalidError(
+      'Invalid order total for Stripe payment intent creation.',
+      {
+        orderId,
+        field: 'totalAmountMinor',
+        rawValue: amountMinor,
+        details: {
+          reason: 'Invalid order total for Stripe payment intent creation.',
+        },
+      }
+    );
+  }
+
+  return { amountMinor, currency: existing.currency };
+}
diff --git a/frontend/lib/services/orders/refund.ts b/frontend/lib/services/orders/refund.ts
index adb83607..6cfc37af 100644
--- a/frontend/lib/services/orders/refund.ts
+++ b/frontend/lib/services/orders/refund.ts
@@ -11,9 +11,7 @@ import {
 } from './psp-metadata/refunds';
 
 function invalid(code: string, message: string): InvalidPayloadError {
-  const err = new InvalidPayloadError(message);
-  (err as any).code = code;
-  return err;
+  return new InvalidPayloadError(message, { code });
 }
 
 function makeRefundIdempotencyKey(
diff --git a/frontend/lib/services/products/cart/rehydrate.ts b/frontend/lib/services/products/cart/rehydrate.ts
index 8b6a7a43..f0646ea0 100644
--- a/frontend/lib/services/products/cart/rehydrate.ts
+++ b/frontend/lib/services/products/cart/rehydrate.ts
@@ -15,6 +15,8 @@ import type {
   CartRemovedItem,
 } from '@/lib/validation/shop';
 import { isTwoDecimalCurrency, type CurrencyCode } from '@/lib/shop/currency';
+import { createCartItemKey } from '@/lib/shop/cart-item-key';
+import { logWarn } from '@/lib/logging';
 
 import { PriceConfigError } from '../../errors';
 
@@ -36,14 +38,72 @@ function assertTwoDecimalCurrency(currency: CurrencyCode): void {
   );
 }
 
+const MAX_VARIANT_LENGTH = 64;
+
+function normalizeVariant(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.length > MAX_VARIANT_LENGTH) return undefined;
+  return trimmed;
+}
+
+function sanitizeVariant(
+  value: string | undefined,
+  allowed: string[] | null | undefined
+): string | undefined {
+  if (!value) return undefined;
+
+  const list = Array.isArray(allowed)
+    ? allowed.filter(v => typeof v === 'string' && v.trim().length > 0)
+    : [];
+
+  if (list.length === 0) return undefined;
+  return list.includes(value) ? value : undefined;
+}
+
+type NormalizedCartLine = {
+  productId: string;
+  quantity: number;
+  selectedSize?: string;
+  selectedColor?: string;
+};
+
+function aggregateClientLines(items: CartClientItem[]): NormalizedCartLine[] {
+  const map = new Map<string, NormalizedCartLine>();
+
+  for (const item of items) {
+    const selectedSize = normalizeVariant(item.selectedSize);
+    const selectedColor = normalizeVariant(item.selectedColor);
+
+    const key = createCartItemKey(item.productId, selectedSize, selectedColor);
+    const prev = map.get(key);
+
+    if (prev) {
+      prev.quantity += item.quantity;
+    } else {
+      map.set(key, {
+        productId: item.productId,
+        quantity: item.quantity,
+        selectedSize,
+        selectedColor,
+      });
+    }
+  }
+
+  return Array.from(map.values());
+}
+
 export async function rehydrateCartItems(
   items: CartClientItem[],
   currency: CurrencyCode
 ): Promise<CartRehydrateResult> {
   assertTwoDecimalCurrency(currency);
 
+  const aggregated = aggregateClientLines(items);
+
   const uniqueProductIds = Array.from(
-    new Set(items.map(item => item.productId))
+    new Set(aggregated.map(item => item.productId))
   );
   if (uniqueProductIds.length === 0) {
     return cartRehydrateResultSchema.parse({
@@ -62,6 +122,8 @@ export async function rehydrateCartItems(
       isActive: products.isActive,
       badge: products.badge,
       imageUrl: products.imageUrl,
+      colors: products.colors,
+      sizes: products.sizes,
       priceMinor: productPrices.priceMinor,
       price: productPrices.price,
       priceCurrency: productPrices.currency,
@@ -77,12 +139,21 @@ export async function rehydrateCartItems(
     .where(inArray(products.id, uniqueProductIds));
 
   const productMap = new Map(rows.map(r => [r.id, r]));
-
-  const rehydratedItems: CartRehydrateItem[] = [];
   const removed: CartRemovedItem[] = [];
-  let totalMinor = 0;
 
-  for (const item of items) {
+  // Merge by canonical key AFTER sanitization (prevents duplicate lines).
+  const merged = new Map<
+    string,
+    Omit<
+      CartRehydrateItem,
+      'quantity' | 'lineTotalMinor' | 'lineTotal' | 'unitPrice' | 'lineTotal'
+    > & {
+      desiredQuantity: number;
+      unitPriceMinor: number;
+    }
+  >();
+
+  for (const item of aggregated) {
     const product = productMap.get(item.productId);
 
     if (!product) {
@@ -110,12 +181,6 @@ export async function rehydrateCartItems(
       });
     }
 
-    const effectiveQuantity = Math.min(
-      item.quantity,
-      product.stock,
-      MAX_QUANTITY_PER_LINE
-    );
-
     let unitPriceMinor: number;
 
     if (
@@ -125,7 +190,10 @@ export async function rehydrateCartItems(
       if (!Number.isInteger(product.priceMinor)) {
         throw new PriceConfigError(
           'Invalid priceMinor in DB (must be integer).',
-          { productId: product.id, currency }
+          {
+            productId: product.id,
+            currency,
+          }
         );
       }
       if (!Number.isSafeInteger(product.priceMinor) || product.priceMinor < 1) {
@@ -152,31 +220,84 @@ export async function rehydrateCartItems(
       });
     }
 
+    const sanitizedSize = sanitizeVariant(item.selectedSize, product.sizes);
+    const sanitizedColor = sanitizeVariant(item.selectedColor, product.colors);
+
+    if (
+      sanitizedSize !== item.selectedSize ||
+      sanitizedColor !== item.selectedColor
+    ) {
+      logWarn('cart_rehydrate_variant_sanitized', {
+        productId: product.id,
+        currency,
+        droppedSize:
+          item.selectedSize && sanitizedSize !== item.selectedSize
+            ? item.selectedSize
+            : undefined,
+        droppedColor:
+          item.selectedColor && sanitizedColor !== item.selectedColor
+            ? item.selectedColor
+            : undefined,
+      });
+    }
+
+    const key = createCartItemKey(product.id, sanitizedSize, sanitizedColor);
+
+    const prev = merged.get(key);
+    if (prev) {
+      prev.desiredQuantity += item.quantity;
+    } else {
+      merged.set(key, {
+        productId: product.id,
+        slug: product.slug,
+        title: product.title,
+        currency,
+        stock: product.stock,
+        badge: product.badge ?? 'NONE',
+        imageUrl: product.imageUrl,
+        selectedSize: sanitizedSize,
+        selectedColor: sanitizedColor,
+        desiredQuantity: item.quantity,
+        unitPriceMinor,
+      });
+    }
+  }
+
+  const rehydratedItems: CartRehydrateItem[] = [];
+  let totalMinor = 0;
+
+  for (const line of merged.values()) {
+    const effectiveQuantity = Math.min(
+      line.desiredQuantity,
+      line.stock,
+      MAX_QUANTITY_PER_LINE
+    );
+
     const lineTotalMinor = calculateLineTotal(
-      unitPriceMinor,
+      line.unitPriceMinor,
       effectiveQuantity
     );
     totalMinor += lineTotalMinor;
 
     rehydratedItems.push({
-      productId: product.id,
-      slug: product.slug,
-      title: product.title,
+      productId: line.productId,
+      slug: line.slug,
+      title: line.title,
       quantity: effectiveQuantity,
 
-      unitPriceMinor,
+      unitPriceMinor: line.unitPriceMinor,
       lineTotalMinor,
 
-      unitPrice: fromMinorUnits(unitPriceMinor),
+      unitPrice: fromMinorUnits(line.unitPriceMinor),
       lineTotal: fromMinorUnits(lineTotalMinor),
 
-      currency,
+      currency: line.currency,
 
-      stock: product.stock,
-      badge: product.badge ?? 'NONE',
-      imageUrl: product.imageUrl,
-      selectedSize: item.selectedSize,
-      selectedColor: item.selectedColor,
+      stock: line.stock,
+      badge: line.badge,
+      imageUrl: line.imageUrl,
+      selectedSize: line.selectedSize,
+      selectedColor: line.selectedColor,
     });
   }
 
diff --git a/frontend/lib/services/products/mutations/update.ts b/frontend/lib/services/products/mutations/update.ts
index cccb4348..a32f19dd 100644
--- a/frontend/lib/services/products/mutations/update.ts
+++ b/frontend/lib/services/products/mutations/update.ts
@@ -1,6 +1,4 @@
-// frontend/lib/services/products/mutations/update.ts
 import { eq, sql } from 'drizzle-orm';
-
 import {
   destroyProductImage,
   uploadProductImageFromFile,
@@ -17,6 +15,7 @@ import { mapRowToProduct } from '../mapping';
 import { normalizeSlug } from '../slug';
 import {
   assertMoneyMinorInt,
+  assertMergedPricesPolicy,
   enforceSaleBadgeRequiresOriginal,
   normalizePricesFromInput,
   validatePriceRows,
@@ -56,10 +55,14 @@ export async function updateProduct(
 
   const prices = normalizePricesFromInput(input);
   if (prices.length) validatePriceRows(prices);
-  // Enforce SALE invariant against FINAL state (DB rows + incoming upserts)
+
   const finalBadge = (input as any).badge ?? existing.badge;
 
-  if (finalBadge === 'SALE') {
+  // Enforce merged-state invariants (DB rows + incoming upserts)
+  // - If prices are patched, validate merged currency policy (e.g. USD must exist)
+  // - If final badge is SALE, enforce originalPrice for ALL currencies in merged state
+
+  if (prices.length || finalBadge === 'SALE') {
     const existingPriceRows = await db
       .select({
         currency: productPrices.currency,
@@ -92,7 +95,18 @@ export async function updateProduct(
       merged.set(p.currency, p);
     }
 
-    enforceSaleBadgeRequiresOriginal('SALE', Array.from(merged.values()));
+    const mergedRows = Array.from(merged.values());
+
+    // Currency-set policy should be enforced on merged state ONLY when prices are patched.
+    // This keeps PATCH semantics: partial prices payload is allowed, and policy is checked post-merge.
+    if (prices.length) {
+      assertMergedPricesPolicy(mergedRows, { productId: id, requireUsd: true });
+    }
+
+    // SALE invariant must be enforced on merged state when badge is SALE (even if prices are not patched).
+    if (finalBadge === 'SALE') {
+      enforceSaleBadgeRequiresOriginal('SALE', mergedRows);
+    }
   }
 
   // Base fields update
@@ -138,7 +152,7 @@ export async function updateProduct(
   }
 
   try {
-    // 1) upsert prices 
+    // 1) upsert prices
     if (prices.length) {
       const upsertRows = prices.map(p => {
         const priceMinor = p.priceMinor;
diff --git a/frontend/lib/services/products/prices.ts b/frontend/lib/services/products/prices.ts
index 395a1d61..242301a4 100644
--- a/frontend/lib/services/products/prices.ts
+++ b/frontend/lib/services/products/prices.ts
@@ -1,8 +1,7 @@
 import { toCents } from '@/lib/shop/money';
 import { currencyValues } from '@/lib/shop/currency';
 import type { CurrencyCode } from '@/lib/shop/currency';
-
-import { InvalidPayloadError } from '../errors';
+import { InvalidPayloadError, PriceConfigError } from '../errors';
 import type { NormalizedPriceRow } from './types';
 
 function assertMoneyString(value: string, field: string): number {
@@ -56,7 +55,27 @@ function assertOptionalMoneyString(
   }
   return n;
 }
+export function assertMergedPricesPolicy(
+  merged: NormalizedPriceRow[],
+  options?: { productId?: string; requireUsd?: boolean }
+) {
+  if (!merged.length) {
+    throw new PriceConfigError('At least one price is required.', {
+      productId: options?.productId,
+    });
+  }
 
+  const requireUsd = options?.requireUsd ?? true;
+  if (requireUsd) {
+    const hasUsd = merged.some(p => p.currency === 'USD' && p.priceMinor >= 1);
+    if (!hasUsd) {
+      throw new PriceConfigError('USD price is required.', {
+        productId: options?.productId,
+        currency: 'USD',
+      });
+    }
+  }
+}
 function toMoneyMinor(value: string, field: string): number {
   const n = assertMoneyString(value, field);
   return toCents(n);
@@ -168,7 +187,6 @@ export function requireUsd(prices: NormalizedPriceRow[]): NormalizedPriceRow {
   return usd;
 }
 
-
 export function validatePriceRows(prices: NormalizedPriceRow[]) {
   // Safety: no duplicates even if upstream schema is bypassed
   const seen = new Set<CurrencyCode>();
diff --git a/frontend/lib/shop/money.ts b/frontend/lib/shop/money.ts
index 06321733..20e23226 100644
--- a/frontend/lib/shop/money.ts
+++ b/frontend/lib/shop/money.ts
@@ -1,76 +1,181 @@
-export type Money = number;
-export type MoneyCents = number;
-
-function parseAmount(value: unknown): number {
-  const parsed = typeof value === "string" ? value.trim() : value;
-
-  if (typeof parsed !== "string" && typeof parsed !== "number") {
-    throw new Error("Invalid money value");
-  }
-
-  const numeric =
-    typeof parsed === "string" && parsed.length > 0 ? Number(parsed) : Number(parsed);
-
-  if (!Number.isFinite(numeric)) {
-    throw new Error("Invalid money value");
-  }
-
-  if (numeric < 0) {
-    throw new Error("Invalid money value");
-  }
-
-  return numeric;
-}
+export type Money = number;      // legacy/display only
+export type MoneyCents = number; // canonical minor units (safe int >= 0)
 
 /**
  * Strict invariant for canonical minor-units:
  * - finite
  * - integer (no trunc/round normalization here)
  * - >= 0
+ * - safe integer
  */
 export function assertIntegerCentsStrict(cents: number): MoneyCents {
   if (!Number.isFinite(cents) || !Number.isInteger(cents) || cents < 0) {
-    throw new Error("Invalid money cents value");
+    throw new Error('Invalid money cents value');
+  }
+  if (!Number.isSafeInteger(cents)) {
+    throw new Error('Money cents exceeds JS safe integer range');
   }
   return cents;
 }
 
+function assertPositiveInteger(name: string, v: number): number {
+  if (!Number.isFinite(v) || !Number.isInteger(v) || v <= 0) {
+    throw new Error(`Invalid ${name}`);
+  }
+  if (!Number.isSafeInteger(v)) {
+    throw new Error(`${name} exceeds JS safe integer range`);
+  }
+  return v;
+}
+
+function isScientificNotation(s: string): boolean {
+  return /e[+-]?\d+/i.test(s);
+}
+
+/**
+ * Parse decimal "major units" string/number into minor units (cents) WITHOUT floats.
+ * Rules:
+ * - accepts: "12", "12.3", "12.34", ".5", "0.5"
+ * - rejects: negatives, NaN/Infinity, scientific notation ("1e-3"), non-numeric
+ * - rounds HALF_UP to 2 decimals if more than 2 fractional digits
+ */
+function parseMajorToMinor(input: string | number): MoneyCents {
+  const raw =
+    typeof input === 'string'
+      ? input.trim()
+      : Number.isFinite(input)
+        ? String(input)
+        : String(input);
+
+  if (!raw.length) throw new Error('Invalid money value');
+
+  if (typeof input === 'number') {
+    if (!Number.isFinite(input) || input < 0) throw new Error('Invalid money value');
+  }
+
+  const s = raw;
+
+  if (s.startsWith('-')) throw new Error('Invalid money value');
+  if (isScientificNotation(s)) {
+    // JS numbers can stringify to "1e-7" – refuse to avoid ambiguous rounding
+    throw new Error('Invalid money value');
+  }
+
+  // Normalize leading-dot ".5" -> "0.5"
+  const normalized = s.startsWith('.') ? `0${s}` : s;
+
+  // Accept only digits with optional single dot
+  const m = normalized.match(/^(\d+)(?:\.(\d+))?$/);
+  if (!m) throw new Error('Invalid money value');
+
+  const intStr = m[1] ?? '0';
+  const fracStrRaw = m[2] ?? '';
+
+  // int part safe range pre-check
+  const maxIntPart = Math.floor(Number.MAX_SAFE_INTEGER / 100);
+  const intPart = Number(intStr);
+  if (!Number.isSafeInteger(intPart) || intPart < 0 || intPart > maxIntPart) {
+    throw new Error('Invalid money value');
+  }
+
+  // Fractional rounding to 2 digits, HALF_UP
+  let frac2 = fracStrRaw.slice(0, 2);
+  while (frac2.length < 2) frac2 += '0';
+
+  let cents = Number(frac2);
+  if (!Number.isInteger(cents) || cents < 0 || cents > 99) {
+    throw new Error('Invalid money value');
+  }
+
+  // Round if there are extra digits beyond 2
+  if (fracStrRaw.length > 2) {
+    const third = fracStrRaw.charCodeAt(2) - 48; // '0' => 0
+    if (third >= 5) {
+      cents += 1;
+      if (cents === 100) {
+        // carry
+        cents = 0;
+        if (intPart + 1 > maxIntPart) throw new Error('Invalid money value');
+        const minor = (intPart + 1) * 100 + cents;
+        return assertIntegerCentsStrict(minor);
+      }
+    }
+  }
+
+  const minor = intPart * 100 + cents;
+  return assertIntegerCentsStrict(minor);
+}
+
+/**
+ * Public API: major -> cents (minor).
+ * NOTE: prefer passing strings from DB/inputs; numbers are accepted but may be rejected
+ * if they stringify to scientific notation.
+ */
 export function toCents(value: number | string): MoneyCents {
-  const parsed = parseAmount(value);
-  const cents = Math.round(parsed * 100);
-  return assertIntegerCentsStrict(cents);
+  if (typeof value !== 'string' && typeof value !== 'number') {
+    throw new Error('Invalid money value');
+  }
+  return parseMajorToMinor(value);
 }
 
+/**
+ * Minor -> legacy major number (display only).
+ * Still returns a JS number; do NOT use for money comparisons.
+ */
 export function fromCents(cents: MoneyCents): Money {
-  return Number((assertIntegerCentsStrict(cents) / 100).toFixed(2));
+  const v = assertIntegerCentsStrict(cents);
+  const intPart = Math.floor(v / 100);
+  const frac = v % 100;
+  // Controlled string -> number (display only)
+  return Number(`${intPart}.${String(frac).padStart(2, '0')}`);
 }
 
 /**
  * Legacy DB numeric money (string/number like "12.34") -> canonical cents (int >= 0).
+ * No floats.
  */
 export function fromDbMoney(value: unknown): MoneyCents {
-  if (typeof value !== "string" && typeof value !== "number") {
-    throw new Error("Invalid money value");
+  if (typeof value !== 'string' && typeof value !== 'number') {
+    throw new Error('Invalid money value');
   }
   return toCents(value);
 }
 
+/**
+ * Canonical cents -> DB decimal string "12.34" WITHOUT floats/toFixed.
+ */
 export function toDbMoney(cents: MoneyCents): string {
-  return (assertIntegerCentsStrict(cents) / 100).toFixed(2);
+  const v = assertIntegerCentsStrict(cents);
+  const intPart = Math.floor(v / 100);
+  const frac = v % 100;
+  return `${intPart}.${String(frac).padStart(2, '0')}`;
 }
 
-export function calculateLineTotal(unitPriceCents: MoneyCents, quantity: number): MoneyCents {
-  if (!Number.isFinite(quantity) || !Number.isInteger(quantity) || quantity <= 0) {
-    throw new Error("Invalid quantity");
+export function calculateLineTotal(
+  unitPriceCents: MoneyCents,
+  quantity: number
+): MoneyCents {
+  const price = assertIntegerCentsStrict(unitPriceCents);
+  const qty = assertPositiveInteger('quantity', quantity);
+
+  const total = price * qty;
+
+  if (!Number.isSafeInteger(total)) {
+    throw new Error('Line total exceeds JS safe integer range');
   }
-  return assertIntegerCentsStrict(assertIntegerCentsStrict(unitPriceCents) * quantity);
-}
 
+  return assertIntegerCentsStrict(total);
+}
 
 export function sumLineTotals(lineTotals: MoneyCents[]): MoneyCents {
   let total = 0;
   for (const cents of lineTotals) {
-    total = assertIntegerCentsStrict(total + assertIntegerCentsStrict(cents));
+    const v = assertIntegerCentsStrict(cents);
+    const next = total + v;
+    if (!Number.isSafeInteger(next)) {
+      throw new Error('Sum exceeds JS safe integer range');
+    }
+    total = next;
   }
-  return total;
+  return assertIntegerCentsStrict(total);
 }
diff --git a/frontend/lib/tests/admin-product-patch-price-config-error-contract.test.ts b/frontend/lib/tests/admin-product-patch-price-config-error-contract.test.ts
new file mode 100644
index 00000000..1e0af014
--- /dev/null
+++ b/frontend/lib/tests/admin-product-patch-price-config-error-contract.test.ts
@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { PriceConfigError } from '@/lib/services/errors';
+
+vi.mock('@/lib/auth/admin', () => ({
+  requireAdminApi: vi.fn(async () => {}),
+  AdminApiDisabledError: class AdminApiDisabledError extends Error {
+    code = 'ADMIN_API_DISABLED' as const;
+  },
+  AdminUnauthorizedError: class AdminUnauthorizedError extends Error {
+    code = 'ADMIN_UNAUTHORIZED' as const;
+  },
+  AdminForbiddenError: class AdminForbiddenError extends Error {
+    code = 'ADMIN_FORBIDDEN' as const;
+  },
+}));
+
+vi.mock('@/lib/admin/parseAdminProductForm', () => ({
+  parseAdminProductForm: vi.fn(() => ({
+    ok: true,
+    data: { badge: 'NONE', prices: [{ currency: 'UAH', priceMinor: 1000 }] },
+  })),
+}));
+
+vi.mock('@/lib/services/products', () => ({
+  updateProduct: vi.fn(async () => {
+    throw new PriceConfigError('USD price is required.', {
+      productId: 'p1',
+      currency: 'USD',
+    });
+  }),
+  getAdminProductByIdWithPrices: vi.fn(),
+  deleteProduct: vi.fn(),
+}));
+
+import { PATCH } from '@/app/api/shop/admin/products/[id]/route';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+function makeReq(): any {
+  const fd = new FormData();
+
+  // Make payload realistic enough to pass parseAdminProductForm in PATCH
+  fd.set('title', 'Test product');
+  fd.set('badge', 'NONE');
+  fd.set('isActive', 'true');
+  fd.set('isFeatured', 'false');
+  fd.set('stock', '0');
+
+  // Include USD to avoid parser-level USD requirements if any still exist
+  fd.set(
+    'prices',
+    JSON.stringify([
+      { currency: 'USD', priceMinor: 999, originalPriceMinor: null },
+      { currency: 'UAH', priceMinor: 1000, originalPriceMinor: null },
+    ])
+  );
+
+  return { formData: async () => fd };
+}
+
+describe('admin PATCH /shop/admin/products/:id (PRICE_CONFIG_ERROR contract)', () => {
+  it('returns 400 PRICE_CONFIG_ERROR when merged policy is violated', async () => {
+    const res = await PATCH(makeReq(), {
+      params: Promise.resolve({ id: '00000000-0000-4000-8000-000000000001' }),
+    } as any);
+
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json.code).toBe('PRICE_CONFIG_ERROR');
+  });
+});
diff --git a/frontend/lib/tests/cart-rehydrate-variant-sanitize.test.ts b/frontend/lib/tests/cart-rehydrate-variant-sanitize.test.ts
new file mode 100644
index 00000000..112134d0
--- /dev/null
+++ b/frontend/lib/tests/cart-rehydrate-variant-sanitize.test.ts
@@ -0,0 +1,101 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import crypto from 'node:crypto';
+import { eq } from 'drizzle-orm';
+
+import { db } from '@/db';
+import { products, productPrices } from '@/db/schema';
+import { rehydrateCartItems } from '@/lib/services/products';
+
+let productId: string;
+
+beforeAll(async () => {
+  productId = crypto.randomUUID();
+
+  await db.insert(products).values({
+    id: productId,
+    slug: `test-cart-${productId}`,
+    title: 'Test Product',
+    description: null,
+    imageUrl: 'https://example.com/test.jpg',
+    imagePublicId: null,
+    price: '10.00',
+    originalPrice: null,
+    currency: 'USD',
+    category: null,
+    type: null,
+    colors: ['black'],
+    sizes: ['S', 'M'],
+    badge: 'NONE',
+    isActive: true,
+    isFeatured: false,
+    stock: 10,
+    sku: null,
+  });
+
+  await db.insert(productPrices).values({
+    id: crypto.randomUUID(),
+    productId,
+    currency: 'USD',
+    priceMinor: 1000,
+    originalPriceMinor: null,
+    price: '10.00',
+    originalPrice: null,
+  });
+});
+
+afterAll(async () => {
+  await db.delete(productPrices).where(eq(productPrices.productId, productId));
+  await db.delete(products).where(eq(products.id, productId));
+});
+
+describe('cart rehydrate: variant sanitization', () => {
+  it('drops invalid selectedSize and merges lines after sanitization', async () => {
+    const result = await rehydrateCartItems(
+      [
+        {
+          productId,
+          quantity: 1,
+          selectedSize: 'INVALID',
+          selectedColor: 'black',
+        },
+        {
+          productId,
+          quantity: 2,
+          selectedColor: 'black',
+        },
+      ],
+      'USD'
+    );
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0]!.quantity).toBe(3);
+    expect(result.items[0]!.selectedSize).toBeUndefined();
+    expect(result.items[0]!.selectedColor).toBe('black');
+    expect(result.summary.totalAmountMinor).toBe(3000);
+  });
+
+  it('drops invalid selectedColor and merges lines after sanitization', async () => {
+    const result = await rehydrateCartItems(
+      [
+        {
+          productId,
+          quantity: 1,
+          selectedSize: 'S',
+          selectedColor: 'INVALID',
+        },
+        {
+          productId,
+          quantity: 2,
+          selectedSize: 'S',
+        },
+      ],
+      'USD'
+    );
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0]!.quantity).toBe(3);
+    expect(result.items[0]!.selectedSize).toBe('S');
+    expect(result.items[0]!.selectedColor).toBeUndefined();
+    expect(result.summary.totalAmountMinor).toBe(3000);
+  });
+});
diff --git a/frontend/lib/tests/checkout-set-payment-intent-reject-contract.test.ts b/frontend/lib/tests/checkout-set-payment-intent-reject-contract.test.ts
index de3d39e1..76420d64 100644
--- a/frontend/lib/tests/checkout-set-payment-intent-reject-contract.test.ts
+++ b/frontend/lib/tests/checkout-set-payment-intent-reject-contract.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { makeCheckoutReq } from '@/lib/tests/helpers/makeCheckoutReq';
 import { InvalidPayloadError } from '@/lib/services/errors';
+import { ensureStripePaymentIntentForOrder } from '@/lib/services/orders/payment-attempts';
 
 // Force payments enabled so route goes into Stripe flow
 // gitleaks:allow
@@ -28,6 +29,14 @@ vi.mock('@/lib/psp/stripe', () => ({
   retrievePaymentIntent: vi.fn(),
 }));
 
+// Avoid DB coupling introduced by #6 (DB-canonical PI amount/currency)
+vi.mock('@/lib/services/orders/payment-intent', () => ({
+  readStripePaymentIntentParams: vi.fn(async () => ({
+    amountMinor: 1000,
+    currency: 'USD',
+  })),
+}));
+
 // Mock order services
 vi.mock('@/lib/services/orders', async () => {
   const actual = await vi.importActual<any>('@/lib/services/orders');
@@ -39,6 +48,16 @@ vi.mock('@/lib/services/orders', async () => {
   };
 });
 
+vi.mock('@/lib/services/orders/payment-attempts', async () => {
+  const actual = await vi.importActual<any>(
+    '@/lib/services/orders/payment-attempts'
+  );
+  return {
+    ...actual,
+    ensureStripePaymentIntentForOrder: vi.fn(),
+  };
+});
+
 import { POST } from '@/app/api/shop/checkout/route';
 import {
   createOrderWithItems,
@@ -76,6 +95,14 @@ describe('checkout: setOrderPaymentIntent rejection after order creation must no
         'Order cannot accept a payment intent from the current status.'
       )
     );
+    const ensurePI = ensureStripePaymentIntentForOrder as unknown as MockedFn;
+
+    ensurePI.mockRejectedValueOnce(
+      new InvalidPayloadError(
+        'Order cannot accept a payment intent from the current status.'
+      )
+    );
+
     const res = await POST(
       makeCheckoutReq({
         idempotencyKey: 'idem_key_test_new_attach_reject_0001',
@@ -114,6 +141,13 @@ describe('checkout: setOrderPaymentIntent rejection after order creation must no
         'Order cannot accept a payment intent from the current status.'
       )
     );
+    const ensurePI = ensureStripePaymentIntentForOrder as unknown as MockedFn;
+
+    ensurePI.mockRejectedValueOnce(
+      new InvalidPayloadError(
+        'Order cannot accept a payment intent from the current status.'
+      )
+    );
 
     const res = await POST(
       makeCheckoutReq({
diff --git a/frontend/lib/tests/checkout-stripe-error-contract.test.ts b/frontend/lib/tests/checkout-stripe-error-contract.test.ts
index 4ae13f34..4734fc31 100644
--- a/frontend/lib/tests/checkout-stripe-error-contract.test.ts
+++ b/frontend/lib/tests/checkout-stripe-error-contract.test.ts
@@ -25,6 +25,14 @@ vi.mock('@/lib/psp/stripe', () => ({
   retrievePaymentIntent: vi.fn(),
 }));
 
+// Avoid DB coupling introduced by #6 (DB-canonical PI amount/currency)
+vi.mock('@/lib/services/orders/payment-intent', () => ({
+  readStripePaymentIntentParams: vi.fn(async () => ({
+    amountMinor: 1000,
+    currency: 'USD',
+  })),
+}));
+
 // 4) mock orders services so we don't depend on DB schema/seed here
 vi.mock('@/lib/services/orders', async () => {
   const actual = await vi.importActual<any>('@/lib/services/orders');
diff --git a/frontend/lib/tests/product-admin-merged-prices-policy.test.ts b/frontend/lib/tests/product-admin-merged-prices-policy.test.ts
new file mode 100644
index 00000000..3706ee43
--- /dev/null
+++ b/frontend/lib/tests/product-admin-merged-prices-policy.test.ts
@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { assertMergedPricesPolicy } from '@/lib/services/products/prices';
+import { PriceConfigError } from '@/lib/services/errors';
+
+describe('assertMergedPricesPolicy (merged-state)', () => {
+  it('throws PRICE_CONFIG_ERROR when USD is missing after merge', () => {
+    try {
+      assertMergedPricesPolicy(
+        [{ currency: 'UAH', priceMinor: 1000, originalPriceMinor: null }],
+        { productId: 'p1', requireUsd: true }
+      );
+      throw new Error('Expected PriceConfigError');
+    } catch (e) {
+      expect(e).toBeInstanceOf(PriceConfigError);
+      expect((e as any).code).toBe('PRICE_CONFIG_ERROR');
+    }
+  });
+
+  it('passes when USD exists in merged state', () => {
+    expect(() =>
+      assertMergedPricesPolicy(
+        [
+          { currency: 'UAH', priceMinor: 1000, originalPriceMinor: null },
+          { currency: 'USD', priceMinor: 500, originalPriceMinor: null },
+        ],
+        { productId: 'p1', requireUsd: true }
+      )
+    ).not.toThrow();
+  });
+});
diff --git a/frontend/lib/tests/product-admin-update-prices-patch-semantics.test.ts b/frontend/lib/tests/product-admin-update-prices-patch-semantics.test.ts
new file mode 100644
index 00000000..3f5fa223
--- /dev/null
+++ b/frontend/lib/tests/product-admin-update-prices-patch-semantics.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { productAdminUpdateSchema } from '@/lib/validation/shop';
+
+describe('productAdminUpdateSchema: prices PATCH semantics', () => {
+  it('allows partial prices update without USD', () => {
+    const res = productAdminUpdateSchema.safeParse({
+      prices: [
+        { currency: 'UAH', priceMinor: 1000, originalPriceMinor: 2000 },
+      ],
+    });
+
+    expect(res.success).toBe(true);
+  });
+
+  it('still rejects duplicate currencies', () => {
+    const res = productAdminUpdateSchema.safeParse({
+      prices: [
+        { currency: 'UAH', priceMinor: 1000, originalPriceMinor: 2000 },
+        { currency: 'UAH', priceMinor: 1500, originalPriceMinor: 2500 },
+      ],
+    });
+
+    expect(res.success).toBe(false);
+  });
+
+  it('requires originalPriceMinor for provided rows when badge=SALE and prices provided', () => {
+    const res = productAdminUpdateSchema.safeParse({
+      badge: 'SALE',
+      prices: [{ currency: 'UAH', priceMinor: 1000 }],
+    });
+
+    expect(res.success).toBe(false);
+  });
+});
diff --git a/frontend/lib/validation/shop.ts b/frontend/lib/validation/shop.ts
index 4043dc65..9ba5c181 100644
--- a/frontend/lib/validation/shop.ts
+++ b/frontend/lib/validation/shop.ts
@@ -196,6 +196,25 @@ export const adminPriceRowSchema = z
       }
     }
   });
+type AdminPriceRow = z.infer<typeof adminPriceRowSchema>;
+
+function refineNoDuplicateCurrencies(
+  prices: AdminPriceRow[],
+  ctx: z.RefinementCtx
+) {
+  const seen = new Set<string>();
+  prices.forEach((p, idx) => {
+    if (seen.has(p.currency)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['prices', idx, 'currency'],
+        message: 'Duplicate currency in prices',
+      });
+    } else {
+      seen.add(p.currency);
+    }
+  });
+}
 
 export const productAdminSchema = z
   .object({
@@ -221,18 +240,7 @@ export const productAdminSchema = z
   })
   .superRefine((data, ctx) => {
     // 1) no duplicate currencies
-    const seen = new Set<string>();
-    data.prices.forEach((p, idx) => {
-      if (seen.has(p.currency)) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ['prices', idx, 'currency'],
-          message: 'Duplicate currency in prices',
-        });
-      } else {
-        seen.add(p.currency);
-      }
-    });
+    refineNoDuplicateCurrencies(data.prices, ctx);
 
     // 2) USD is required
     const usd = data.prices.find(p => p.currency === 'USD');
@@ -267,7 +275,8 @@ export const productAdminUpdateSchema = z
         const trimmed = value?.trim() ?? '';
         return trimmed.length ? trimmed : undefined;
       }),
-    prices: z.array(adminPriceRowSchema).optional(),
+    prices: z.array(adminPriceRowSchema).min(1).optional(),
+
     description: z.string().optional(),
     category: z.enum(productCategoryValues as [string, ...string[]]).optional(),
     type: z.enum(typeValues as [string, ...string[]]).optional(),
@@ -281,19 +290,9 @@ export const productAdminUpdateSchema = z
   })
   .superRefine((data, ctx) => {
     if (data.prices) {
-      const seen = new Set<string>();
-      data.prices.forEach((p, idx) => {
-        if (seen.has(p.currency)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ['prices', idx, 'currency'],
-            message: 'Duplicate currency in prices',
-          });
-        } else {
-          seen.add(p.currency);
-        }
-      });
+      refineNoDuplicateCurrencies(data.prices, ctx);
     }
+
     if (data.badge === 'SALE' && data.prices) {
       data.prices.forEach((p, idx) => {
         if (p.originalPriceMinor == null) {
diff --git a/frontend/project-structure.txt b/frontend/project-structure.txt
index 8bbcda9a..69150a9f 100644
--- a/frontend/project-structure.txt
+++ b/frontend/project-structure.txt
@@ -224,6 +224,7 @@
     📄 catalog-load-more.tsx
     📄 catalog-products-client.tsx
     📄 category-tile.tsx
+    📄 clear-cart-on-mount.tsx
     📁 header
       📄 cart-button.tsx
       📄 nav-links.tsx
@@ -386,6 +387,7 @@
   📄 logging.ts
   📄 logout.ts
   📄 navigation.ts
+  📄 pagination.ts
   📁 psp
     📄 stripe.ts
   📁 quiz
@@ -393,6 +395,8 @@
     📄 quiz-crypto.ts
     📄 quiz-session.ts
     📄 quiz-storage-keys.ts
+  📁 security
+    📄 csrf.ts
   📁 services
     📄 errors.ts
     📄 inventory.ts
@@ -400,6 +404,8 @@
       📄 checkout.ts
       📄 payment-intent.ts
       📄 payment-state.ts
+      📁 psp-metadata
+        📄 refunds.ts
       📄 refund.ts
       📄 restock.ts
       📄 summary.ts
@@ -440,6 +446,8 @@
     📄 checkout-stripe-error-contract.test.ts
     📄 currency.test.ts
     📄 format-money.test.ts
+    📁 helpers
+      📄 makeCheckoutReq.ts
     📄 order-items-snapshot-immutable.test.ts
     📄 order-items-variants.test.ts
     📄 orders-access.test.ts