Squashed commit of the following:

commit cd99a6489b
Merge: ebcbbb1 e63a036
Author: ncoronel <ncoronel@quo.ar>
Date:   Wed Aug 26 10:12:44 2026 -0300

    Merge branch 'fix/simplify_stock_reservations' of https://gitea.quo.ar/tbianchini/shopit-back into fix/simplify_stock_reservations

commit ebcbbb1774
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:33:39 2026 -0300

    fix(cart): reconcile expired cart mutations

commit 3dd378ed06
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:10:15 2026 -0300

    docs(stock): describe associated entity expiration

commit 4f705175bd
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:10:14 2026 -0300

    test(stock): cover propagated reservation expiration

commit 82570fe941
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:09:52 2026 -0300

    refactor(stock): propagate reservation expiration

commit d2a2b323e0
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:58:47 2026 -0300

    docs(stock): document terminal reservation recovery

commit ec67623b7b
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:58:47 2026 -0300

    test(stock): cover terminal reservation lifecycle

commit f6f138e180
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:58:41 2026 -0300

    refactor(stock): make expired reservations terminal

commit d612b7a118
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:28:30 2026 -0300

    docs(stock): describe unified expiration ownership

commit 49f42d4507
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:28:23 2026 -0300

    test(stock): cover authoritative reservation expiration

commit 1881cc1d4b
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:28:17 2026 -0300

    refactor(stock): make reservation expiration authoritative

commit 00ec37d8a0
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:05:34 2026 -0300

    docs(stock): document centralized reservation flow

commit d9f374c718
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:05:29 2026 -0300

    test(stock): cover aggregate reservation lifecycle

commit bbfdf8f342
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:05:23 2026 -0300

    refactor(stock): centralize reservation aggregate

commit 8a0f29bdae
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:33:39 2026 -0300

    fix(cart): reconcile expired cart mutations

commit 198ed400a9
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:10:15 2026 -0300

    docs(stock): describe associated entity expiration

commit 23d83166e6
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:10:14 2026 -0300

    test(stock): cover propagated reservation expiration

commit cb090402d0
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:09:52 2026 -0300

    refactor(stock): propagate reservation expiration

commit c120b6f7c0
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:58:47 2026 -0300

    docs(stock): document terminal reservation recovery

commit 1106fa28b4
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:58:47 2026 -0300

    test(stock): cover terminal reservation lifecycle

commit 896fb81bcf
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:58:41 2026 -0300

    refactor(stock): make expired reservations terminal

commit 8545fbc645
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:28:30 2026 -0300

    docs(stock): describe unified expiration ownership

commit dd6dcb708a
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:28:23 2026 -0300

    test(stock): cover authoritative reservation expiration

commit 624b246ff5
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:28:17 2026 -0300

    refactor(stock): make reservation expiration authoritative

commit 007b95b904
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:05:34 2026 -0300

    docs(stock): document centralized reservation flow

commit 0b3c8c93be
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:05:29 2026 -0300

    test(stock): cover aggregate reservation lifecycle

commit ede718e448
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:05:23 2026 -0300

    refactor(stock): centralize reservation aggregate

commit e63a03601a
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:33:39 2026 -0300

    fix(cart): reconcile expired cart mutations

commit 389373ad8c
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:10:15 2026 -0300

    docs(stock): describe associated entity expiration

commit ace02a3133
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:10:14 2026 -0300

    test(stock): cover propagated reservation expiration

commit d69a6210f6
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 16:09:52 2026 -0300

    refactor(stock): propagate reservation expiration

commit 3c0b43fea3
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:58:47 2026 -0300

    docs(stock): document terminal reservation recovery

commit 9b0008626b
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:58:47 2026 -0300

    test(stock): cover terminal reservation lifecycle

commit 61861e331a
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:58:41 2026 -0300

    refactor(stock): make expired reservations terminal

commit 2cc9d7dd97
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:28:30 2026 -0300

    docs(stock): describe unified expiration ownership

commit f982bcead1
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:28:23 2026 -0300

    test(stock): cover authoritative reservation expiration

commit 7a85e1731d
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:28:17 2026 -0300

    refactor(stock): make reservation expiration authoritative

commit 6db99e775a
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:05:34 2026 -0300

    docs(stock): document centralized reservation flow

commit e5f7ba3615
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:05:29 2026 -0300

    test(stock): cover aggregate reservation lifecycle

commit 24bfef431b
Author: ncoronel <ncoronel@quo.ar>
Date:   Tue Aug 25 15:05:23 2026 -0300

    refactor(stock): centralize reservation aggregate

app/Domains/Catalog/Exceptions/StockReservationExpiredException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Domains\Catalog\Exceptions;
+
+use RuntimeException;
+
+class StockReservationExpiredException extends RuntimeException
+{
+    public function __construct()
+    {
+        parent::__construct(__('api.cart.reservation_expired'));
+    }
+}

app/Domains/Catalog/Models/Inventory.php

@@ -48,10 +48,10 @@ class Inventory extends Model
         return $this->hasOne(Variant::class);
     }
 
-    /** @return HasMany<StockReservation, $this> */
-    public function stockReservations(): HasMany
+    /** @return HasMany<StockReservationLine, $this> */
+    public function stockReservationLines(): HasMany
     {
-        return $this->hasMany(StockReservation::class);
+        return $this->hasMany(StockReservationLine::class);
     }
 
     public function availableStock(): int

app/Domains/Catalog/Models/StockReservation.php

@@ -2,21 +2,20 @@
 
 namespace App\Domains\Catalog\Models;
 
-use App\Domains\Cart\Models\CartItem;
+use App\Domains\Cart\Models\Cart;
 use App\Domains\Purchase\Models\Purchase;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasOne;
 
 #[Fillable([
-    'inventory_id',
-    'cart_item_id',
-    'purchase_id',
-    'quantity',
     'status',
     'expires_at',
     'committed_at',
     'released_at',
+    'expired_at',
+    'release_reason',
 ])]
 class StockReservation extends Model
 {
@@ -31,31 +30,28 @@ class StockReservation extends Model
     protected function casts(): array
     {
         return [
-            'inventory_id' => 'integer',
-            'cart_item_id' => 'integer',
-            'purchase_id' => 'integer',
-            'quantity' => 'integer',
             'expires_at' => 'datetime',
             'committed_at' => 'datetime',
             'released_at' => 'datetime',
+            'expired_at' => 'datetime',
         ];
     }
 
-    /** @return BelongsTo<Inventory, $this> */
-    public function inventory(): BelongsTo
+    /** @return HasMany<StockReservationLine, $this> */
+    public function lines(): HasMany
     {
-        return $this->belongsTo(Inventory::class);
+        return $this->hasMany(StockReservationLine::class);
     }
 
-    /** @return BelongsTo<CartItem, $this> */
-    public function cartItem(): BelongsTo
+    /** @return HasOne<Cart, $this> */
+    public function currentCart(): HasOne
     {
-        return $this->belongsTo(CartItem::class);
+        return $this->hasOne(Cart::class, 'current_stock_reservation_id');
     }
 
-    /** @return BelongsTo<Purchase, $this> */
-    public function purchase(): BelongsTo
+    /** @return HasOne<Purchase, $this> */
+    public function purchase(): HasOne
     {
-        return $this->belongsTo(Purchase::class);
+        return $this->hasOne(Purchase::class);
     }
 }

app/Domains/Catalog/Models/StockReservationLine.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Domains\Catalog\Models;
+
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+#[Fillable([
+    'stock_reservation_id',
+    'inventory_id',
+    'quantity',
+    'tracks_inventory',
+])]
+class StockReservationLine extends Model
+{
+    protected function casts(): array
+    {
+        return [
+            'stock_reservation_id' => 'integer',
+            'inventory_id' => 'integer',
+            'quantity' => 'integer',
+            'tracks_inventory' => 'boolean',
+        ];
+    }
+
+    /** @return BelongsTo<StockReservation, $this> */
+    public function reservation(): BelongsTo
+    {
+        return $this->belongsTo(StockReservation::class, 'stock_reservation_id');
+    }
+
+    /** @return BelongsTo<Inventory, $this> */
+    public function inventory(): BelongsTo
+    {
+        return $this->belongsTo(Inventory::class);
+    }
+}

app/Domains/Catalog/Services/CatalogInventoryService.php

@@ -25,6 +25,24 @@ class CatalogInventoryService
         );
     }
 
+    /**
+     * @return array<int, array{quantity: int, tracks_inventory: bool}>
+     */
+    public function detailedRequirementsFor(CatalogItem|Variant $selection, int $quantity = 1): array
+    {
+        if ($quantity <= 0) {
+            throw new \InvalidArgumentException('La cantidad debe ser mayor a cero.');
+        }
+
+        return array_map(
+            fn (array $requirement): array => [
+                ...$requirement,
+                'quantity' => $requirement['quantity'] * $quantity,
+            ],
+            $this->inventoryRequirements($selection),
+        );
+    }
+
     public function availableQuantity(CatalogItem|Variant $selection): ?int
     {
         if ($selection instanceof CatalogItem

app/Domains/Catalog/Services/ExpireStockReservationsService.php

@@ -2,50 +2,184 @@
 
 namespace App\Domains\Catalog\Services;
 
-use App\Domains\Cart\Services\ExpireCartReservationsService;
-use App\Domains\Purchase\Services\CheckoutService;
+use App\Domains\Cart\Models\Cart;
+use App\Domains\Catalog\Models\StockReservation;
+use App\Domains\Purchase\Models\Purchase;
+use App\Domains\Purchase\Services\Checkout\ReleaseCheckoutService;
+use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Log;
+use RuntimeException;
 use Throwable;
 
 class ExpireStockReservationsService
 {
+    private const BATCH_SIZE = 500;
+
     public function __construct(
-        private readonly CheckoutService $checkout,
-        private readonly ExpireCartReservationsService $carts,
+        private readonly ReleaseCheckoutService $purchases,
+        private readonly StockReservationService $reservations,
     ) {}
 
     /**
-     * @return array{purchases: int, cart_items: int}
+     * @return array{purchases: int, cart_reservations: int, orphan_reservations: int, failed: int}
      */
     public function expireOverdue(): array
     {
-        $expiredPurchases = null;
-        $expiredCartItems = null;
+        $summary = [
+            'purchases' => 0,
+            'cart_reservations' => 0,
+            'orphan_reservations' => 0,
+            'failed' => 0,
+        ];
+        $lastReservationId = 0;
 
-        try {
-            $expiredPurchases = $this->checkout->expireOverduePurchases();
-            $expiredCartItems = $this->carts->expireOverdue();
+        do {
+            $reservationIds = StockReservation::query()
+                ->where('status', StockReservation::STATUS_ACTIVE)
+                ->whereNotNull('expires_at')
+                ->where('expires_at', '<=', now())
+                ->where('id', '>', $lastReservationId)
+                ->orderBy('id')
+                ->limit(self::BATCH_SIZE)
+                ->pluck('id');
 
-            Log::channel('commands')->info('Stock reservation cleanup completed.', [
-                'command' => 'reservations:expire',
-                'expired_purchases' => $expiredPurchases,
-                'expired_cart_items' => $expiredCartItems,
-                'total_expired' => $expiredPurchases + $expiredCartItems,
-            ]);
+            foreach ($reservationIds as $reservationId) {
+                $lastReservationId = (int) $reservationId;
 
-            return [
-                'purchases' => $expiredPurchases,
-                'cart_items' => $expiredCartItems,
-            ];
-        } catch (Throwable $exception) {
-            Log::channel('commands')->error('Stock reservation cleanup failed.', [
-                'command' => 'reservations:expire',
-                'expired_purchases' => $expiredPurchases,
-                'expired_cart_items' => $expiredCartItems,
-                'exception' => $exception,
-            ]);
+                try {
+                    $owner = $this->expireReservation($lastReservationId);
+                    if ($owner !== null) {
+                        $summary[$owner]++;
+                    }
+                } catch (Throwable $exception) {
+                    $summary['failed']++;
+                    Log::channel('commands')->error('Failed to expire overdue stock reservation.', [
+                        'command' => 'reservations:expire',
+                        'stock_reservation_id' => $lastReservationId,
+                        'exception' => $exception,
+                    ]);
+                }
+            }
+        } while ($reservationIds->count() === self::BATCH_SIZE);
 
-            throw $exception;
+        Log::channel('commands')->info('Stock reservation cleanup completed.', [
+            'command' => 'reservations:expire',
+            'expired_purchases' => $summary['purchases'],
+            'expired_cart_reservations' => $summary['cart_reservations'],
+            'expired_orphan_reservations' => $summary['orphan_reservations'],
+            'failed_reservations' => $summary['failed'],
+            'total_expired' => $summary['purchases']
+                + $summary['cart_reservations']
+                + $summary['orphan_reservations'],
+        ]);
+
+        return $summary;
+    }
+
+    public function expireIfOverdue(int $reservationId): bool
+    {
+        /** @var StockReservation|null $reservation */
+        $reservation = StockReservation::query()->find($reservationId);
+        if ($reservation?->status === StockReservation::STATUS_EXPIRED) {
+            return true;
         }
+        if (! $this->isOverdue($reservation)) {
+            return false;
+        }
+
+        return $this->expireReservation($reservationId) !== null;
+    }
+
+    /** @return 'purchases'|'cart_reservations'|'orphan_reservations'|null */
+    private function expireReservation(int $reservationId): ?string
+    {
+        $purchaseId = Purchase::query()
+            ->where('stock_reservation_id', $reservationId)
+            ->value('id');
+        if ($purchaseId !== null) {
+            return $this->expirePurchase((int) $purchaseId);
+        }
+
+        $cartId = Cart::query()
+            ->where('current_stock_reservation_id', $reservationId)
+            ->where('status', 'active')
+            ->value('id');
+        if ($cartId !== null) {
+            return $this->expireCart((int) $cartId, $reservationId);
+        }
+
+        return $this->expireOrphan($reservationId);
+    }
+
+    /** @return 'purchases'|null */
+    private function expirePurchase(int $purchaseId): ?string
+    {
+        /** @var Purchase|null $purchase */
+        $purchase = Purchase::query()->find($purchaseId);
+        if ($purchase === null) {
+            return null;
+        }
+
+        $purchase = $this->purchases->expire($purchase);
+        if ($purchase->status === Purchase::STATUS_EXPIRED) {
+            return 'purchases';
+        }
+
+        $reservation = $purchase->stockReservation;
+        if ($this->isOverdue($reservation)) {
+            throw new RuntimeException('An overdue active reservation belongs to a purchase that cannot expire.');
+        }
+
+        return null;
+    }
+
+    /** @return 'cart_reservations'|null */
+    private function expireCart(int $cartId, int $reservationId): ?string
+    {
+        return DB::transaction(function () use ($cartId, $reservationId): ?string {
+            /** @var Cart|null $cart */
+            $cart = Cart::query()
+                ->whereKey($cartId)
+                ->where('current_stock_reservation_id', $reservationId)
+                ->where('status', Cart::STATUS_ACTIVE)
+                ->lockForUpdate()
+                ->first();
+            if ($cart === null) {
+                return null;
+            }
+
+            /** @var StockReservation|null $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->find($reservationId);
+            if (! $this->isOverdue($reservation)) {
+                return null;
+            }
+
+            $this->reservations->expire($reservation);
+            $cart->update(['status' => Cart::STATUS_EXPIRED]);
+
+            return 'cart_reservations';
+        });
+    }
+
+    /** @return 'orphan_reservations'|null */
+    private function expireOrphan(int $reservationId): ?string
+    {
+        /** @var StockReservation|null $reservation */
+        $reservation = StockReservation::query()->find($reservationId);
+        if (! $this->isOverdue($reservation)) {
+            return null;
+        }
+
+        $this->reservations->expire($reservation);
+
+        return 'orphan_reservations';
+    }
+
+    private function isOverdue(?StockReservation $reservation): bool
+    {
+        return $reservation !== null
+            && $reservation->status === StockReservation::STATUS_ACTIVE
+            && $reservation->expires_at !== null
+            && ! $reservation->expires_at->isFuture();
     }
 }

app/Domains/Catalog/Services/StockReservationService.php

@@ -2,262 +2,486 @@
 
 namespace App\Domains\Catalog\Services;
 
+use App\Domains\Cart\Models\Cart;
 use App\Domains\Cart\Models\CartItem;
-use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Catalog\Exceptions\StockReservationExpiredException;
+use App\Domains\Catalog\Models\Inventory;
 use App\Domains\Catalog\Models\StockReservation;
-use App\Domains\Catalog\Models\Variant;
+use App\Domains\Catalog\Models\StockReservationLine;
 use App\Domains\Purchase\Models\Purchase;
 use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\DB;
 
 class StockReservationService
 {
+    public const REASON_CART_EMPTY = 'cart_empty';
+
+    public const REASON_CART_CHANGED = 'cart_changed';
+
+    public const REASON_PURCHASE_SUPERSEDED = 'purchase_superseded';
+
+    public const REASON_PURCHASE_CANCELLED = 'purchase_cancelled';
+
+    public const REASON_PAYMENT_REJECTED = 'payment_rejected';
+
+    public const REASON_MANUAL_RELEASE = 'manual_release';
+
     public function __construct(
         private readonly CatalogInventoryService $inventory,
     ) {}
 
-    public function reserve(CartItem $cartItem, CatalogItem|Variant $selection, int $quantity): void
+    public function syncCart(Cart $cart): ?StockReservation
     {
-        DB::transaction(function () use ($cartItem, $selection, $quantity): void {
-            $this->inventory->reserve($selection, $quantity);
-            $this->recordIncrease($cartItem, $selection, $quantity);
-        });
-    }
+        return DB::transaction(function () use ($cart): ?StockReservation {
+            /** @var Cart $lockedCart */
+            $lockedCart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
+            $items = $lockedCart->items()->orderBy('id')->lockForUpdate()->get();
+            $this->loadSelections($items);
+            $requirements = $this->requirementsForItems($items);
 
-    public function release(
-        CartItem $cartItem,
-        CatalogItem|Variant $selection,
-        int $quantity,
-        string $releasedStatus = StockReservation::STATUS_RELEASED,
-    ): void {
-        DB::transaction(function () use ($cartItem, $selection, $quantity, $releasedStatus): void {
-            $this->ensure($cartItem, $selection);
-            $this->inventory->release($selection, $quantity);
-            $this->recordDecrease($cartItem, $selection, $quantity, $releasedStatus);
-        });
-    }
+            $reservation = $lockedCart->current_stock_reservation_id === null
+                ? null
+                : StockReservation::query()->lockForUpdate()->find($lockedCart->current_stock_reservation_id);
 
-    public function commit(
-        CartItem $cartItem,
-        CatalogItem|Variant $selection,
-        Purchase $purchase,
-    ): void {
-        DB::transaction(function () use ($cartItem, $selection, $purchase): void {
-            $this->ensure($cartItem, $selection);
-            $this->inventory->commit($selection, (int) $cartItem->cantidad);
+            if ($reservation !== null) {
+                $this->assertUsableCartReservation($reservation);
+            }
 
-            $requirements = $this->inventory->requirementsFor($selection, (int) $cartItem->cantidad);
-            foreach ($requirements as $inventoryId => $quantity) {
-                $reservation = $this->lockReservation($cartItem, $inventoryId);
-                if (
-                    $reservation === null
-                    || $reservation->status !== StockReservation::STATUS_ACTIVE
-                    || $reservation->purchase_id !== $purchase->getKey()
-                    || $reservation->quantity !== $quantity
-                ) {
-                    throw new \InvalidArgumentException('La reserva de stock no coincide con el item del carrito.');
+            if ($requirements === []) {
+                if ($reservation !== null && $reservation->status === StockReservation::STATUS_ACTIVE) {
+                    $this->finalizeLocked(
+                        $reservation,
+                        StockReservation::STATUS_RELEASED,
+                        self::REASON_CART_EMPTY,
+                    );
                 }
 
-                $reservation->update([
-                    'status' => StockReservation::STATUS_COMMITTED,
-                    'committed_at' => now(),
-                    'expires_at' => null,
-                ]);
+                $lockedCart->update(['current_stock_reservation_id' => null]);
+                $cart->current_stock_reservation_id = null;
+
+                return null;
             }
-        });
-    }
-
-    public function ensure(CartItem $cartItem, CatalogItem|Variant $selection): void
-    {
-        $requirements = $this->inventory->requirementsFor($selection, (int) $cartItem->cantidad);
-
-        foreach ($requirements as $inventoryId => $quantity) {
-            $reservation = $this->lockReservation($cartItem, $inventoryId);
 
             if ($reservation === null) {
-                StockReservation::query()->create([
-                    'inventory_id' => $inventoryId,
-                    'cart_item_id' => $cartItem->getKey(),
-                    'quantity' => $quantity,
+                $reservation = StockReservation::query()->create([
                     'status' => StockReservation::STATUS_ACTIVE,
                     'expires_at' => $this->expiration(),
                 ]);
-
-                continue;
+                $lockedCart->update(['current_stock_reservation_id' => $reservation->getKey()]);
             }
 
-            if ($reservation->status !== StockReservation::STATUS_ACTIVE || $reservation->quantity !== $quantity) {
-                $reservation->update([
-                    'quantity' => $quantity,
-                    'status' => StockReservation::STATUS_ACTIVE,
-                    'committed_at' => null,
-                    'released_at' => null,
-                    'expires_at' => $this->expiration(),
-                ]);
+            if (Purchase::query()->where('stock_reservation_id', $reservation->getKey())->exists()) {
+                throw new \InvalidArgumentException('La reserva vinculada a una compra no se puede modificar.');
             }
-        }
-    }
 
-    public function attachToPurchase(
-        CartItem $cartItem,
-        CatalogItem|Variant $selection,
-        Purchase $purchase,
-    ): void {
-        DB::transaction(function () use ($cartItem, $selection, $purchase): void {
-            $this->ensure($cartItem, $selection);
-            StockReservation::query()
-                ->where('cart_item_id', $cartItem->getKey())
-                ->where('status', StockReservation::STATUS_ACTIVE)
-                ->update([
-                    'purchase_id' => $purchase->getKey(),
-                    'expires_at' => $purchase->expires_at,
-                ]);
-        });
-    }
-
-    public function detachFromPurchase(Purchase $purchase): void
-    {
-        StockReservation::query()
-            ->where('purchase_id', $purchase->getKey())
-            ->where('status', StockReservation::STATUS_ACTIVE)
-            ->update([
-                'purchase_id' => null,
-                'expires_at' => $this->expiration(),
-            ]);
-    }
-
-    public function restore(CartItem $cartItem, CatalogItem|Variant $selection): void
-    {
-        DB::transaction(function () use ($cartItem, $selection): void {
-            $requirements = $this->inventory->requirementsFor(
-                $selection,
-                (int) $cartItem->cantidad,
-            );
-            $activeReservations = StockReservation::query()
-                ->where('cart_item_id', $cartItem->getKey())
-                ->where('status', StockReservation::STATUS_ACTIVE)
+            $currentLines = StockReservationLine::query()
+                ->where('stock_reservation_id', $reservation->getKey())
+                ->orderBy('inventory_id')
                 ->lockForUpdate()
                 ->get()
                 ->keyBy('inventory_id');
-
-            $hasCompleteReservation = collect($requirements)->every(
-                fn (int $quantity, int $inventoryId): bool => (int) ($activeReservations->get($inventoryId)?->quantity ?? 0) === $quantity,
-            );
-
-            if ($hasCompleteReservation) {
-                return;
-            }
-
-            if ($activeReservations->isNotEmpty()) {
-                throw new \InvalidArgumentException('La reserva de stock del carrito es inconsistente.');
-            }
-
-            $this->inventory->reserve($selection, (int) $cartItem->cantidad);
-            $this->recordIncrease($cartItem, $selection, (int) $cartItem->cantidad);
-        });
-    }
-
-    public function syncPurchaseExpiration(Purchase $purchase): void
-    {
-        StockReservation::query()
-            ->where('purchase_id', $purchase->getKey())
-            ->where('status', StockReservation::STATUS_ACTIVE)
-            ->update(['expires_at' => $purchase->expires_at]);
-    }
-
-    public function transfer(CartItem $source, CartItem $target): void
-    {
-        DB::transaction(function () use ($source, $target): void {
-            $sourceReservations = StockReservation::query()
-                ->where('cart_item_id', $source->getKey())
-                ->where('status', StockReservation::STATUS_ACTIVE)
-                ->orderBy('inventory_id')
+            $inventoryIds = collect(array_keys($requirements))
+                ->merge($currentLines->keys())
+                ->map(fn ($id): int => (int) $id)
+                ->unique()
+                ->sort()
+                ->values();
+            $inventories = Inventory::query()
+                ->whereKey($inventoryIds)
+                ->orderBy('id')
                 ->lockForUpdate()
-                ->get();
+                ->get()
+                ->keyBy('id');
 
-            foreach ($sourceReservations as $sourceReservation) {
-                $targetReservation = $this->lockReservation($target, (int) $sourceReservation->inventory_id);
+            foreach ($inventoryIds as $inventoryId) {
+                $inventory = $inventories->get($inventoryId)
+                    ?? throw new \InvalidArgumentException('No se encontró el inventario requerido.');
+                $previous = (int) ($currentLines->get($inventoryId)?->quantity ?? 0);
+                $required = (int) ($requirements[$inventoryId]['quantity'] ?? 0);
+                $delta = $required - $previous;
 
-                if ($targetReservation === null) {
-                    $sourceItemQuantity = (int) $source->cantidad;
-                    $targetItemQuantity = (int) $target->fresh()->cantidad;
-                    $perItemQuantity = intdiv((int) $sourceReservation->quantity, $sourceItemQuantity);
-                    $sourceReservation->update([
-                        'cart_item_id' => $target->getKey(),
-                        'purchase_id' => null,
-                        'quantity' => $perItemQuantity * $targetItemQuantity,
-                        'expires_at' => $this->expiration(),
-                    ]);
+                if ($delta > 0
+                    && $requirements[$inventoryId]['tracks_inventory']
+                    && $inventory->availableStock() < $delta) {
+                    throw new \InvalidArgumentException('No hay suficiente stock disponible para reservar el carrito.');
+                }
+
+                if ($delta < 0 && $inventory->reserved_stock < abs($delta)) {
+                    throw new \InvalidArgumentException('La reserva de stock del carrito es inconsistente.');
+                }
+            }
+
+            foreach ($inventoryIds as $inventoryId) {
+                /** @var Inventory $inventory */
+                $inventory = $inventories->get($inventoryId);
+                $line = $currentLines->get($inventoryId);
+                $previous = (int) ($line?->quantity ?? 0);
+                $required = (int) ($requirements[$inventoryId]['quantity'] ?? 0);
+                $delta = $required - $previous;
+
+                if ($delta > 0) {
+                    $inventory->reserve($delta, $requirements[$inventoryId]['tracks_inventory']);
+                } elseif ($delta < 0) {
+                    $inventory->release(abs($delta));
+                }
+
+                if ($required === 0) {
+                    $line?->delete();
 
                     continue;
                 }
 
-                $targetReservation->update([
-                    'quantity' => $targetReservation->quantity + $sourceReservation->quantity,
-                    'status' => StockReservation::STATUS_ACTIVE,
-                    'expires_at' => $this->expiration(),
-                ]);
-                $sourceReservation->delete();
+                StockReservationLine::query()->updateOrCreate(
+                    [
+                        'stock_reservation_id' => $reservation->getKey(),
+                        'inventory_id' => $inventoryId,
+                    ],
+                    [
+                        'quantity' => $required,
+                        'tracks_inventory' => $requirements[$inventoryId]['tracks_inventory'],
+                    ],
+                );
+            }
+
+            $reservation->update([
+                'expires_at' => $this->expiration(),
+                'release_reason' => null,
+            ]);
+            $cart->current_stock_reservation_id = $reservation->getKey();
+
+            return $reservation->fresh('lines');
+        });
+    }
+
+    public function attachToPurchase(
+        Cart $cart,
+        Purchase $purchase,
+        Carbon $expiresAt,
+    ): StockReservation {
+        return DB::transaction(function () use ($cart, $purchase, $expiresAt): StockReservation {
+            /** @var Cart $lockedCart */
+            $lockedCart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
+            /** @var Purchase $lockedPurchase */
+            $lockedPurchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+
+            if ($lockedCart->current_stock_reservation_id === null) {
+                throw new \InvalidArgumentException('El carrito no tiene una reserva de stock activa.');
+            }
+
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->findOrFail($lockedCart->current_stock_reservation_id);
+            $this->assertUsableCartReservation($reservation);
+
+            $linkedPurchase = Purchase::query()
+                ->where('stock_reservation_id', $reservation->getKey())
+                ->whereKeyNot($lockedPurchase->getKey())
+                ->exists();
+            if ($linkedPurchase) {
+                throw new \InvalidArgumentException('La reserva de stock ya pertenece a otra compra.');
+            }
+
+            $lockedPurchase->update(['stock_reservation_id' => $reservation->getKey()]);
+            $reservation->update(['expires_at' => $expiresAt]);
+            $purchase->stock_reservation_id = $reservation->getKey();
+            $cart->current_stock_reservation_id = $reservation->getKey();
+
+            return $reservation->fresh('lines');
+        });
+    }
+
+    public function commit(Purchase $purchase): void
+    {
+        DB::transaction(function () use ($purchase): void {
+            /** @var Purchase $purchase */
+            $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+            if ($purchase->stock_reservation_id === null) {
+                throw new \InvalidArgumentException('La compra no tiene una reserva de stock.');
+            }
+
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->findOrFail($purchase->stock_reservation_id);
+            if ($reservation->status === StockReservation::STATUS_COMMITTED) {
+                return;
+            }
+            if ($reservation->status !== StockReservation::STATUS_ACTIVE) {
+                throw new \InvalidArgumentException('La reserva de stock no está activa.');
+            }
+            if ($reservation->expires_at !== null && ! $reservation->expires_at->isFuture()) {
+                throw new StockReservationExpiredException;
+            }
+
+            $lines = $this->lockLines($reservation);
+            if ($lines->isEmpty()) {
+                throw new \InvalidArgumentException('La reserva de stock no tiene inventarios.');
+            }
+
+            $inventories = $this->lockInventories($lines);
+            foreach ($lines as $line) {
+                $inventory = $inventories->get($line->inventory_id)
+                    ?? throw new \InvalidArgumentException('No se encontró el inventario reservado.');
+                if ($inventory->reserved_stock < $line->quantity
+                    || ($line->tracks_inventory && $inventory->real_stock < $line->quantity)) {
+                    throw new \InvalidArgumentException('La reserva de stock no alcanza para confirmar la compra.');
+                }
+            }
+
+            foreach ($lines as $line) {
+                $inventories->get($line->inventory_id)->buy(
+                    (int) $line->quantity,
+                    (bool) $line->tracks_inventory,
+                );
+            }
+
+            $reservation->update([
+                'status' => StockReservation::STATUS_COMMITTED,
+                'expires_at' => null,
+                'committed_at' => now(),
+                'released_at' => null,
+                'expired_at' => null,
+                'release_reason' => null,
+            ]);
+        });
+    }
+
+    public function releaseForPurchase(
+        Purchase $purchase,
+        string $status = StockReservation::STATUS_RELEASED,
+        ?string $reason = null,
+    ): void {
+        DB::transaction(function () use ($purchase, $status, $reason): void {
+            /** @var Purchase $purchase */
+            $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+            if ($purchase->stock_reservation_id === null) {
+                return;
+            }
+
+            /** @var StockReservation|null $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->find($purchase->stock_reservation_id);
+            if ($reservation !== null) {
+                $this->finalizeLocked($reservation, $status, $reason);
             }
         });
     }
 
-    private function recordIncrease(CartItem $cartItem, CatalogItem|Variant $selection, int $quantity): void
+    public function returnToCart(Purchase $purchase, Cart $cart): StockReservation
     {
-        foreach ($this->inventory->requirementsFor($selection, $quantity) as $inventoryId => $requiredQuantity) {
-            $reservation = $this->lockReservation($cartItem, $inventoryId);
+        return DB::transaction(function () use ($purchase, $cart): StockReservation {
+            /** @var Purchase $purchase */
+            $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+            /** @var Cart $cart */
+            $cart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
 
-            if ($reservation === null) {
-                StockReservation::query()->create([
-                    'inventory_id' => $inventoryId,
-                    'cart_item_id' => $cartItem->getKey(),
-                    'quantity' => $requiredQuantity,
-                    'status' => StockReservation::STATUS_ACTIVE,
-                    'expires_at' => $this->expiration(),
-                ]);
-
-                continue;
+            if ($purchase->stock_reservation_id === null
+                || $cart->current_stock_reservation_id !== $purchase->stock_reservation_id) {
+                throw new \InvalidArgumentException('La compra y el carrito no comparten la reserva activa.');
             }
 
-            $reservation->update([
-                'quantity' => ($reservation->status === StockReservation::STATUS_ACTIVE ? $reservation->quantity : 0) + $requiredQuantity,
-                'status' => StockReservation::STATUS_ACTIVE,
-                'committed_at' => null,
-                'released_at' => null,
-                'expires_at' => $this->expiration(),
-            ]);
-        }
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()
+                ->lockForUpdate()
+                ->findOrFail($purchase->stock_reservation_id);
+            $this->assertUsableCartReservation($reservation);
+
+            $purchase->update(['stock_reservation_id' => null]);
+            $cart->update(['current_purchase_id' => null]);
+            $reservation->update(['expires_at' => $this->expiration()]);
+
+            return $reservation->fresh('lines');
+        });
     }
 
-    private function recordDecrease(
-        CartItem $cartItem,
-        CatalogItem|Variant $selection,
-        int $quantity,
-        string $releasedStatus,
+    public function assertCartReservationUsable(Cart $cart): void
+    {
+        DB::transaction(function () use ($cart): void {
+            /** @var Cart $cart */
+            $cart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
+            if ($cart->current_stock_reservation_id === null) {
+                return;
+            }
+
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()
+                ->lockForUpdate()
+                ->findOrFail($cart->current_stock_reservation_id);
+            $this->assertUsableCartReservation($reservation);
+        });
+    }
+
+    public function releaseCurrentCartReservation(
+        Cart $cart,
+        string $reason = self::REASON_CART_CHANGED,
     ): void {
-        foreach ($this->inventory->requirementsFor($selection, $quantity) as $inventoryId => $requiredQuantity) {
-            $reservation = $this->lockReservation($cartItem, $inventoryId);
-            if ($reservation === null || $reservation->status !== StockReservation::STATUS_ACTIVE || $reservation->quantity < $requiredQuantity) {
-                throw new \InvalidArgumentException('La reserva de stock no alcanza para liberar la cantidad solicitada.');
+        DB::transaction(function () use ($cart, $reason): void {
+            /** @var Cart $cart */
+            $cart = Cart::query()->lockForUpdate()->findOrFail($cart->getKey());
+            if ($cart->current_stock_reservation_id === null) {
+                return;
             }
 
-            $remaining = $reservation->quantity - $requiredQuantity;
-            $reservation->update([
-                'quantity' => $remaining,
-                'status' => $remaining === 0 ? $releasedStatus : StockReservation::STATUS_ACTIVE,
-                'released_at' => $remaining === 0 ? now() : null,
-                'expires_at' => $remaining === 0 ? null : $reservation->expires_at,
-            ]);
+            /** @var StockReservation|null $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->find($cart->current_stock_reservation_id);
+            if ($reservation !== null) {
+                $this->finalizeLocked($reservation, StockReservation::STATUS_RELEASED, $reason);
+            }
+            $cart->update(['current_stock_reservation_id' => null]);
+        });
+    }
+
+    public function expire(StockReservation $reservation): void
+    {
+        DB::transaction(function () use ($reservation): void {
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()->lockForUpdate()->findOrFail($reservation->getKey());
+            if ($reservation->status !== StockReservation::STATUS_ACTIVE
+                || $reservation->expires_at === null
+                || $reservation->expires_at->isFuture()) {
+                return;
+            }
+
+            $this->finalizeLocked($reservation, StockReservation::STATUS_EXPIRED, null);
+        });
+    }
+
+    public function refreshForPurchase(Purchase $purchase, ?Carbon $expiresAt): void
+    {
+        DB::transaction(function () use ($purchase, $expiresAt): void {
+            /** @var Purchase $purchase */
+            $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+            if ($purchase->stock_reservation_id === null) {
+                throw new \InvalidArgumentException('La compra no tiene una reserva de stock.');
+            }
+
+            /** @var StockReservation $reservation */
+            $reservation = StockReservation::query()
+                ->lockForUpdate()
+                ->findOrFail($purchase->stock_reservation_id);
+            if ($reservation->status !== StockReservation::STATUS_ACTIVE) {
+                throw new \InvalidArgumentException('La reserva de stock no está activa.');
+            }
+            if ($reservation->expires_at !== null && ! $reservation->expires_at->isFuture()) {
+                throw new StockReservationExpiredException;
+            }
+
+            $reservation->update(['expires_at' => $expiresAt]);
+        });
+    }
+
+    /**
+     * @param  Collection<int, CartItem>  $items
+     * @return array<int, array{quantity: int, tracks_inventory: bool}>
+     */
+    private function requirementsForItems(Collection $items): array
+    {
+        $requirements = [];
+        foreach ($items as $item) {
+            $selection = $item->selectedItem();
+            if ($selection === null) {
+                throw new \InvalidArgumentException('El carrito contiene un item de catálogo inexistente.');
+            }
+
+            foreach ($this->inventory->detailedRequirementsFor($selection, (int) $item->cantidad) as $inventoryId => $requirement) {
+                if (isset($requirements[$inventoryId])) {
+                    $requirements[$inventoryId]['quantity'] += $requirement['quantity'];
+                    $requirements[$inventoryId]['tracks_inventory'] =
+                        $requirements[$inventoryId]['tracks_inventory'] || $requirement['tracks_inventory'];
+
+                    continue;
+                }
+
+                $requirements[$inventoryId] = $requirement;
+            }
+        }
+
+        ksort($requirements);
+
+        return $requirements;
+    }
+
+    /** @param Collection<int, CartItem> $items */
+    private function loadSelections(Collection $items): void
+    {
+        $items->load([
+            'catalogItem.inventory',
+            'catalogItem.bundleComponents.catalogItem.inventory',
+            'catalogItem.bundleComponents.variant.inventory',
+            'catalogItem.bundleComponents.variant.catalogItem',
+            'variant.inventory',
+            'variant.catalogItem',
+        ]);
+    }
+
+    /** @return Collection<int, StockReservationLine> */
+    private function lockLines(StockReservation $reservation): Collection
+    {
+        return StockReservationLine::query()
+            ->where('stock_reservation_id', $reservation->getKey())
+            ->orderBy('inventory_id')
+            ->lockForUpdate()
+            ->get();
+    }
+
+    /**
+     * @param  Collection<int, StockReservationLine>  $lines
+     * @return Collection<int, Inventory>
+     */
+    private function lockInventories(Collection $lines): Collection
+    {
+        return Inventory::query()
+            ->whereKey($lines->pluck('inventory_id'))
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get()
+            ->keyBy('id');
+    }
+
+    private function finalizeLocked(
+        StockReservation $reservation,
+        string $status,
+        ?string $reason,
+    ): void {
+        if ($reservation->status !== StockReservation::STATUS_ACTIVE) {
+            return;
+        }
+        if (! in_array($status, [StockReservation::STATUS_RELEASED, StockReservation::STATUS_EXPIRED], true)) {
+            throw new \InvalidArgumentException('El estado final de la reserva no es válido.');
+        }
+
+        $lines = $this->lockLines($reservation);
+        $inventories = $this->lockInventories($lines);
+        foreach ($lines as $line) {
+            $inventory = $inventories->get($line->inventory_id)
+                ?? throw new \InvalidArgumentException('No se encontró el inventario reservado.');
+            $inventory->release((int) $line->quantity);
+        }
+
+        $now = now();
+        $reservation->update([
+            'status' => $status,
+            'expires_at' => null,
+            'released_at' => $status === StockReservation::STATUS_RELEASED ? $now : null,
+            'expired_at' => $status === StockReservation::STATUS_EXPIRED ? $now : null,
+            'release_reason' => $status === StockReservation::STATUS_RELEASED ? $reason : null,
+        ]);
+
+        if ($status === StockReservation::STATUS_RELEASED) {
+            Cart::query()
+                ->where('current_stock_reservation_id', $reservation->getKey())
+                ->update(['current_stock_reservation_id' => null]);
         }
     }
 
-    private function lockReservation(CartItem $cartItem, int $inventoryId): ?StockReservation
+    private function assertUsableCartReservation(StockReservation $reservation): void
     {
-        return StockReservation::query()
-            ->where('cart_item_id', $cartItem->getKey())
-            ->where('inventory_id', $inventoryId)
-            ->lockForUpdate()
-            ->first();
+        if ($reservation->status === StockReservation::STATUS_EXPIRED
+            || ($reservation->expires_at !== null && ! $reservation->expires_at->isFuture())) {
+            throw new StockReservationExpiredException;
+        }
+
+        if ($reservation->status !== StockReservation::STATUS_ACTIVE
+            || $reservation->expires_at === null) {
+            throw new \InvalidArgumentException('La reserva de stock no está disponible para operar el carrito.');
+        }
     }
 
     private function expiration(): Carbon

app/Domains/Catalog/documentacion/README.md

@@ -9,7 +9,7 @@ Modela y publica la oferta comercial del tenant: productos, variantes, categorí
 - `CatalogItem` es la raíz del producto y se relaciona con tenant, categoría, marca, inventario, variantes, atributos, adjuntos y grupos destacados.
 - `Variant`, `ItemAttribute`, `Attribute`, `AttributeOption` y `VariantDefinition` describen opciones comercializables.
 - `Inventory` administra stock disponible, reservado y comprado.
-- `StockReservation` atribuye cada unidad reservada a un ítem de carrito y, durante checkout, a una compra, con estados `active`, `committed`, `released` y `expired`.
+- `StockReservation` representa la reserva completa de un carrito o checkout, con estados `active`, `committed`, `released` y `expired`. Su `expires_at` es el único reloj del bloqueo. Al expirar, también pasan a `expired` la compra pagable y el carrito asociados dentro de la misma transacción. Sus estados terminales nunca se reactivan ni se reemplazan implícitamente. Sus `StockReservationLine` agregan la cantidad requerida por inventario, incluso cuando varios ítems o bundles consumen el mismo stock.
 - `Category` soporta jerarquía y categorías globales o propias del tenant.
 - `FeaturedGroup` y `FeaturedItem` organizan secciones destacadas.
 - `BundleComponent` representa los componentes de un paquete.
@@ -18,7 +18,8 @@ Modela y publica la oferta comercial del tenant: productos, variantes, categorí
 
 - `CatalogService`: alta, búsqueda, detalle, listado por categoría y eliminación.
 - `CatalogInventoryService`: consulta, reserva, libera y confirma inventario.
-- `StockReservationService`: mantiene el ledger de reservas sincronizado con `Inventory.reserved_stock`.
+- `StockReservationService`: sincroniza el carrito como conjunto, bloquea todos sus inventarios en orden estable y mantiene el ledger agregado consistente con `Inventory.reserved_stock`.
+- `ExpireStockReservationsService`: detecta en un único recorrido reservas vencidas de compras, carritos y huérfanas, y delega los efectos comerciales sin mezclar esas reglas con la liberación física del inventario.
 - `FeaturedGroupService`: pagina los ítems destacados para la tienda.
 - `OnTicketFeaturedGroupService`: administra grupos destacados del panel para sitios de tickets.