refactor(storage): centralize temporary URL generation

- Added migration to optimize OnTicket images using OptimizeOnticketImagesSeeder.
- Updated OnTicketTenantSeeder to reference optimized image formats (AVIF).
- Modified OnticketImmersiveHeroCarouselSeeder to use AVIF images for hero carousel.
- Created OptimizeOnticketImagesSeeder to replace existing attachments with optimized images.
- Adjusted TestEventsSeeder to utilize AVIF images for events.
- Updated tests to verify the correct image formats and ensure optimized images are stored.
- Added new image files in AVIF format for logos, backgrounds, and event images.

.env.example

@@ -8,6 +8,7 @@ PURCHASE_CHECKOUT_EXPIRATION_MINUTES=30
 PURCHASE_QR_EXPIRATION_MINUTES=15
 PURCHASE_TELEPAGOS_EXPIRATION_MINUTES=30
 PURCHASE_TRANSFER_EXPIRATION_MINUTES=1440
+PURCHASE_TRANSFER_CANDIDATE_AMOUNT_TOLERANCE_PERCENTAGE=5
 STOCK_RESERVATION_EXPIRATION_MINUTES=30
 FRONTEND_URLS=http://localhost:4200
 
@@ -31,6 +32,7 @@ AUTH_LOGIN_ATTEMPT_WINDOW_MINUTES=30
 AUTH_LOGIN_LOCK_MINUTES=15
 AUTH_LOGIN_RATE_LIMIT_PER_MINUTE=10
 AUTH_LOGIN_IP_RATE_LIMIT_PER_MINUTE=30
+AUTH_PASSWORD_RESET_EXPIRATION_MINUTES=60
 
 LOG_CHANNEL=daily
 LOG_STACK=single
@@ -41,6 +43,9 @@ TELEPAGOS_LOG_LEVEL=info
 TELEPAGOS_LOG_DAYS=30
 COMMANDS_LOG_LEVEL=info
 COMMANDS_LOG_DAYS=30
+EMAILS_LOG_LEVEL=info
+EMAILS_LOG_DAYS=30
+EMAIL_DELIVERY_LEASE_SECONDS=300
 
 DB_CONNECTION=mysql
 DB_HOST=127.0.0.1

AGENTS.md

@@ -1,19 +1,29 @@
 # Project Conventions
 
+## Test database safety
+
+- Tests must use SQLite `:memory:` through `tests/bootstrap.php` and `Tests\TestCase`.
+- Never run tests, `migrate:fresh`, `migrate:refresh`, or `db:wipe` against a persistent database, including the developer's `shopit` database.
+- Never bypass the connection safety guard to resolve test failures. Use `php tests/verify-database-safety.php` to verify isolation without queries or migrations.
+
 ## Architecture
 
-This project uses a domain-oriented structure under `app/Domains`.
+This project uses a domain-oriented structure grouped by business area under
+`app/Domains`. Cross-cutting modules live under `app/Shared`.
 
-Each domain must live in:
+Business domains must live in:
 
 ```text
-app/Domains/<DomainName>/
+app/Domains/<Area>/<DomainName>/
 ```
 
+The current areas are `Core`, `Commerce`, and `Ticketing`. Cross-cutting
+modules live in `app/Shared/<ModuleName>/`.
+
 Supported folders inside each domain:
 
 ```text
-app/Domains/<DomainName>/
+app/Domains/<Area>/<DomainName>/
 ├── Models/
 ├── Controllers/
 ├── Requests/
@@ -28,22 +38,28 @@ app/Domains/<DomainName>/
 
 - Root API routes live in `routes/api.php`.
 - `routes/api.php` should act as an aggregator only.
-- Each domain defines its own routes in `app/Domains/<DomainName>/routes/api.php`.
+- Each business domain defines its own routes in
+  `app/Domains/<Area>/<DomainName>/routes/api.php`.
+- Shared modules that expose routes define them in
+  `app/Shared/<ModuleName>/routes/api.php`.
 
 ## Namespaces
 
 Use this namespace pattern:
 
 ```php
-App\Domains\<DomainName>\Models
-App\Domains\<DomainName>\Controllers
-App\Domains\<DomainName>\Requests
-App\Domains\<DomainName>\Resources
-App\Domains\<DomainName>\Services
-App\Domains\<DomainName>\Policies
-App\Domains\<DomainName>\Exceptions
+App\Domains\<Area>\<DomainName>\Models
+App\Domains\<Area>\<DomainName>\Controllers
+App\Domains\<Area>\<DomainName>\Requests
+App\Domains\<Area>\<DomainName>\Resources
+App\Domains\<Area>\<DomainName>\Services
+App\Domains\<Area>\<DomainName>\Policies
+App\Domains\<Area>\<DomainName>\Exceptions
 ```
 
+For cross-cutting modules, use `App\Shared\<ModuleName>\...`. Reusable enums
+and rules live directly under `App\Shared`.
+
 ## Responsibilities
 
 - `Models/`: Eloquent models and model relationships.
@@ -74,13 +90,19 @@ App\Domains\<DomainName>\Exceptions
 - Namespace, folder, and class names must stay aligned.
 - Route files should be named `api.php`.
 
-## Current Domains
+## Current Areas and Modules
 
-- `Tenant`
-- `Product`
+- `Core`: `Administrator`, `Auth`, `Authorization`, `Bootstrap`, `Client`,
+  `Menu`, `Staff`, `Tenant`.
+- `Commerce`: `Cart`, `Catalog`, `Purchase`, `Sale`.
+- `Ticketing`: `Desfile`, `Event`, `FiestaFutbolInfantil`, `Ticket`.
+- `Shared`: `Attachable`, `Forms`, `Integration`, `Logging`, `MailTest`,
+  `Notification`, `StorageTest`, plus shared enums and rules.
 
 ## Notes For Future Changes
 
 - New features should be added inside the corresponding domain first.
-- If a concern does not belong to an existing domain, create a new domain under `app/Domains`.
+- Add new business features to the appropriate area under `app/Domains`.
+- Keep generic reusable code in `app/Shared`; do not use it as a catch-all for
+  business features.
 - Avoid placing new business code in `app/Http/Controllers` or `app/Models`.

app/Domains/Bootstrap/Services/AdminAppBootstrapService.php

@@ -1,19 +0,0 @@
-<?php
-
-namespace App\Domains\Bootstrap\Services;
-
-use App\Domains\Tenant\Models\WebsiteType;
-
-class AdminAppBootstrapService
-{
-    /** @return array{website_type: WebsiteType} */
-    public function get(string $domain): array
-    {
-        return [
-            'website_type' => WebsiteType::query()
-                ->with(['siteLogo', 'footerLogo'])
-                ->where('dominio', $domain)
-                ->firstOrFail(),
-        ];
-    }
-}

app/Domains/Bootstrap/Services/ScannerBootstrapService.php

@@ -1,19 +0,0 @@
-<?php
-
-namespace App\Domains\Bootstrap\Services;
-
-use App\Domains\Tenant\Models\WebsiteType;
-
-class ScannerBootstrapService
-{
-    /** @return array{website_type: WebsiteType} */
-    public function get(string $domain): array
-    {
-        return [
-            'website_type' => WebsiteType::query()
-                ->with(['siteLogo', 'footerLogo'])
-                ->where('scanner_domain', $domain)
-                ->firstOrFail(),
-        ];
-    }
-}

app/Domains/Cart/Services/ExpireCartReservationsService.php

@@ -1,123 +0,0 @@
-<?php
-
-namespace App\Domains\Cart\Services;
-
-use App\Domains\Cart\Models\Cart;
-use App\Domains\Cart\Models\CartItem;
-use App\Domains\Catalog\Models\Inventory;
-use App\Domains\Catalog\Models\StockReservation;
-use Illuminate\Support\Facades\DB;
-
-class ExpireCartReservationsService
-{
-    public function expireOverdue(): int
-    {
-        $expiredItems = 0;
-        $lastCartItemId = 0;
-
-        do {
-            $cartItemIds = StockReservation::query()
-                ->where('status', StockReservation::STATUS_ACTIVE)
-                ->whereNull('purchase_id')
-                ->whereNotNull('cart_item_id')
-                ->whereNotNull('expires_at')
-                ->where('expires_at', '<=', now())
-                ->where('cart_item_id', '>', $lastCartItemId)
-                ->whereHas('cartItem.cart', fn ($query) => $query->where('status', 'active'))
-                ->select('cart_item_id')
-                ->distinct()
-                ->orderBy('cart_item_id')
-                ->limit(500)
-                ->pluck('cart_item_id');
-
-            foreach ($cartItemIds as $cartItemId) {
-                $lastCartItemId = (int) $cartItemId;
-
-                if ($this->expireCartItem($lastCartItemId)) {
-                    $expiredItems++;
-                }
-            }
-        } while ($cartItemIds->count() === 500);
-
-        return $expiredItems;
-    }
-
-    private function expireCartItem(int $cartItemId): bool
-    {
-        /** @var CartItem|null $candidate */
-        $candidate = CartItem::query()->select(['id', 'cart_id'])->find($cartItemId);
-        if ($candidate === null) {
-            return false;
-        }
-
-        return DB::transaction(function () use ($candidate, $cartItemId): bool {
-            /** @var Cart|null $cart */
-            $cart = Cart::query()
-                ->whereKey($candidate->cart_id)
-                ->where('status', 'active')
-                ->lockForUpdate()
-                ->first();
-
-            if ($cart === null) {
-                return false;
-            }
-
-            /** @var CartItem|null $cartItem */
-            $cartItem = $cart->items()
-                ->whereKey($cartItemId)
-                ->lockForUpdate()
-                ->first();
-
-            if ($cartItem === null) {
-                return false;
-            }
-
-            $reservations = StockReservation::query()
-                ->where('cart_item_id', $cartItem->getKey())
-                ->where('status', StockReservation::STATUS_ACTIVE)
-                ->orderBy('inventory_id')
-                ->lockForUpdate()
-                ->get();
-
-            if (
-                $reservations->isEmpty()
-                || $reservations->contains(
-                    fn (StockReservation $reservation): bool => $reservation->purchase_id !== null
-                        || $reservation->expires_at === null
-                        || $reservation->expires_at->isFuture(),
-                )
-            ) {
-                return false;
-            }
-
-            $inventories = Inventory::query()
-                ->whereKey($reservations->pluck('inventory_id'))
-                ->orderBy('id')
-                ->lockForUpdate()
-                ->get()
-                ->keyBy('id');
-
-            foreach ($reservations as $reservation) {
-                $inventory = $inventories->get($reservation->inventory_id)
-                    ?? throw new \InvalidArgumentException('No se encontro el inventario reservado.');
-
-                $inventory->release((int) $reservation->quantity);
-                $reservation->update([
-                    'quantity' => 0,
-                    'status' => StockReservation::STATUS_EXPIRED,
-                    'expires_at' => null,
-                    'released_at' => now(),
-                ]);
-            }
-
-            $cartItem->delete();
-
-            if (! $cart->items()->exists()) {
-                $cart->update(['status' => 'expired']);
-                $cart->delete();
-            }
-
-            return true;
-        });
-    }
-}

app/Domains/Catalog/Models/StockReservation.php

@@ -1,61 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Models;
-
-use App\Domains\Cart\Models\CartItem;
-use App\Domains\Purchase\Models\Purchase;
-use Illuminate\Database\Eloquent\Attributes\Fillable;
-use Illuminate\Database\Eloquent\Model;
-use Illuminate\Database\Eloquent\Relations\BelongsTo;
-
-#[Fillable([
-    'inventory_id',
-    'cart_item_id',
-    'purchase_id',
-    'quantity',
-    'status',
-    'expires_at',
-    'committed_at',
-    'released_at',
-])]
-class StockReservation extends Model
-{
-    public const STATUS_ACTIVE = 'active';
-
-    public const STATUS_COMMITTED = 'committed';
-
-    public const STATUS_RELEASED = 'released';
-
-    public const STATUS_EXPIRED = 'expired';
-
-    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',
-        ];
-    }
-
-    /** @return BelongsTo<Inventory, $this> */
-    public function inventory(): BelongsTo
-    {
-        return $this->belongsTo(Inventory::class);
-    }
-
-    /** @return BelongsTo<CartItem, $this> */
-    public function cartItem(): BelongsTo
-    {
-        return $this->belongsTo(CartItem::class);
-    }
-
-    /** @return BelongsTo<Purchase, $this> */
-    public function purchase(): BelongsTo
-    {
-        return $this->belongsTo(Purchase::class);
-    }
-}

app/Domains/Catalog/Requests/StoreCatalogItemRequest.php

@@ -1,144 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Requests;
-
-use App\Domains\Catalog\Enums\CatalogItemType;
-use App\Domains\Catalog\Enums\InventoryPolicy;
-use App\Domains\Catalog\Enums\InventorySubject;
-use App\Domains\Shared\Rules\ImageOrBase64Rule;
-use Illuminate\Foundation\Http\FormRequest;
-use Illuminate\Validation\Rule;
-
-class StoreCatalogItemRequest extends FormRequest
-{
-    public function authorize(): bool
-    {
-        return true;
-    }
-
-    /** @return array<string, mixed> */
-    public function rules(): array
-    {
-        $tenantCode = $this->route('tenant')?->codigo;
-        $type = $this->input('type', CatalogItemType::Standard->value);
-        $isBundle = $type === CatalogItemType::Bundle->value;
-
-        return [
-            'tenant_code' => ['prohibited'],
-            'type' => ['sometimes', Rule::enum(CatalogItemType::class)],
-            'category_id' => [
-                'sometimes',
-                'nullable',
-                'integer',
-                Rule::exists('categorias', 'id')->where(
-                    fn ($query) => $query->where('tenant_code', $tenantCode)
-                ),
-            ],
-            'brand_id' => [
-                'sometimes',
-                'nullable',
-                'integer',
-                Rule::exists('brands', 'id')->where(
-                    fn ($query) => $query->where('tenant_codigo', $tenantCode)
-                ),
-            ],
-            'slug' => [
-                'required',
-                'string',
-                'max:255',
-                Rule::unique('catalog_items', 'slug')->where(
-                    fn ($query) => $query->where('tenant_code', $tenantCode)
-                ),
-            ],
-            'nombre' => ['required', 'string', 'max:255'],
-            'descripcion' => ['sometimes', 'nullable', 'string'],
-            'precio' => ['required', 'numeric', 'min:0'],
-            'inventory_policy' => [Rule::prohibitedIf($isBundle), 'sometimes', Rule::enum(InventoryPolicy::class)],
-            'inventory_subject' => ['sometimes', Rule::enum(InventorySubject::class)],
-            'max_units_per_user' => ['sometimes', 'nullable', 'integer', 'min:1'],
-            'has_tickets' => [Rule::prohibitedIf($isBundle), 'sometimes', 'boolean'],
-            'real_stock' => [Rule::prohibitedIf($isBundle), 'sometimes', 'integer', 'min:0'],
-            'inventory_id' => ['prohibited'],
-            'reserved_stock' => ['prohibited'],
-            'sold_units' => ['prohibited'],
-            'attribute_codes' => [Rule::prohibitedIf($isBundle), 'sometimes', 'array'],
-            'attribute_codes.*' => [
-                'required',
-                'string',
-                'distinct',
-                Rule::exists('attribute', 'codigo')->where(
-                    fn ($query) => $query->where('tenant_codigo', $tenantCode)
-                ),
-            ],
-            'multi_select_attribute_codes' => [Rule::prohibitedIf($isBundle), 'sometimes', 'array'],
-            'multi_select_attribute_codes.*' => [
-                'required',
-                'string',
-                'distinct',
-                Rule::exists('attribute', 'codigo')->where(
-                    fn ($query) => $query->where('tenant_codigo', $tenantCode)
-                ),
-            ],
-            'hidden_attribute_codes' => [Rule::prohibitedIf($isBundle), 'sometimes', 'array'],
-            'hidden_attribute_codes.*' => [
-                'required',
-                'string',
-                'distinct',
-                Rule::exists('attribute', 'codigo')->where(
-                    fn ($query) => $query->where('tenant_codigo', $tenantCode)
-                ),
-            ],
-            'images' => ['sometimes', 'array'],
-            'images.*' => ['required', new ImageOrBase64Rule],
-            'variants' => [Rule::prohibitedIf($isBundle), 'sometimes', 'array'],
-            'variants.*.real_stock' => ['sometimes', 'integer', 'min:0'],
-            'variants.*.descripcion' => ['sometimes', 'nullable', 'string'],
-            'variants.*.precio' => ['sometimes', 'nullable', 'numeric', 'min:0', 'max:99999999.99'],
-            'variants.*.event_date_id' => [
-                'sometimes',
-                'nullable',
-                'integer',
-                Rule::exists('event_dates', 'id')->where(
-                    fn ($query) => $query->where('tenant_code', $tenantCode)
-                ),
-            ],
-            'variants.*.event_date_ids' => ['sometimes', 'array', 'min:1'],
-            'variants.*.event_date_ids.*' => [
-                'required',
-                'integer',
-                'distinct',
-                Rule::exists('event_dates', 'id')->where(
-                    fn ($query) => $query->where('tenant_code', $tenantCode)
-                ),
-            ],
-            'variants.*.inventory_id' => ['prohibited'],
-            'variants.*.reserved_stock' => ['prohibited'],
-            'variants.*.sold_units' => ['prohibited'],
-            'variants.*.values' => ['sometimes', 'array'],
-            'variants.*.values.*' => ['nullable'],
-            'variants.*.values.*.*' => ['required', 'string'],
-            'variants.*.images' => ['sometimes', 'array'],
-            'variants.*.images.*' => ['required', new ImageOrBase64Rule],
-            'components' => [
-                Rule::requiredIf($isBundle),
-                Rule::prohibitedIf(! $isBundle),
-                'array',
-                'min:1',
-            ],
-            'components.*.catalog_item_id' => [
-                'required',
-                'integer',
-                Rule::exists('catalog_items', 'id')->where(
-                    fn ($query) => $query->where('tenant_code', $tenantCode)
-                ),
-            ],
-            'components.*.variant_id' => [
-                'sometimes',
-                'nullable',
-                'integer',
-                Rule::exists('variantes', 'id'),
-            ],
-            'components.*.quantity' => ['required', 'integer', 'min:1'],
-        ];
-    }
-}

app/Domains/Catalog/Resources/CatalogFeaturedItemResource.php

@@ -1,106 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Resources;
-
-use App\Domains\Catalog\Enums\InventoryPolicy;
-use App\Domains\Catalog\Enums\ProductLayout;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\FeaturedGroup;
-use App\Domains\Catalog\Models\Variant;
-use App\Domains\Catalog\Services\CatalogItemAllowanceService;
-use Illuminate\Http\Request;
-use Illuminate\Http\Resources\Json\JsonResource;
-
-/** @mixin CatalogItem */
-class CatalogFeaturedItemResource extends JsonResource
-{
-    /** @return array<string, mixed> */
-    public function toArray(Request $request): array
-    {
-        $catalogItem = $this->resource;
-        /** @var FeaturedGroup $featuredGroup */
-        $featuredGroup = $catalogItem->getRelation('featuredGroup');
-        $remainingUserQuota = $catalogItem->getAttribute('remaining_user_quota');
-
-        if ($featuredGroup->product_layout === ProductLayout::ColumnWithImage) {
-            return $this->columnWithImageData($catalogItem);
-        }
-
-        if ($featuredGroup->product_layout === ProductLayout::TicketSelector) {
-            return $this->ticketSelectorData($catalogItem);
-        }
-
-        $data = [
-            'id' => $catalogItem->id,
-            'type' => $catalogItem->type->value,
-            'nombre' => $catalogItem->nombre,
-            'descripcion' => $catalogItem->descripcion,
-            'precio' => $catalogItem->precio,
-            'maximum_addable_quantity' => $this->maximumAddable(
-                $catalogItem->availableStock(),
-                $remainingUserQuota,
-            ),
-            'variants' => $catalogItem->visibleVariants()
-                ->map(fn (Variant $variant): array => [
-                    'id' => $variant->id,
-                    'event_date_id' => $variant->event_date_id,
-                    'event_date' => $variant->eventDate?->date?->format('Y-m-d'),
-                    'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
-                    'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
-                    'descripcion' => $variant->getDescription(),
-                    'precio' => number_format($variant->getPrice(), 2, '.', ''),
-                    'maximum_addable_quantity' => $this->maximumAddable(
-                        $catalogItem->inventory_policy === InventoryPolicy::Unlimited
-                            ? null
-                            : $variant->inventory->availableStock(),
-                        $remainingUserQuota,
-                    ),
-                    'values' => $variant->selectorOptions($catalogItem->itemAttributes),
-                ])
-                ->values(),
-        ];
-
-        return $data;
-    }
-
-    /** @return array<string, mixed> */
-    private function ticketSelectorData(CatalogItem $catalogItem): array
-    {
-        return [
-            'id' => $catalogItem->id,
-            'type' => $catalogItem->type->value,
-            'nombre' => $catalogItem->nombre,
-            'descripcion' => $catalogItem->descripcion,
-            'precio' => $catalogItem->precio,
-            'image' => $this->firstImageUrl($catalogItem),
-        ];
-    }
-
-    /** @return array<string, mixed> */
-    private function columnWithImageData(CatalogItem $catalogItem): array
-    {
-        return [
-            'id' => $catalogItem->id,
-            'type' => $catalogItem->type->value,
-            'nombre' => $catalogItem->nombre,
-            'precio' => $catalogItem->precio,
-            'image' => $this->firstImageUrl($catalogItem),
-        ];
-    }
-
-    private function firstImageUrl(CatalogItem $catalogItem): ?string
-    {
-        $attachment = $catalogItem->attachments->first()
-            ?? $catalogItem->variants
-                ->flatMap(fn (Variant $variant) => $variant->attachments)
-                ->first();
-
-        return $attachment?->getTemporaryUrl(1440);
-    }
-
-    private function maximumAddable(?int $stock, ?int $remainingUserQuota): ?int
-    {
-        return app(CatalogItemAllowanceService::class)
-            ->maximumAddableQuantity($stock, $remainingUserQuota);
-    }
-}

app/Domains/Catalog/Resources/CatalogItemResource.php

@@ -1,50 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Resources;
-
-use App\Domains\Catalog\Models\CatalogItem;
-use Illuminate\Http\Request;
-use Illuminate\Http\Resources\Json\JsonResource;
-
-/** @mixin CatalogItem */
-class CatalogItemResource extends JsonResource
-{
-    /** @return array<string, mixed> */
-    public function toArray(Request $request): array
-    {
-        return [
-            'id' => $this->id,
-            'type' => $this->type->value,
-            'category_id' => $this->category_id,
-            'brand_id' => $this->brand_id,
-            'slug' => $this->slug,
-            'nombre' => $this->nombre,
-            'descripcion' => $this->descripcion,
-            'precio' => $this->precio,
-            'inventory_policy' => $this->inventory_policy?->value,
-            'inventory_subject' => $this->inventory_subject->value,
-            'max_units_per_user' => $this->max_units_per_user,
-            'has_tickets' => $this->has_tickets,
-            'real_stock' => $this->whenLoaded('inventory', fn () => $this->inventory?->real_stock),
-            'images' => $this->whenLoaded('attachments', fn () => $this->attachments
-                ->map(fn ($attachment) => $attachment->getTemporaryUrl(1440))
-                ->values()),
-            'variants' => $this->whenLoaded('variants', fn () => $this->variants
-                ->map(fn ($variant) => [
-                    'id' => $variant->id,
-                    'event_date_id' => $variant->event_date_id,
-                    'event_date' => $variant->eventDate?->date?->format('Y-m-d'),
-                    'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
-                    'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
-                    'descripcion' => $variant->getDescription(),
-                    'precio' => number_format($variant->getPrice(), 2, '.', ''),
-                    'real_stock' => $variant->inventory?->real_stock,
-                    'values' => $variant->selectorOptions($this->itemAttributes),
-                    'images' => $variant->attachments
-                        ->map(fn ($attachment) => $attachment->getTemporaryUrl(1440))
-                        ->values(),
-                ])
-                ->values()),
-        ];
-    }
-}

app/Domains/Catalog/Resources/CatalogSearchItemResource.php

@@ -1,58 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Resources;
-
-use App\Domains\Catalog\Enums\InventoryPolicy;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\Variant;
-use App\Domains\Catalog\Services\CatalogItemAllowanceService;
-use Illuminate\Http\Request;
-use Illuminate\Http\Resources\Json\JsonResource;
-
-/** @mixin CatalogItem */
-class CatalogSearchItemResource extends JsonResource
-{
-    /** @return array<string, mixed> */
-    public function toArray(Request $request): array
-    {
-        $attachment = $this->attachments->first()
-            ?? $this->variants
-                ->flatMap(fn (Variant $variant) => $variant->attachments)
-                ->first();
-
-        return [
-            'id' => $this->id,
-            'type' => $this->type->value,
-            'nombre' => $this->nombre,
-            'descripcion' => $this->descripcion,
-            'precio' => $this->precio,
-            'image' => $attachment?->getTemporaryUrl(1440),
-            'maximum_addable_quantity' => $this->maximumAddable($this->availableStock()),
-            'variants' => $this->visibleVariants()
-                ->map(fn (Variant $variant): array => [
-                    'id' => $variant->id,
-                    'event_date_id' => $variant->event_date_id,
-                    'event_date' => $variant->eventDate?->date?->format('Y-m-d'),
-                    'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
-                    'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
-                    'descripcion' => $variant->getDescription(),
-                    'precio' => number_format($variant->getPrice(), 2, '.', ''),
-                    'maximum_addable_quantity' => $this->maximumAddable(
-                        $this->inventory_policy === InventoryPolicy::Unlimited
-                            ? null
-                            : $variant->inventory?->availableStock(),
-                    ),
-                    'values' => $variant->selectorOptions($this->itemAttributes),
-                ])
-                ->values(),
-        ];
-    }
-
-    private function maximumAddable(?int $stock): ?int
-    {
-        return app(CatalogItemAllowanceService::class)->maximumAddableQuantity(
-            $stock,
-            $this->getAttribute('remaining_user_quota'),
-        );
-    }
-}

app/Domains/Catalog/Services/ExpireStockReservationsService.php

@@ -1,51 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Services;
-
-use App\Domains\Cart\Services\ExpireCartReservationsService;
-use App\Domains\Purchase\Services\CheckoutService;
-use Illuminate\Support\Facades\Log;
-use Throwable;
-
-class ExpireStockReservationsService
-{
-    public function __construct(
-        private readonly CheckoutService $checkout,
-        private readonly ExpireCartReservationsService $carts,
-    ) {}
-
-    /**
-     * @return array{purchases: int, cart_items: int}
-     */
-    public function expireOverdue(): array
-    {
-        $expiredPurchases = null;
-        $expiredCartItems = null;
-
-        try {
-            $expiredPurchases = $this->checkout->expireOverduePurchases();
-            $expiredCartItems = $this->carts->expireOverdue();
-
-            Log::channel('commands')->info('Stock reservation cleanup completed.', [
-                'command' => 'reservations:expire',
-                'expired_purchases' => $expiredPurchases,
-                'expired_cart_items' => $expiredCartItems,
-                'total_expired' => $expiredPurchases + $expiredCartItems,
-            ]);
-
-            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,
-            ]);
-
-            throw $exception;
-        }
-    }
-}

app/Domains/Catalog/Services/StockReservationService.php

@@ -1,230 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Services;
-
-use App\Domains\Cart\Models\CartItem;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\StockReservation;
-use App\Domains\Catalog\Models\Variant;
-use App\Domains\Purchase\Models\Purchase;
-use Illuminate\Support\Carbon;
-use Illuminate\Support\Facades\DB;
-
-class StockReservationService
-{
-    public function __construct(
-        private readonly CatalogInventoryService $inventory,
-    ) {}
-
-    public function reserve(CartItem $cartItem, CatalogItem|Variant $selection, int $quantity): void
-    {
-        DB::transaction(function () use ($cartItem, $selection, $quantity): void {
-            $this->inventory->reserve($selection, $quantity);
-            $this->recordIncrease($cartItem, $selection, $quantity);
-        });
-    }
-
-    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);
-        });
-    }
-
-    public function commit(CartItem $cartItem, CatalogItem|Variant $selection): void
-    {
-        DB::transaction(function () use ($cartItem, $selection): void {
-            $this->ensure($cartItem, $selection);
-            $this->inventory->commit($selection, (int) $cartItem->cantidad);
-
-            $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->quantity !== $quantity) {
-                    throw new \InvalidArgumentException('La reserva de stock no coincide con el item del carrito.');
-                }
-
-                $reservation->update([
-                    'status' => StockReservation::STATUS_COMMITTED,
-                    'committed_at' => now(),
-                    'expires_at' => 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,
-                    'status' => StockReservation::STATUS_ACTIVE,
-                    'expires_at' => $this->expiration(),
-                ]);
-
-                continue;
-            }
-
-            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(),
-                ]);
-            }
-        }
-    }
-
-    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 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')
-                ->lockForUpdate()
-                ->get();
-
-            foreach ($sourceReservations as $sourceReservation) {
-                $targetReservation = $this->lockReservation($target, (int) $sourceReservation->inventory_id);
-
-                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(),
-                    ]);
-
-                    continue;
-                }
-
-                $targetReservation->update([
-                    'quantity' => $targetReservation->quantity + $sourceReservation->quantity,
-                    'status' => StockReservation::STATUS_ACTIVE,
-                    'expires_at' => $this->expiration(),
-                ]);
-                $sourceReservation->delete();
-            }
-        });
-    }
-
-    private function recordIncrease(CartItem $cartItem, CatalogItem|Variant $selection, int $quantity): void
-    {
-        foreach ($this->inventory->requirementsFor($selection, $quantity) as $inventoryId => $requiredQuantity) {
-            $reservation = $this->lockReservation($cartItem, $inventoryId);
-
-            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;
-            }
-
-            $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(),
-            ]);
-        }
-    }
-
-    private function recordDecrease(
-        CartItem $cartItem,
-        CatalogItem|Variant $selection,
-        int $quantity,
-        string $releasedStatus,
-    ): 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.');
-            }
-
-            $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,
-            ]);
-        }
-    }
-
-    private function lockReservation(CartItem $cartItem, int $inventoryId): ?StockReservation
-    {
-        return StockReservation::query()
-            ->where('cart_item_id', $cartItem->getKey())
-            ->where('inventory_id', $inventoryId)
-            ->lockForUpdate()
-            ->first();
-    }
-
-    private function expiration(): Carbon
-    {
-        return now()->addMinutes(
-            max(1, (int) config('catalog.stock_reservation_expiration_minutes', 30)),
-        );
-    }
-}

app/Domains/Commerce/Cart/Controllers/CartController.php

@@ -1,14 +1,13 @@
 <?php
 
-namespace App\Domains\Cart\Controllers;
+namespace App\Domains\Commerce\Cart\Controllers;
 
-use App\Domains\Cart\Models\Cart;
-use App\Domains\Cart\Models\CartItem;
-use App\Domains\Cart\Requests\AddCartItemRequest;
-use App\Domains\Cart\Requests\UpdateCartItemQuantityRequest;
-use App\Domains\Cart\Resources\CartResource;
-use App\Domains\Cart\Services\CartService;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Commerce\Cart\Models\CartItem;
+use App\Domains\Commerce\Cart\Requests\AddCartItemRequest;
+use App\Domains\Commerce\Cart\Requests\UpdateCartItemQuantityRequest;
+use App\Domains\Commerce\Cart\Resources\CartResource;
+use App\Domains\Commerce\Cart\Services\CartService;
+use App\Domains\Core\Tenant\Models\Tenant;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
@@ -78,36 +77,6 @@ class CartController extends Controller
         ]);
     }
 
-    public function updateCheckoutItem(
-        UpdateCartItemQuantityRequest $request,
-        Tenant $tenant,
-        Cart $cart,
-        CartItem $cartItem,
-    ): CartResource {
-        $updatesVariant = $request->exists('variant_id');
-
-        return CartResource::make(
-            $this->cartService->updateCheckoutItem(
-                $tenant,
-                $request,
-                $cart,
-                $cartItem->getKey(),
-                (int) $request->validated('cantidad'),
-                $updatesVariant
-                    ? ($request->validated('variant_id') !== null
-                        ? (int) $request->validated('variant_id')
-                        : null)
-                    : $cartItem->variant_id,
-                $updatesVariant,
-            ),
-        )->additional([
-            'code' => $updatesVariant ? 'cart.item_updated' : 'cart.quantity_updated',
-            'message' => $updatesVariant
-                ? __('api.cart.item_updated')
-                : __('api.cart.quantity_updated'),
-        ]);
-    }
-
     public function removeItem(Request $request, Tenant $tenant, CartItem $cartItem): CartResource
     {
         return CartResource::make(
@@ -117,23 +86,4 @@ class CartController extends Controller
             'message' => __('api.cart.item_removed'),
         ]);
     }
-
-    public function removeCheckoutItem(
-        Request $request,
-        Tenant $tenant,
-        Cart $cart,
-        CartItem $cartItem,
-    ): CartResource {
-        return CartResource::make(
-            $this->cartService->removeCheckoutItem(
-                $tenant,
-                $request,
-                $cart,
-                $cartItem->getKey(),
-            ),
-        )->additional([
-            'code' => 'cart.item_removed',
-            'message' => __('api.cart.item_removed'),
-        ]);
-    }
 }

app/Domains/Commerce/Cart/Models/Cart.php

@@ -1,16 +1,17 @@
 <?php
 
-namespace App\Domains\Cart\Models;
+namespace App\Domains\Commerce\Cart\Models;
 
-use App\Domains\Auth\Models\User;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\Inventory;
-use App\Domains\Catalog\Models\Variant;
-use App\Domains\Catalog\Services\CatalogInventoryService;
-use App\Domains\Catalog\Services\StockReservationService;
-use App\Domains\Purchase\Models\Purchase;
-use App\Domains\Purchase\Services\UserPurchaseLimitService;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Core\Auth\Models\User;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Inventory;
+use App\Domains\Commerce\Catalog\Models\StockReservation;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Services\CatalogInventoryService;
+use App\Domains\Commerce\Catalog\Services\StockReservationService;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Commerce\Purchase\Services\UserPurchaseLimitService;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
@@ -27,6 +28,8 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
     'guest_token',
     'status',
     'origin',
+    'current_purchase_id',
+    'current_stock_reservation_id',
 ])]
 class Cart extends Model
 {
@@ -35,6 +38,16 @@ class Cart extends Model
 
     protected $table = 'carritos';
 
+    public const STATUS_ACTIVE = 'active';
+
+    public const STATUS_CHECKOUT = 'checkout';
+
+    public const STATUS_CONVERTED = 'converted';
+
+    public const STATUS_EXPIRED = 'expired';
+
+    public const STATUS_ABANDONED = 'abandoned';
+
     public const ORIGIN_USER = 'user';
 
     public const ORIGIN_DIRECT_CHECKOUT = 'direct_checkout';
@@ -43,6 +56,8 @@ class Cart extends Model
     {
         return [
             'user_id' => 'integer',
+            'current_purchase_id' => 'integer',
+            'current_stock_reservation_id' => 'integer',
         ];
     }
 
@@ -76,6 +91,21 @@ class Cart extends Model
         return $this->hasMany(Purchase::class, 'cart_id');
     }
 
+    /** @return BelongsTo<Purchase, $this> */
+    public function currentPurchase(): BelongsTo
+    {
+        return $this->belongsTo(Purchase::class, 'current_purchase_id');
+    }
+
+    /** @return BelongsTo<StockReservation, $this> */
+    public function currentStockReservation(): BelongsTo
+    {
+        return $this->belongsTo(
+            StockReservation::class,
+            'current_stock_reservation_id',
+        );
+    }
+
     public function getTotalAmount(): float
     {
         $items = $this->relationLoaded('items')
@@ -98,7 +128,8 @@ class Cart extends Model
         }
 
         return DB::transaction(function () use ($catalogItemId, $variantId, $quantity): CartItem {
-            self::query()->whereKey($this->getKey())->lockForUpdate()->firstOrFail();
+            $this->invalidateCurrentCheckout();
+            app(StockReservationService::class)->assertCartReservationUsable($this);
             $selectedItem = $this->resolveScopedItem($catalogItemId, $variantId, true);
             $cartQuantity = (int) $this->items()
                 ->where('catalog_item_id', $catalogItemId)
@@ -132,12 +163,11 @@ class Cart extends Model
                     'cantidad' => $quantity,
                 ]);
             } else {
-                app(StockReservationService::class)->ensure($item, $selectedItem);
                 $item->cantidad += $quantity;
                 $item->save();
             }
 
-            app(StockReservationService::class)->reserve($item, $selectedItem, $quantity);
+            app(StockReservationService::class)->syncCart($this);
 
             return $item->fresh();
         });
@@ -163,6 +193,9 @@ class Cart extends Model
             $updateVariant,
             $excludedPurchaseId,
         ): CartItem {
+            $this->invalidateCurrentCheckout();
+            app(StockReservationService::class)->assertCartReservationUsable($this);
+
             /** @var CartItem $item */
             $item = $this->items()
                 ->where('id', $cartItemId)
@@ -195,7 +228,6 @@ class Cart extends Model
                     $nextAvailableQuantity,
                 );
 
-                app(StockReservationService::class)->release($item, $currentSelection, $item->cantidad);
                 $availableQuantity = $inventoryService->availableQuantity($nextSelection);
 
                 if ($availableQuantity !== null && $availableQuantity < $quantity) {
@@ -212,11 +244,10 @@ class Cart extends Model
                     ->first();
 
                 if ($targetItem !== null) {
-                    app(StockReservationService::class)->ensure($targetItem, $nextSelection);
                     $targetItem->cantidad += $quantity;
                     $targetItem->save();
-                    app(StockReservationService::class)->reserve($targetItem, $nextSelection, $quantity);
                     $item->delete();
+                    app(StockReservationService::class)->syncCart($this);
 
                     return $targetItem->fresh();
                 }
@@ -224,7 +255,7 @@ class Cart extends Model
                 $item->variant_id = $variantId;
                 $item->cantidad = $quantity;
                 $item->save();
-                app(StockReservationService::class)->reserve($item, $nextSelection, $quantity);
+                app(StockReservationService::class)->syncCart($this);
 
                 return $item->fresh();
             }
@@ -253,16 +284,9 @@ class Cart extends Model
                 ]);
             }
 
-            if ($delta > 0) {
-                app(StockReservationService::class)->reserve($item, $currentSelection, $delta);
-            }
-
-            if ($delta < 0) {
-                app(StockReservationService::class)->release($item, $currentSelection, abs($delta));
-            }
-
             $item->cantidad = $quantity;
             $item->save();
+            app(StockReservationService::class)->syncCart($this);
 
             return $item->fresh();
         });
@@ -271,26 +295,79 @@ class Cart extends Model
     public function removeItem(int $cartItemId): void
     {
         DB::transaction(function () use ($cartItemId): void {
+            $this->invalidateCurrentCheckout();
+            app(StockReservationService::class)->assertCartReservationUsable($this);
+
             /** @var CartItem $item */
             $item = $this->items()
                 ->where('id', $cartItemId)
                 ->lockForUpdate()
                 ->firstOrFail();
 
-            $selectedItem = $this->resolveScopedItem(
-                $item->catalog_item_id,
-                $item->variant_id,
-                true,
-            );
-            app(StockReservationService::class)->release(
-                $item,
-                $selectedItem,
-                $item->cantidad,
-            );
             $item->delete();
+            app(StockReservationService::class)->syncCart($this);
         });
     }
 
+    private function invalidateCurrentCheckout(): void
+    {
+        $candidatePurchaseId = self::query()
+            ->whereKey($this->getKey())
+            ->value('current_purchase_id');
+        $currentPurchase = $candidatePurchaseId === null
+            ? null
+            : Purchase::query()->lockForUpdate()->find($candidatePurchaseId);
+
+        /** @var self $cart */
+        $cart = self::query()->lockForUpdate()->findOrFail($this->getKey());
+
+        if ($cart->current_purchase_id !== $candidatePurchaseId) {
+            if ($cart->current_purchase_id !== null) {
+                throw ValidationException::withMessages([
+                    'cart' => __('api.purchase.checkout_in_progress'),
+                ]);
+            }
+
+            $this->current_purchase_id = null;
+
+            return;
+        }
+
+        if ($currentPurchase === null) {
+            return;
+        }
+
+        if ($currentPurchase->status === Purchase::STATUS_PAID) {
+            throw ValidationException::withMessages([
+                'cart' => __('api.cart.editing_disabled'),
+            ]);
+        }
+
+        if (in_array($currentPurchase->status, [
+            Purchase::STATUS_CREATED,
+            Purchase::STATUS_PENDING_PAYMENT,
+        ], true)) {
+            app(StockReservationService::class)->returnToCart($currentPurchase, $cart);
+            $currentPurchase->update([
+                'status' => Purchase::STATUS_SUPERSEDED,
+            ]);
+
+            $this->current_purchase_id = null;
+
+            return;
+        }
+
+        app(StockReservationService::class)->releaseForPurchase(
+            $currentPurchase,
+            reason: StockReservationService::REASON_PURCHASE_SUPERSEDED,
+        );
+        self::query()
+            ->whereKey($cart->getKey())
+            ->where('current_purchase_id', $currentPurchase->getKey())
+            ->update(['current_purchase_id' => null]);
+        $this->current_purchase_id = null;
+    }
+
     protected function resolveScopedItem(
         int $catalogItemId,
         ?int $variantId,
@@ -298,7 +375,7 @@ class Cart extends Model
     ): CatalogItem|Variant {
         $catalogItemQuery = CatalogItem::query()
             ->whereKey($catalogItemId)
-            ->where('tenant_code', $this->tenant_codigo);
+            ->forTenantCatalog($this->tenant()->firstOrFail());
 
         if ($lockForUpdate) {
             $catalogItemQuery->lockForUpdate();
@@ -323,6 +400,17 @@ class Cart extends Model
                 ]);
             }
 
+            if ($catalogItem->bundleComponents()
+                ->whereNotNull('component_variant_id')
+                ->whereHas('variant', fn ($query) => $query
+                    ->whereNotNull('sales_disabled_at')
+                    ->orWhereNotNull('replaced_by_variant_id'))
+                ->exists()) {
+                throw ValidationException::withMessages([
+                    'catalog_item_id' => [__('api.cart.bundle_component_unavailable')],
+                ]);
+            }
+
             return $catalogItem;
         }
 
@@ -353,6 +441,12 @@ class Cart extends Model
             throw new NotFoundHttpException('Variant not found for catalog item.');
         }
 
+        if (! $variant->isSellable()) {
+            throw ValidationException::withMessages([
+                'variant_id' => [__('api.cart.variant_unavailable')],
+            ]);
+        }
+
         $inventory = $this->resolveInventory($variant->inventory_id, $lockForUpdate);
         $variant->setRelation('catalogItem', $catalogItem);
         $variant->setRelation('inventory', $inventory);

app/Domains/Commerce/Cart/Models/CartItem.php

@@ -1,15 +1,13 @@
 <?php
 
-namespace App\Domains\Cart\Models;
+namespace App\Domains\Commerce\Cart\Models;
 
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\StockReservation;
-use App\Domains\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Variant;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
-use Illuminate\Database\Eloquent\Relations\HasMany;
 
 #[Fillable([
     'cart_id',
@@ -57,10 +55,4 @@ class CartItem extends Model
     {
         return $this->variant ?? $this->catalogItem;
     }
-
-    /** @return HasMany<StockReservation, $this> */
-    public function stockReservations(): HasMany
-    {
-        return $this->hasMany(StockReservation::class);
-    }
 }

app/Domains/Commerce/Cart/Requests/AddCartItemRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Cart\Requests;
+namespace App\Domains\Commerce\Cart\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;

app/Domains/Commerce/Cart/Requests/UpdateCartItemQuantityRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Cart\Requests;
+namespace App\Domains\Commerce\Cart\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 

app/Domains/Commerce/Cart/Resources/CartItemResource.php

@@ -1,12 +1,11 @@
 <?php
 
-namespace App\Domains\Cart\Resources;
+namespace App\Domains\Commerce\Cart\Resources;
 
-use App\Domains\Cart\Models\Cart;
-use App\Domains\Cart\Models\CartItem;
-use App\Domains\Catalog\Enums\InventoryPolicy;
-use App\Domains\Catalog\Models\Variant;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Commerce\Cart\Models\CartItem;
+use App\Domains\Commerce\Catalog\Enums\InventoryPolicy;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 
@@ -23,13 +22,9 @@ class CartItemResource extends JsonResource
         $selectedItem = $this->selectedItem();
         $imageUrl = null;
         $tenant = $request->route('tenant');
-        $checkoutCart = $request->route('cart');
         $displayImage = ! $tenant instanceof Tenant || $tenant->display_cart_item_images;
         $includeVariants = $tenant instanceof Tenant
-            && ($checkoutCart instanceof Cart
-                ? $tenant->checkout_editing_policy
-                : $tenant->cart_editing_policy)
-                ->allowsVariantChanges();
+            && $tenant->cart_editing_policy->allowsVariantChanges();
 
         if ($displayImage && $selectedItem?->relationLoaded('attachments')) {
             $imageUrl = $selectedItem->attachments->first()?->getTemporaryUrl(1440);

app/Domains/Commerce/Cart/Resources/CartResource.php

@@ -1,8 +1,8 @@
 <?php
 
-namespace App\Domains\Cart\Resources;
+namespace App\Domains\Commerce\Cart\Resources;
 
-use App\Domains\Cart\Models\Cart;
+use App\Domains\Commerce\Cart\Models\Cart;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 

app/Domains/Commerce/Cart/Services/CartService.php

@@ -1,14 +1,12 @@
 <?php
 
-namespace App\Domains\Cart\Services;
+namespace App\Domains\Commerce\Cart\Services;
 
-use App\Domains\Auth\Models\User;
-use App\Domains\Cart\Models\Cart;
-use App\Domains\Cart\Models\CartItem;
-use App\Domains\Catalog\Services\StockReservationService;
-use App\Domains\Purchase\Models\Purchase;
-use App\Domains\Purchase\Services\PurchaseStateGuard;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Core\Auth\Models\User;
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Catalog\Exceptions\StockReservationExpiredException;
+use App\Domains\Commerce\Catalog\Services\ExpireStockReservationsService;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\DB;
@@ -19,11 +17,6 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 
 class CartService
 {
-    public function __construct(
-        private readonly StockReservationService $reservations,
-        private readonly PurchaseStateGuard $purchaseState,
-    ) {}
-
     public function show(Tenant $tenant, Request $request): Cart
     {
         $resolvedIdentity = $this->resolveIdentity($request);
@@ -32,7 +25,7 @@ class CartService
             return $this->makeEmptyCart($tenant);
         }
 
-        $cart = $this->findCart($tenant, $resolvedIdentity['identity']);
+        $cart = $this->resolveCart($tenant, $resolvedIdentity['identity']);
 
         if ($cart === null) {
             return $this->makeEmptyCart($tenant);
@@ -89,125 +82,6 @@ class CartService
         return $this->loadCart($cart, $tenant);
     }
 
-    public function updateCheckoutItem(
-        Tenant $tenant,
-        Request $request,
-        Cart $cart,
-        int $cartItemId,
-        int $quantity,
-        ?int $variantId,
-        bool $updateVariant,
-    ): Cart {
-        $user = $request->user() ?? Auth::guard('sanctum')->user();
-
-        if (! $user instanceof User) {
-            throw new NotFoundHttpException('Checkout cart not found.');
-        }
-
-        return DB::transaction(function () use (
-            $tenant,
-            $user,
-            $cart,
-            $cartItemId,
-            $quantity,
-            $variantId,
-            $updateVariant,
-        ): Cart {
-            /** @var Purchase|null $purchase */
-            $purchase = Purchase::query()
-                ->where('cart_id', $cart->getKey())
-                ->where('tenant_codigo', $tenant->codigo)
-                ->where('user_id', $user->getKey())
-                ->whereDoesntHave('items')
-                ->lockForUpdate()
-                ->first();
-
-            if ($purchase === null) {
-                throw new NotFoundHttpException('Checkout cart not found.');
-            }
-
-            $this->purchaseState->assertNotExpired($purchase);
-
-            if (! in_array($purchase->status, [
-                Purchase::STATUS_CREATED,
-                Purchase::STATUS_PENDING_PAYMENT,
-            ], true)) {
-                throw new NotFoundHttpException('Checkout cart not found.');
-            }
-
-            /** @var Cart|null $checkoutCart */
-            $checkoutCart = Cart::query()
-                ->whereKey($cart->getKey())
-                ->where('tenant_codigo', $tenant->codigo)
-                ->where('user_id', $user->getKey())
-                ->where('status', 'checkout')
-                ->lockForUpdate()
-                ->first();
-
-            if ($checkoutCart === null) {
-                throw new NotFoundHttpException('Checkout cart not found.');
-            }
-
-            /** @var CartItem|null $cartItem */
-            $cartItem = $checkoutCart->items()
-                ->whereKey($cartItemId)
-                ->lockForUpdate()
-                ->first();
-
-            if ($cartItem === null) {
-                throw new NotFoundHttpException('Checkout item not found.');
-            }
-
-            $hasChanges = (int) $cartItem->cantidad !== $quantity
-                || ($updateVariant && $cartItem->variant_id !== $variantId);
-
-            if (! $hasChanges) {
-                return $this->loadCart($checkoutCart, $tenant, true);
-            }
-
-            if (
-                (int) $cartItem->cantidad !== $quantity
-                && ! $tenant->checkout_editing_policy->allowsQuantityChanges()
-            ) {
-                throw ValidationException::withMessages([
-                    'cantidad' => __('api.cart.editing_disabled'),
-                ]);
-            }
-
-            if (
-                $updateVariant
-                && $cartItem->variant_id !== $variantId
-                && ! $tenant->checkout_editing_policy->allowsVariantChanges()
-            ) {
-                throw ValidationException::withMessages([
-                    'variant_id' => __('api.cart.variant_change_disabled'),
-                ]);
-            }
-
-            $checkoutCart->updateItem(
-                $cartItemId,
-                $quantity,
-                $variantId,
-                $updateVariant,
-                $purchase->getKey(),
-            );
-
-            $purchase->telepagosQr()->delete();
-            $purchase->update([
-                'status' => Purchase::STATUS_CREATED,
-                'payment_method' => null,
-                'transfer_payer_dni' => null,
-                'total' => $checkoutCart->getTotalAmount(),
-                'expires_at' => now()->addMinutes(
-                    max(1, (int) config('purchase.checkout_expiration_minutes', 30)),
-                ),
-            ]);
-            $this->reservations->syncPurchaseExpiration($purchase);
-
-            return $this->loadCart($checkoutCart, $tenant, true);
-        });
-    }
-
     public function removeItem(Tenant $tenant, Request $request, int $cartItemId): Cart
     {
         if (! $tenant->cart_editing_policy->allowsRemoval()) {
@@ -223,77 +97,6 @@ class CartService
         return $this->loadCart($cart, $tenant);
     }
 
-    public function removeCheckoutItem(
-        Tenant $tenant,
-        Request $request,
-        Cart $cart,
-        int $cartItemId,
-    ): Cart {
-        if (! $tenant->checkout_editing_policy->allowsRemoval()) {
-            throw ValidationException::withMessages([
-                'cart_item' => __('api.cart.editing_disabled'),
-            ]);
-        }
-
-        $user = $request->user() ?? Auth::guard('sanctum')->user();
-
-        if (! $user instanceof User) {
-            throw new NotFoundHttpException('Checkout cart not found.');
-        }
-
-        return DB::transaction(function () use ($tenant, $user, $cart, $cartItemId): Cart {
-            /** @var Purchase|null $purchase */
-            $purchase = Purchase::query()
-                ->where('cart_id', $cart->getKey())
-                ->where('tenant_codigo', $tenant->codigo)
-                ->where('user_id', $user->getKey())
-                ->whereDoesntHave('items')
-                ->lockForUpdate()
-                ->first();
-
-            if ($purchase === null) {
-                throw new NotFoundHttpException('Checkout cart not found.');
-            }
-
-            $this->purchaseState->assertNotExpired($purchase);
-
-            if (! in_array($purchase->status, [
-                Purchase::STATUS_CREATED,
-                Purchase::STATUS_PENDING_PAYMENT,
-            ], true)) {
-                throw new NotFoundHttpException('Checkout cart not found.');
-            }
-
-            /** @var Cart|null $checkoutCart */
-            $checkoutCart = Cart::query()
-                ->whereKey($cart->getKey())
-                ->where('tenant_codigo', $tenant->codigo)
-                ->where('user_id', $user->getKey())
-                ->where('status', 'checkout')
-                ->lockForUpdate()
-                ->first();
-
-            if ($checkoutCart === null) {
-                throw new NotFoundHttpException('Checkout cart not found.');
-            }
-
-            $checkoutCart->removeItem($cartItemId);
-            $purchase->telepagosQr()->delete();
-            $purchase->update([
-                'status' => Purchase::STATUS_CREATED,
-                'payment_method' => null,
-                'transfer_payer_dni' => null,
-                'total' => $checkoutCart->getTotalAmount(),
-                'expires_at' => now()->addMinutes(
-                    max(1, (int) config('purchase.checkout_expiration_minutes', 30)),
-                ),
-            ]);
-            $this->reservations->syncPurchaseExpiration($purchase);
-
-            return $this->loadCart($checkoutCart, $tenant, true);
-        });
-    }
-
     public function makeGuestTokenCookie(string $guestToken): Cookie
     {
         $secure = (bool) config('session.secure');
@@ -319,7 +122,7 @@ class CartService
     {
         $cart = new Cart([
             'tenant_codigo' => $tenant->codigo,
-            'status' => 'active',
+            'status' => Cart::STATUS_ACTIVE,
         ]);
 
         $cart->setRelation('items', collect());
@@ -327,7 +130,7 @@ class CartService
         return $cart;
     }
 
-    protected function loadCart(Cart $cart, Tenant $tenant, bool $isCheckout = false): Cart
+    protected function loadCart(Cart $cart, Tenant $tenant): Cart
     {
         $relations = [
             'items.catalogItem.attachments',
@@ -340,11 +143,7 @@ class CartService
             'items.variant.eventDate',
         ];
 
-        $editingPolicy = $isCheckout
-            ? $tenant->checkout_editing_policy
-            : $tenant->cart_editing_policy;
-
-        if ($editingPolicy->allowsVariantChanges()) {
+        if ($tenant->cart_editing_policy->allowsVariantChanges()) {
             $relations = [
                 ...$relations,
                 'items.catalogItem.variants' => fn ($query) => $query->orderBy('id'),
@@ -424,12 +223,14 @@ class CartService
     {
         return Cart::query()
             ->where('tenant_codigo', $tenant->codigo)
-            ->where('status', 'active')
+            ->where('origin', Cart::ORIGIN_USER)
+            ->whereIn('status', [Cart::STATUS_ACTIVE, Cart::STATUS_EXPIRED])
             ->when(
                 $identity['user_id'] !== null,
                 fn ($query) => $query->where('user_id', $identity['user_id']),
                 fn ($query) => $query->where('guest_token', $identity['guest_token']),
             )
+            ->orderByRaw('CASE WHEN status = ? THEN 0 ELSE 1 END', [Cart::STATUS_ACTIVE])
             ->first();
     }
 
@@ -438,7 +239,7 @@ class CartService
      */
     protected function findCartOrFail(Tenant $tenant, array $identity): Cart
     {
-        $cart = $this->findCart($tenant, $identity);
+        $cart = $this->resolveCart($tenant, $identity, replaceExpired: false);
 
         if ($cart === null) {
             throw new NotFoundHttpException('Cart not found.');
@@ -451,10 +252,73 @@ class CartService
      * @param  array{user_id: ?int, guest_token: ?string}  $identity
      */
     protected function findOrCreateCart(Tenant $tenant, array $identity): Cart
+    {
+        return $this->resolveCart($tenant, $identity)
+            ?? $this->createCart($tenant, $identity);
+    }
+
+    /**
+     * @param  array{user_id: ?int, guest_token: ?string}  $identity
+     */
+    protected function resolveCart(
+        Tenant $tenant,
+        array $identity,
+        bool $replaceExpired = true,
+    ): ?Cart {
+        $cart = $this->findCart($tenant, $identity);
+
+        if ($cart?->status === Cart::STATUS_ACTIVE
+            && $cart->current_stock_reservation_id !== null
+            && app(ExpireStockReservationsService::class)
+                ->expireIfOverdue($cart->current_stock_reservation_id)) {
+            $cart = $this->findCart($tenant, $identity);
+        }
+
+        if ($cart?->status === Cart::STATUS_EXPIRED) {
+            if (! $replaceExpired) {
+                throw new StockReservationExpiredException;
+            }
+
+            return $this->replaceExpiredCart($cart, $tenant, $identity);
+        }
+
+        if ($cart !== null) {
+            return $cart;
+        }
+
+        return null;
+    }
+
+    /**
+     * @param  array{user_id: ?int, guest_token: ?string}  $identity
+     */
+    protected function replaceExpiredCart(Cart $expiredCart, Tenant $tenant, array $identity): Cart
+    {
+        return DB::transaction(function () use ($expiredCart, $tenant, $identity): Cart {
+            /** @var Cart|null $lockedCart */
+            $lockedCart = Cart::query()->lockForUpdate()->find($expiredCart->getKey());
+
+            if ($lockedCart?->status === Cart::STATUS_EXPIRED) {
+                $lockedCart->update([
+                    'status' => Cart::STATUS_ABANDONED,
+                    'current_purchase_id' => null,
+                ]);
+            }
+
+            return $this->findCart($tenant, $identity)
+                ?? $this->createCart($tenant, $identity);
+        });
+    }
+
+    /**
+     * @param  array{user_id: ?int, guest_token: ?string}  $identity
+     */
+    protected function createCart(Tenant $tenant, array $identity): Cart
     {
         $attributes = [
             'tenant_codigo' => $tenant->codigo,
-            'status' => 'active',
+            'status' => Cart::STATUS_ACTIVE,
+            'origin' => Cart::ORIGIN_USER,
         ];
 
         if ($identity['user_id'] !== null) {

app/Domains/Commerce/Cart/Services/CartVariantReplacementService.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace App\Domains\Commerce\Cart\Services;
+
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Cart\Models\CartItem;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Services\CatalogInventoryService;
+use Illuminate\Validation\ValidationException;
+
+class CartVariantReplacementService
+{
+    public function __construct(private readonly CatalogInventoryService $inventory) {}
+
+    public function replaceHistoricalVariants(Cart $cart): void
+    {
+        $items = $cart->items()
+            ->whereNotNull('variant_id')
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+
+        foreach ($items as $item) {
+            $variant = Variant::query()->lockForUpdate()->find($item->variant_id);
+
+            if ($variant === null) {
+                throw $this->unavailableVariant();
+            }
+
+            $replacement = $this->latestReplacement($variant);
+
+            if ($replacement->is($variant)) {
+                if (! $variant->isSellable()) {
+                    throw $this->unavailableVariant();
+                }
+
+                continue;
+            }
+
+            if (! $replacement->isSellable()) {
+                throw $this->unavailableVariant();
+            }
+
+            /** @var CartItem|null $targetItem */
+            $targetItem = $cart->items()
+                ->whereKeyNot($item->getKey())
+                ->where('catalog_item_id', $item->catalog_item_id)
+                ->where('variant_id', $replacement->getKey())
+                ->lockForUpdate()
+                ->first();
+
+            $replacementQuantity = $item->cantidad + ($targetItem?->cantidad ?? 0);
+            if ($replacement->inventory_id !== $variant->inventory_id) {
+                $available = $this->inventory->availableQuantity($replacement);
+
+                if ($available !== null && $available < $replacementQuantity) {
+                    throw $this->unavailableVariant();
+                }
+            }
+
+            if ($targetItem !== null) {
+                $targetItem->cantidad += $item->cantidad;
+                $targetItem->save();
+                $item->delete();
+
+                continue;
+            }
+
+            $item->update(['variant_id' => $replacement->getKey()]);
+        }
+    }
+
+    private function latestReplacement(Variant $variant): Variant
+    {
+        $current = $variant;
+        $visited = [];
+
+        while ($current->replaced_by_variant_id !== null) {
+            if (isset($visited[$current->getKey()])) {
+                throw $this->unavailableVariant();
+            }
+
+            $visited[$current->getKey()] = true;
+            $current = Variant::query()
+                ->lockForUpdate()
+                ->find($current->replaced_by_variant_id)
+                ?? throw $this->unavailableVariant();
+        }
+
+        return $current;
+    }
+
+    private function unavailableVariant(): ValidationException
+    {
+        return ValidationException::withMessages([
+            'cart_id' => [__('api.cart.cart_variant_unavailable')],
+        ]);
+    }
+}

app/Domains/Commerce/Cart/Services/GuestCartMergeService.php

@@ -1,9 +1,9 @@
 <?php
 
-namespace App\Domains\Cart\Services;
+namespace App\Domains\Commerce\Cart\Services;
 
-use App\Domains\Auth\Models\User;
-use App\Domains\Cart\Models\Cart;
+use App\Domains\Core\Auth\Models\User;
+use App\Domains\Commerce\Cart\Models\Cart;
 use Illuminate\Support\Facades\DB;
 
 class GuestCartMergeService

app/Domains/Commerce/Cart/Services/InvalidateEventDateCartsService.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace App\Domains\Commerce\Cart\Services;
+
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Catalog\Models\StockReservation;
+use App\Domains\Commerce\Catalog\Services\StockReservationService;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Core\Tenant\Models\Tenant;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+
+class InvalidateEventDateCartsService
+{
+    public function __construct(private readonly StockReservationService $reservations) {}
+
+    /** @param Collection<int, int> $eventDateIds */
+    public function invalidate(
+        Tenant $tenant,
+        Collection $eventDateIds,
+        string $reason = StockReservationService::REASON_EVENT_DATE_RESCHEDULED,
+    ): void {
+        DB::transaction(function () use ($tenant, $eventDateIds, $reason): void {
+            $carts = Cart::query()
+                ->where('tenant_codigo', $tenant->codigo)
+                ->where('status', Cart::STATUS_ACTIVE)
+                ->whereNull('current_purchase_id')
+                ->whereHas('currentStockReservation', fn ($reservation) => $reservation
+                    ->where('status', StockReservation::STATUS_ACTIVE))
+                ->whereHas('items.variant', fn ($variant) => $variant
+                    ->withTrashed()
+                    ->where(fn ($dates) => $dates
+                        ->whereIn('event_date_id', $eventDateIds)
+                        ->orWhereHas('eventDates', fn ($date) => $date
+                            ->whereIn('event_dates.id', $eventDateIds))))
+                ->orderBy('id')
+                ->lockForUpdate()
+                ->get();
+
+            foreach ($carts as $cart) {
+                // Checkout keeps the cart and purchase attached to the same reservation.
+                if (Purchase::query()
+                    ->where('stock_reservation_id', $cart->current_stock_reservation_id)
+                    ->exists()) {
+                    continue;
+                }
+
+                $this->reservations->releaseCurrentCartReservation(
+                    $cart,
+                    $reason,
+                );
+
+                // Reuse the existing expired-cart flow: stale mutations receive the
+                // expiration response and the next GET replaces the whole cart.
+                $cart->update(['status' => Cart::STATUS_EXPIRED]);
+            }
+        });
+    }
+}

app/Domains/Commerce/Cart/documentacion/README.md

@@ -6,13 +6,12 @@ Gestiona el carrito activo de un tenant tanto para visitantes como para usuarios
 
 ## Modelo
 
-- `Cart`: pertenece a un tenant y opcionalmente a un usuario; calcula el total y permite agregar, actualizar o quitar ítems.
+- `Cart`: pertenece a un tenant y opcionalmente a un usuario; calcula el total, permite agregar, actualizar o quitar ítems y apunta a su reserva de stock vigente mediante `current_stock_reservation_id`.
 - `CartItem`: referencia un `CatalogItem` y, opcionalmente, una `Variant`; sólo persiste la selección y cantidad, y expone siempre los datos vigentes del catálogo.
 
 ## Servicios
 
 - `CartService`: obtiene el carrito, modifica ítems y administra la cookie del token invitado.
-- `ExpireCartReservationsService`: libera las reservas vencidas de carritos activos y elimina los carritos que quedan vacíos.
 - `GuestCartMergeService`: incorpora el carrito invitado al usuario cuando este se autentica.
 
 ## Endpoints
@@ -34,4 +33,6 @@ Depende de `Catalog` para productos y variantes, de `Tenant` para aislar datos y
 
 Un carrito puede pasar a `checkout`. Las compras directas usan un carrito técnico con `origin=direct_checkout`; los carritos normales conservan `origin=user` y pueden restaurarse al cancelar o vencer la compra.
 
-El comando unificado `php artisan reservations:expire` procesa primero las compras vencidas y luego las reservas activas sin compra cuyo `expires_at` haya vencido. Se ejecuta cada minuto mediante el scheduler, conserva la fila de reserva con estado `expired`, elimina el ítem abandonado y elimina lógicamente el carrito cuando queda vacío. Cada intento registra sus resultados o su error en el log diario `storage/logs/commands/commands-AAAA-MM-DD.log`.
+Cada edición sincroniza una única reserva para el carrito completo. Si varios ítems o bundles consumen el mismo inventario, se persiste una sola línea con la cantidad agregada. Al editar durante checkout, la compra anterior queda `superseded`, se desvincula y el carrito conserva la misma reserva activa con sus líneas actualizadas.
+
+El comando unificado `php artisan reservations:expire` recorre una sola vez las reservas activas cuyo `expires_at` haya vencido. Cuando pertenecen a un carrito, conserva la reserva y sus líneas como historial, libera el stock como conjunto y cambia el carrito asociado a `expired` sin eliminar sus ítems. Al volver a resolver ese carrito desde la API, el anterior pasa automáticamente a `abandoned` y se crea uno activo y vacío para la misma identidad. El cliente nunca necesita reiniciarlo explícitamente. La API también materializa este vencimiento al acceder al carrito aunque el comando programado todavía no haya corrido.

app/Domains/Commerce/Cart/routes/api.php

@@ -1,6 +1,6 @@
 <?php
 
-use App\Domains\Cart\Controllers\CartController;
+use App\Domains\Commerce\Cart\Controllers\CartController;
 use Illuminate\Support\Facades\Route;
 
 Route::prefix('tenants/{tenant:codigo}')
@@ -10,10 +10,3 @@ Route::prefix('tenants/{tenant:codigo}')
         Route::patch('cart/items/{cartItem}', [CartController::class, 'updateItemQuantity']);
         Route::delete('cart/items/{cartItem}', [CartController::class, 'removeItem']);
     });
-
-Route::prefix('tenants/{tenant:codigo}')
-    ->middleware('auth:sanctum')
-    ->group(function (): void {
-        Route::patch('checkout-carts/{cart}/items/{cartItem}', [CartController::class, 'updateCheckoutItem'])->withTrashed();
-        Route::delete('checkout-carts/{cart}/items/{cartItem}', [CartController::class, 'removeCheckoutItem'])->withTrashed();
-    });

app/Domains/Commerce/Catalog/Controllers/AdminApp/OnTicketFeaturedGroupController.php

@@ -1,12 +1,12 @@
 <?php
 
-namespace App\Domains\Catalog\Controllers\AdminApp;
+namespace App\Domains\Commerce\Catalog\Controllers\AdminApp;
 
-use App\Domains\Catalog\Models\FeaturedGroup;
-use App\Domains\Catalog\Requests\AdminApp\UpsertOnTicketFeaturedGroupRequest;
-use App\Domains\Catalog\Resources\AdminApp\OnTicketFeaturedGroupResource;
-use App\Domains\Catalog\Services\OnTicketFeaturedGroupService;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Commerce\Catalog\Models\FeaturedGroup;
+use App\Domains\Commerce\Catalog\Requests\AdminApp\UpsertOnTicketFeaturedGroupRequest;
+use App\Domains\Commerce\Catalog\Resources\AdminApp\OnTicketFeaturedGroupResource;
+use App\Domains\Commerce\Catalog\Services\OnTicketFeaturedGroupService;
+use App\Domains\Core\Tenant\Models\Tenant;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
@@ -58,7 +58,7 @@ class OnTicketFeaturedGroupController extends Controller
     {
         $tenant = $request->user()->tenant()->firstOrFail();
 
-        abort_unless($tenant->website_type_code === 'onticket', 404);
+        abort_unless(in_array($tenant->storefront_website_type_code, ['onticket', 'onticket_multi_event'], true), 404);
 
         return $tenant;
     }

app/Domains/Commerce/Catalog/Controllers/CatalogController.php

@@ -1,27 +1,25 @@
 <?php
 
-namespace App\Domains\Catalog\Controllers;
+namespace App\Domains\Commerce\Catalog\Controllers;
 
-use App\Domains\Cart\Services\CartService;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\Category;
-use App\Domains\Catalog\Models\FeaturedGroup;
-use App\Domains\Catalog\Requests\CatalogItemDetailRequest;
-use App\Domains\Catalog\Requests\CatalogVariantOptionsRequest;
-use App\Domains\Catalog\Requests\CategoryPageRequest;
-use App\Domains\Catalog\Requests\FeaturedGroupPageRequest;
-use App\Domains\Catalog\Requests\SearchCatalogItemsRequest;
-use App\Domains\Catalog\Requests\StoreCatalogItemRequest;
-use App\Domains\Catalog\Resources\CatalogFeaturedGroupResource;
-use App\Domains\Catalog\Resources\CatalogItemDetailResource;
-use App\Domains\Catalog\Resources\CatalogItemResource;
-use App\Domains\Catalog\Resources\CatalogSearchItemResource;
-use App\Domains\Catalog\Resources\CatalogVariantOptionsResource;
-use App\Domains\Catalog\Services\CatalogItemAllowanceService;
-use App\Domains\Catalog\Services\CatalogService;
-use App\Domains\Catalog\Services\FeaturedGroupService;
-use App\Domains\Catalog\Services\VariantSelectionService;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Commerce\Cart\Services\CartService;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Category;
+use App\Domains\Commerce\Catalog\Models\FeaturedGroup;
+use App\Domains\Commerce\Catalog\Requests\CatalogItemDetailRequest;
+use App\Domains\Commerce\Catalog\Requests\CatalogVariantOptionsRequest;
+use App\Domains\Commerce\Catalog\Requests\CategoryPageRequest;
+use App\Domains\Commerce\Catalog\Requests\FeaturedGroupPageRequest;
+use App\Domains\Commerce\Catalog\Requests\SearchCatalogItemsRequest;
+use App\Domains\Commerce\Catalog\Resources\CatalogFeaturedGroupResource;
+use App\Domains\Commerce\Catalog\Resources\CatalogItemDetailResource;
+use App\Domains\Commerce\Catalog\Resources\CatalogSearchItemResource;
+use App\Domains\Commerce\Catalog\Resources\CatalogVariantOptionsResource;
+use App\Domains\Commerce\Catalog\Services\CatalogItemAllowanceService;
+use App\Domains\Commerce\Catalog\Services\CatalogService;
+use App\Domains\Commerce\Catalog\Services\FeaturedGroupService;
+use App\Domains\Commerce\Catalog\Services\VariantSelectionService;
+use App\Domains\Core\Tenant\Models\Tenant;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
@@ -40,7 +38,7 @@ class CatalogController extends Controller
         return response()->json($featuredGroups->map(
             fn (FeaturedGroup $featuredGroup): array => (new CatalogFeaturedGroupResource(
                 $featuredGroup,
-                $featuredGroupService->itemsResponse($featuredGroup, 1, $this->userId($request)),
+                $featuredGroupService->itemsResponse($featuredGroup, $tenant, 1, $this->userId($request)),
             ))->resolve()
         ));
     }
@@ -102,6 +100,7 @@ class CatalogController extends Controller
 
         return response()->json($featuredGroupService->itemsResponse(
             $featuredGroup,
+            $tenant,
             $page,
             $this->userId($request),
         ));
@@ -114,7 +113,8 @@ class CatalogController extends Controller
         CatalogService $catalogService,
         CatalogItemAllowanceService $allowances,
     ): CatalogItemDetailResource {
-        abort_unless($catalogItem->tenant_code === $tenant->codigo, 404);
+        abort_unless($catalogItem->tenant_code === $tenant->codigo
+            && ($tenant->active_event_id === null || $catalogItem->event_id === $tenant->active_event_id), 404);
 
         $variantId = $request->validated('variant_id');
 
@@ -134,7 +134,8 @@ class CatalogController extends Controller
         VariantSelectionService $variantSelectionService,
         CartService $cartService,
     ): CatalogVariantOptionsResource {
-        abort_unless($catalogItem->tenant_code === $tenant->codigo, 404);
+        abort_unless($catalogItem->tenant_code === $tenant->codigo
+            && ($tenant->active_event_id === null || $catalogItem->event_id === $tenant->active_event_id), 404);
 
         $includedVariantId = null;
         $cartItemId = $request->validated('cart_item_id');
@@ -163,21 +164,6 @@ class CatalogController extends Controller
         );
     }
 
-    public function store(
-        StoreCatalogItemRequest $request,
-        Tenant $tenant,
-        CatalogService $catalogService,
-    ): JsonResponse {
-        $catalogItem = $catalogService->create([
-            ...$request->validated(),
-            'tenant_code' => $tenant->codigo,
-        ]);
-
-        return CatalogItemResource::make($catalogItem)
-            ->response()
-            ->setStatusCode(201);
-    }
-
     private function userId(Request $request): ?int
     {
         $userId = $request->user()?->getAuthIdentifier() ?? Auth::guard('sanctum')->id();

app/Domains/Commerce/Catalog/Enums/CatalogItemType.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Enums;
+namespace App\Domains\Commerce\Catalog\Enums;
 
 enum CatalogItemType: string
 {

app/Domains/Commerce/Catalog/Enums/FeaturedGroupSource.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Enums;
+namespace App\Domains\Commerce\Catalog\Enums;
 
 enum FeaturedGroupSource: string
 {

app/Domains/Commerce/Catalog/Enums/GroupLayout.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Enums;
+namespace App\Domains\Commerce\Catalog\Enums;
 
 enum GroupLayout: string
 {

app/Domains/Commerce/Catalog/Enums/InventoryPolicy.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Enums;
+namespace App\Domains\Commerce\Catalog\Enums;
 
 enum InventoryPolicy: string
 {

app/Domains/Commerce/Catalog/Enums/InventorySubject.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Enums;
+namespace App\Domains\Commerce\Catalog\Enums;
 
 enum InventorySubject: string
 {

app/Domains/Commerce/Catalog/Enums/ProductLayout.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Enums;
+namespace App\Domains\Commerce\Catalog\Enums;
 
 enum ProductLayout: string
 {

app/Domains/Commerce/Catalog/Exceptions/StockReservationExpiredException.php

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

app/Domains/Commerce/Catalog/Models/Attribute.php

@@ -1,10 +1,10 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
-use App\Domains\Event\Models\EventDate;
-use App\Domains\Shared\Enums\FieldType;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticketing\Event\Models\EventDate;
+use App\Shared\Enums\FieldType;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
@@ -59,6 +59,8 @@ class Attribute extends Model
     public function eventDates(): HasMany
     {
         return $this->hasMany(EventDate::class, 'tenant_code', 'tenant_codigo')
+            ->whereNull('rescheduled_to_event_date_id')
+            ->whereNull('suspended_at')
             ->orderBy('date')
             ->orderBy('time_start');
     }

app/Domains/Commerce/Catalog/Models/AttributeOption.php

@@ -1,8 +1,8 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
-use App\Domains\Ticket\Models\ValidityTime;
+use App\Domains\Ticketing\Ticket\Models\ValidityTime;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;

app/Domains/Commerce/Catalog/Models/Brand.php

@@ -1,8 +1,8 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;

app/Domains/Commerce/Catalog/Models/BundleComponent.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;

app/Domains/Commerce/Catalog/Models/CatalogItem.php

@@ -1,14 +1,15 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
-use App\Domains\Attachable\Models\Attachment;
-use App\Domains\Catalog\Enums\CatalogItemType;
-use App\Domains\Catalog\Enums\InventoryPolicy;
-use App\Domains\Catalog\Enums\InventorySubject;
-use App\Domains\Catalog\Services\CatalogInventoryService;
-use App\Domains\Tenant\Models\Tenant;
-use App\Domains\Ticket\Models\Ticket;
+use App\Shared\Attachable\Models\Attachment;
+use App\Domains\Commerce\Catalog\Enums\CatalogItemType;
+use App\Domains\Commerce\Catalog\Enums\InventoryPolicy;
+use App\Domains\Commerce\Catalog\Enums\InventorySubject;
+use App\Domains\Commerce\Catalog\Services\CatalogInventoryService;
+use App\Domains\Core\Tenant\Models\Tenant;
+use App\Domains\Ticketing\Event\Models\Event;
+use App\Domains\Ticketing\Ticket\Models\Ticket;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
@@ -27,8 +28,10 @@ use Illuminate\Support\Collection;
     'type',
     'slug',
     'nombre',
+    'group_order',
     'descripcion',
     'precio',
+    'sales_end_at',
     'inventory_policy',
     'inventory_subject',
     'max_units_per_user',
@@ -47,16 +50,33 @@ class CatalogItem extends Model
         'inventory_policy' => InventoryPolicy::Tracked->value,
         'inventory_subject' => InventorySubject::Product->value,
         'has_tickets' => false,
+        'group_order' => 0,
     ];
 
+    protected static function booted(): void
+    {
+        static::creating(function (CatalogItem $item): void {
+            if ($item->event_id !== null || $item->tenant_code === null) {
+                return;
+            }
+
+            $item->event_id = Tenant::query()
+                ->where('codigo', $item->tenant_code)
+                ->value('active_event_id');
+        });
+    }
+
     protected function casts(): array
     {
         return [
+            'event_id' => 'integer',
             'category_id' => 'integer',
             'brand_id' => 'integer',
             'inventory_id' => 'integer',
             'type' => CatalogItemType::class,
+            'group_order' => 'integer',
             'precio' => 'decimal:2',
+            'sales_end_at' => 'datetime',
             'inventory_policy' => InventoryPolicy::class,
             'inventory_subject' => InventorySubject::class,
             'max_units_per_user' => 'integer',
@@ -70,6 +90,21 @@ class CatalogItem extends Model
         return $this->belongsTo(Tenant::class, 'tenant_code', 'codigo');
     }
 
+    /** @return BelongsTo<Event, $this> */
+    public function event(): BelongsTo
+    {
+        return $this->belongsTo(Event::class);
+    }
+
+    /** @param Builder<CatalogItem> $query */
+    public function scopeForTenantCatalog(Builder $query, Tenant $tenant): Builder
+    {
+        return $query
+            ->where('catalog_items.tenant_code', $tenant->codigo)
+            ->when($tenant->active_event_id !== null, fn (Builder $query): Builder => $query
+                ->where('catalog_items.event_id', $tenant->active_event_id));
+    }
+
     /** @return BelongsTo<Category, $this> */
     public function category(): BelongsTo
     {
@@ -158,6 +193,10 @@ class CatalogItem extends Model
 
     public function isAvailable(): bool
     {
+        if (! $this->isSaleOpen()) {
+            return false;
+        }
+
         if ($this->type === CatalogItemType::Bundle) {
             $availableStock = $this->availableStock();
 
@@ -172,27 +211,67 @@ class CatalogItem extends Model
     }
 
     /** @param Builder<CatalogItem> $query */
-    public function scopeWhereVariantsAvailable(Builder $query): Builder
+    public function scopeWhereAvailable(Builder $query): Builder
     {
         return $query->where(function (Builder $query): void {
+            $query->whereNull('catalog_items.sales_end_at')
+                ->orWhere('catalog_items.sales_end_at', '>', now());
+        })->where(function (Builder $query): void {
             $query
-                ->whereDoesntHave('variants')
-                ->orWhere('catalog_items.inventory_policy', InventoryPolicy::Unlimited->value)
+                ->where(function (Builder $unlimitedQuery): void {
+                    $unlimitedQuery
+                        ->where('catalog_items.inventory_policy', InventoryPolicy::Unlimited->value)
+                        ->where(function (Builder $selectionQuery): void {
+                            $selectionQuery
+                                ->whereDoesntHave('variants')
+                                ->orWhereHas('variants', fn (Builder $variantQuery): Builder => $variantQuery
+                                    ->whereNull('sales_disabled_at')
+                                    ->whereNull('replaced_by_variant_id'));
+                        });
+                })
                 ->orWhereHas(
-                    'variants.inventory',
-                    fn (Builder $inventoryQuery): Builder => $inventoryQuery
-                        ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock')
-                );
+                    'variants',
+                    fn (Builder $variantQuery): Builder => $variantQuery
+                        ->whereNull('sales_disabled_at')
+                        ->whereNull('replaced_by_variant_id')
+                        ->whereHas(
+                            'inventory',
+                            fn (Builder $inventoryQuery): Builder => $inventoryQuery
+                                ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock')
+                        )
+                )
+                ->orWhere(function (Builder $directItemQuery): void {
+                    $directItemQuery
+                        ->whereDoesntHave('variants')
+                        ->where(function (Builder $inventoryQuery): void {
+                            $inventoryQuery
+                                ->whereNull('catalog_items.inventory_id')
+                                ->orWhereHas(
+                                    'inventory',
+                                    fn (Builder $availableInventoryQuery): Builder => $availableInventoryQuery
+                                        ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock')
+                                );
+                        });
+                });
         });
     }
 
+    public function isSaleOpen(): bool
+    {
+        return $this->sales_end_at === null || now()->lt($this->sales_end_at);
+    }
+
     /** @return Collection<int, Variant> */
     public function visibleVariants(?int $includedVariantId = null): Collection
     {
         return $this->variants
-            ->filter(fn (Variant $variant): bool => ($includedVariantId !== null && $variant->id === $includedVariantId)
-                || $this->inventory_policy === InventoryPolicy::Unlimited
-                || ($variant->inventory?->availableStock() ?? 0) > 0)
+            ->each(fn (Variant $variant) => $variant->setRelation('catalogItem', $this))
+            ->filter(fn (Variant $variant): bool => $variant->hasOnlyActiveEventDates()
+                && (($includedVariantId !== null && $variant->id === $includedVariantId)
+                    || ($variant->isSellable() && (
+                        $this->inventory_policy === InventoryPolicy::Unlimited
+                        || ($variant->inventory?->availableStock() ?? 0) > 0
+                    ))))
             ->values();
     }
 

app/Domains/Commerce/Catalog/Models/Category.php

@@ -1,9 +1,9 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
-use App\Domains\Auth\Models\User;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Core\Auth\Models\User;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
@@ -15,6 +15,7 @@ use Illuminate\Database\Eloquent\Relations\HasMany;
     'tenant_code',
     'categoria_id',
     'nombre',
+    'is_enabled',
 ])]
 class Category extends Model
 {
@@ -22,6 +23,10 @@ class Category extends Model
 
     protected $table = 'categorias';
 
+    protected $attributes = [
+        'is_enabled' => true,
+    ];
+
     /**
      * @return array<string, string>
      */
@@ -29,6 +34,7 @@ class Category extends Model
     {
         return [
             'categoria_id' => 'integer',
+            'is_enabled' => 'boolean',
         ];
     }
 

app/Domains/Commerce/Catalog/Models/FeaturedGroup.php

@@ -1,11 +1,11 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
-use App\Domains\Catalog\Enums\FeaturedGroupSource;
-use App\Domains\Catalog\Enums\GroupLayout;
-use App\Domains\Catalog\Enums\ProductLayout;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Commerce\Catalog\Enums\FeaturedGroupSource;
+use App\Domains\Commerce\Catalog\Enums\GroupLayout;
+use App\Domains\Commerce\Catalog\Enums\ProductLayout;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;

app/Domains/Commerce/Catalog/Models/FeaturedItem.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;

app/Domains/Commerce/Catalog/Models/Inventory.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
@@ -10,6 +10,7 @@ use Illuminate\Database\Eloquent\Relations\HasOne;
 
 #[Fillable([
     'sold_units',
+    'refunded_units',
     'reserved_stock',
     'real_stock',
 ])]
@@ -23,6 +24,7 @@ class Inventory extends Model
 
     protected $attributes = [
         'sold_units' => 0,
+        'refunded_units' => 0,
         'reserved_stock' => 0,
         'real_stock' => 0,
     ];
@@ -31,6 +33,7 @@ class Inventory extends Model
     {
         return [
             'sold_units' => 'integer',
+            'refunded_units' => 'integer',
             'reserved_stock' => 'integer',
             'real_stock' => 'integer',
         ];
@@ -42,16 +45,16 @@ class Inventory extends Model
         return $this->hasOne(CatalogItem::class);
     }
 
-    /** @return HasOne<Variant, $this> */
-    public function variant(): HasOne
+    /** @return HasMany<Variant, $this> */
+    public function variants(): HasMany
     {
-        return $this->hasOne(Variant::class);
+        return $this->hasMany(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/Commerce/Catalog/Models/ItemAttribute.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;

app/Domains/Commerce/Catalog/Models/StockReservation.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Domains\Commerce\Catalog\Models;
+
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasOne;
+
+#[Fillable([
+    'status',
+    'expires_at',
+    'committed_at',
+    'released_at',
+    'expired_at',
+    'release_reason',
+])]
+class StockReservation extends Model
+{
+    public const STATUS_ACTIVE = 'active';
+
+    public const STATUS_COMMITTED = 'committed';
+
+    public const STATUS_RELEASED = 'released';
+
+    public const STATUS_EXPIRED = 'expired';
+
+    protected function casts(): array
+    {
+        return [
+            'expires_at' => 'datetime',
+            'committed_at' => 'datetime',
+            'released_at' => 'datetime',
+            'expired_at' => 'datetime',
+        ];
+    }
+
+    /** @return HasMany<StockReservationLine, $this> */
+    public function lines(): HasMany
+    {
+        return $this->hasMany(StockReservationLine::class);
+    }
+
+    /** @return HasOne<Cart, $this> */
+    public function currentCart(): HasOne
+    {
+        return $this->hasOne(Cart::class, 'current_stock_reservation_id');
+    }
+
+    /** @return HasOne<Purchase, $this> */
+    public function purchase(): HasOne
+    {
+        return $this->hasOne(Purchase::class);
+    }
+}

app/Domains/Commerce/Catalog/Models/StockReservationLine.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Domains\Commerce\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/Commerce/Catalog/Models/Variant.php

@@ -1,10 +1,10 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
-use App\Domains\Attachable\Models\Attachment;
-use App\Domains\Event\Models\EventDate;
-use App\Domains\Ticket\Models\Ticket;
+use App\Shared\Attachable\Models\Attachment;
+use App\Domains\Ticketing\Event\Models\EventDate;
+use App\Domains\Ticketing\Ticket\Models\Ticket;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
@@ -20,6 +20,8 @@ use Illuminate\Support\Str;
     'catalog_item_id',
     'event_date_id',
     'inventory_id',
+    'replaced_by_variant_id',
+    'sales_disabled_at',
     'descripcion',
     'precio',
 ])]
@@ -37,6 +39,8 @@ class Variant extends Model
             'catalog_item_id' => 'integer',
             'event_date_id' => 'integer',
             'inventory_id' => 'integer',
+            'replaced_by_variant_id' => 'integer',
+            'sales_disabled_at' => 'datetime',
             'precio' => 'decimal:2',
         ];
     }
@@ -76,6 +80,40 @@ class Variant extends Model
         return $this->belongsTo(Inventory::class);
     }
 
+    /** @return BelongsTo<Variant, $this> */
+    public function replacement(): BelongsTo
+    {
+        return $this->belongsTo(self::class, 'replaced_by_variant_id');
+    }
+
+    /** @return HasMany<Variant, $this> */
+    public function replacedVariants(): HasMany
+    {
+        return $this->hasMany(self::class, 'replaced_by_variant_id');
+    }
+
+    public function isSellable(): bool
+    {
+        return $this->sales_disabled_at === null
+            && $this->replaced_by_variant_id === null
+            && $this->catalogItem->isSaleOpen()
+            && $this->hasOnlyActiveEventDates();
+    }
+
+    public function hasOnlyActiveEventDates(): bool
+    {
+        if (! $this->exists
+            && $this->event_date_id === null
+            && ! $this->relationLoaded('eventDates')) {
+            return true;
+        }
+
+        return $this->selectedEventDates()->every(
+            fn (EventDate $eventDate): bool => $eventDate->rescheduled_to_event_date_id === null
+                && $eventDate->suspended_at === null,
+        );
+    }
+
     /** @return HasMany<VariantDefinition, $this> */
     public function definitions(): HasMany
     {

app/Domains/Commerce/Catalog/Models/VariantDefinition.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Models;
+namespace App\Domains\Commerce\Catalog\Models;
 
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;

app/Domains/Commerce/Catalog/Requests/AdminApp/UpsertOnTicketFeaturedGroupRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Requests\AdminApp;
+namespace App\Domains\Commerce\Catalog\Requests\AdminApp;
 
 use Illuminate\Foundation\Http\FormRequest;
 

app/Domains/Commerce/Catalog/Requests/CatalogItemDetailRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Requests;
+namespace App\Domains\Commerce\Catalog\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 

app/Domains/Commerce/Catalog/Requests/CatalogVariantOptionsRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Requests;
+namespace App\Domains\Commerce\Catalog\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 

app/Domains/Commerce/Catalog/Requests/CategoryPageRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Requests;
+namespace App\Domains\Commerce\Catalog\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 

app/Domains/Commerce/Catalog/Requests/FeaturedGroupPageRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Requests;
+namespace App\Domains\Commerce\Catalog\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 

app/Domains/Commerce/Catalog/Requests/SearchCatalogItemsRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Requests;
+namespace App\Domains\Commerce\Catalog\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 

app/Domains/Commerce/Catalog/Resources/AdminApp/OnTicketFeaturedGroupResource.php

@@ -1,9 +1,9 @@
 <?php
 
-namespace App\Domains\Catalog\Resources\AdminApp;
+namespace App\Domains\Commerce\Catalog\Resources\AdminApp;
 
-use App\Domains\Catalog\Enums\ProductLayout;
-use App\Domains\Catalog\Models\FeaturedGroup;
+use App\Domains\Commerce\Catalog\Enums\ProductLayout;
+use App\Domains\Commerce\Catalog\Models\FeaturedGroup;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 

app/Domains/Commerce/Catalog/Resources/CatalogFeaturedGroupResource.php

@@ -1,8 +1,8 @@
 <?php
 
-namespace App\Domains\Catalog\Resources;
+namespace App\Domains\Commerce\Catalog\Resources;
 
-use App\Domains\Catalog\Models\FeaturedGroup;
+use App\Domains\Commerce\Catalog\Models\FeaturedGroup;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 

app/Domains/Commerce/Catalog/Resources/CatalogFeaturedItemResource.php

@@ -0,0 +1,136 @@
+<?php
+
+namespace App\Domains\Commerce\Catalog\Resources;
+
+use App\Domains\Commerce\Catalog\Enums\InventoryPolicy;
+use App\Domains\Commerce\Catalog\Enums\ProductLayout;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\FeaturedGroup;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Services\CatalogItemAllowanceService;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin CatalogItem */
+class CatalogFeaturedItemResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        $catalogItem = $this->resource;
+        /** @var FeaturedGroup $featuredGroup */
+        $featuredGroup = $catalogItem->getRelation('featuredGroup');
+
+        if ($featuredGroup->product_layout === ProductLayout::ColumnWithImage) {
+            return $this->columnWithImageData($catalogItem);
+        }
+
+        if ($featuredGroup->product_layout === ProductLayout::TicketSelector) {
+            return $this->ticketSelectorData($catalogItem);
+        }
+
+        $remainingUserQuota = $catalogItem->getAttribute('remaining_user_quota');
+        $availableStock = $catalogItem->availableStock();
+
+        $data = [
+            'id' => $catalogItem->id,
+            'type' => $catalogItem->type->value,
+            'nombre' => $catalogItem->nombre,
+            'descripcion' => $catalogItem->descripcion,
+            'precio' => $catalogItem->precio,
+            'maximum_addable_quantity' => $this->maximumAddable(
+                $availableStock,
+                $remainingUserQuota,
+            ),
+            'unavailable_message' => $this->unavailableMessage(
+                $availableStock,
+                $remainingUserQuota,
+            ),
+            'variants' => $catalogItem->visibleVariants()
+                ->map(function (Variant $variant) use ($catalogItem, $remainingUserQuota): array {
+                    $variantStock = $catalogItem->inventory_policy === InventoryPolicy::Unlimited
+                        ? null
+                        : $variant->inventory->availableStock();
+
+                    return [
+                        'id' => $variant->id,
+                        'event_date_id' => $variant->event_date_id,
+                        'event_date' => $variant->eventDate?->date?->format('Y-m-d'),
+                        'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
+                        'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
+                        'descripcion' => $variant->getDescription(),
+                        'precio' => number_format($variant->getPrice(), 2, '.', ''),
+                        'maximum_addable_quantity' => $this->maximumAddable(
+                            $variantStock,
+                            $remainingUserQuota,
+                        ),
+                        'unavailable_message' => $this->unavailableMessage(
+                            $variantStock,
+                            $remainingUserQuota,
+                        ),
+                        'values' => $variant->selectorOptions($catalogItem->itemAttributes),
+                    ];
+                })
+                ->values(),
+        ];
+
+        return $data;
+    }
+
+    /** @return array<string, mixed> */
+    private function ticketSelectorData(CatalogItem $catalogItem): array
+    {
+        $availableStock = $catalogItem->availableStock();
+        $remainingUserQuota = $catalogItem->getAttribute('remaining_user_quota');
+
+        return [
+            'id' => $catalogItem->id,
+            'type' => $catalogItem->type->value,
+            'nombre' => $catalogItem->nombre,
+            'descripcion' => $catalogItem->descripcion,
+            'precio' => $catalogItem->precio,
+            'image' => $this->firstImageUrl($catalogItem),
+            'maximum_addable_quantity' => $this->maximumAddable($availableStock, $remainingUserQuota),
+            'unavailable_message' => $this->unavailableMessage($availableStock, $remainingUserQuota),
+        ];
+    }
+
+    /** @return array<string, mixed> */
+    private function columnWithImageData(CatalogItem $catalogItem): array
+    {
+        $availableStock = $catalogItem->availableStock();
+        $remainingUserQuota = $catalogItem->getAttribute('remaining_user_quota');
+
+        return [
+            'id' => $catalogItem->id,
+            'type' => $catalogItem->type->value,
+            'nombre' => $catalogItem->nombre,
+            'precio' => $catalogItem->precio,
+            'image' => $this->firstImageUrl($catalogItem),
+            'maximum_addable_quantity' => $this->maximumAddable($availableStock, $remainingUserQuota),
+            'unavailable_message' => $this->unavailableMessage($availableStock, $remainingUserQuota),
+        ];
+    }
+
+    private function firstImageUrl(CatalogItem $catalogItem): ?string
+    {
+        $attachment = $catalogItem->attachments->first()
+            ?? $catalogItem->visibleVariants()
+                ->flatMap(fn (Variant $variant) => $variant->attachments)
+                ->first();
+
+        return $attachment?->getTemporaryUrl(1440);
+    }
+
+    private function maximumAddable(?int $stock, ?int $remainingUserQuota): ?int
+    {
+        return app(CatalogItemAllowanceService::class)
+            ->maximumAddableQuantity($stock, $remainingUserQuota);
+    }
+
+    private function unavailableMessage(?int $stock, ?int $remainingUserQuota): ?string
+    {
+        return app(CatalogItemAllowanceService::class)
+            ->unavailableMessage($stock, $remainingUserQuota);
+    }
+}

app/Domains/Commerce/Catalog/Resources/CatalogItemDetailResource.php

@@ -1,14 +1,14 @@
 <?php
 
-namespace App\Domains\Catalog\Resources;
+namespace App\Domains\Commerce\Catalog\Resources;
 
-use App\Domains\Catalog\Enums\InventoryPolicy;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\ItemAttribute;
-use App\Domains\Catalog\Models\Variant;
-use App\Domains\Catalog\Services\CatalogItemAllowanceService;
-use App\Domains\Shared\Enums\FieldType;
-use App\Domains\Ticket\Resources\ValidityTimeResource;
+use App\Domains\Commerce\Catalog\Enums\InventoryPolicy;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\ItemAttribute;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Services\CatalogItemAllowanceService;
+use App\Domains\Ticketing\Ticket\Resources\ValidityTimeResource;
+use App\Shared\Enums\FieldType;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 use Illuminate\Support\Collection;
@@ -42,11 +42,15 @@ class CatalogItemDetailResource extends JsonResource
                 $selectedVariant === null,
                 fn () => $this->maximumAddable($this->availableStock()),
             ),
+            'unavailable_message' => $this->when(
+                $selectedVariant === null,
+                fn () => $this->unavailableMessage($this->availableStock()),
+            ),
             'images' => $this->when(
                 $selectedVariant === null,
                 fn () => $this->imageUrls($this->attachments),
             ),
-            'variants' => $this->visibleVariants()
+            'variants' => $this->variants
                 ->map(fn (Variant $variant): array => $this->variantData($variant))
                 ->values(),
             'selected_variant' => $this->when(
@@ -136,7 +140,7 @@ class CatalogItemDetailResource extends JsonResource
                 'validity_time_id' => $option->validity_time_id,
                 'validity_time' => $option->validityTime === null
                     ? null
-                    : ValidityTimeResource::make($option->validityTime),
+                    : ValidityTimeResource::make($option->validityTime, $this->tenant->timezone),
                 'metadata' => $option->metadata,
             ])
             ->values();
@@ -159,6 +163,7 @@ class CatalogItemDetailResource extends JsonResource
     {
         $values = $variant->selectionOptions($this->itemAttributes);
         $eventDates = $variant->selectedEventDates();
+        $variantStock = $this->variantStock($variant);
 
         return [
             'id' => $variant->id,
@@ -168,7 +173,8 @@ class CatalogItemDetailResource extends JsonResource
             'event_dates' => $eventDates->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
             'descripcion' => $variant->getDescription(),
             'precio' => number_format($variant->getPrice(), 2, '.', ''),
-            'maximum_addable_quantity' => $this->maximumAddable($this->variantStock($variant)),
+            'maximum_addable_quantity' => $this->maximumAddable($variantStock),
+            'unavailable_message' => $this->unavailableMessage($variantStock),
             'values' => $values,
         ];
     }
@@ -195,4 +201,12 @@ class CatalogItemDetailResource extends JsonResource
             $this->getAttribute('remaining_user_quota'),
         );
     }
+
+    private function unavailableMessage(?int $stock): ?string
+    {
+        return app(CatalogItemAllowanceService::class)->unavailableMessage(
+            $stock,
+            $this->getAttribute('remaining_user_quota'),
+        );
+    }
 }

app/Domains/Commerce/Catalog/Resources/CatalogSearchItemResource.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Domains\Commerce\Catalog\Resources;
+
+use App\Domains\Commerce\Catalog\Enums\InventoryPolicy;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Services\CatalogItemAllowanceService;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin CatalogItem */
+class CatalogSearchItemResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        $availableStock = $this->availableStock();
+        $visibleVariants = $this->visibleVariants();
+        $attachment = $this->attachments->first()
+            ?? $visibleVariants
+                ->flatMap(fn (Variant $variant) => $variant->attachments)
+                ->first();
+
+        return [
+            'id' => $this->id,
+            'type' => $this->type->value,
+            'nombre' => $this->nombre,
+            'descripcion' => $this->descripcion,
+            'precio' => $this->precio,
+            'image' => $attachment?->getTemporaryUrl(1440),
+            'maximum_addable_quantity' => $this->maximumAddable($availableStock),
+            'unavailable_message' => $this->unavailableMessage($availableStock),
+            'variants' => $visibleVariants
+                ->map(function (Variant $variant): array {
+                    $variantStock = $this->inventory_policy === InventoryPolicy::Unlimited
+                        ? null
+                        : $variant->inventory?->availableStock();
+
+                    return [
+                        'id' => $variant->id,
+                        'event_date_id' => $variant->event_date_id,
+                        'event_date' => $variant->eventDate?->date?->format('Y-m-d'),
+                        'event_date_ids' => $variant->selectedEventDates()->pluck('id')->values(),
+                        'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
+                        'descripcion' => $variant->getDescription(),
+                        'precio' => number_format($variant->getPrice(), 2, '.', ''),
+                        'maximum_addable_quantity' => $this->maximumAddable($variantStock),
+                        'unavailable_message' => $this->unavailableMessage($variantStock),
+                        'values' => $variant->selectorOptions($this->itemAttributes),
+                    ];
+                })
+                ->values(),
+        ];
+    }
+
+    private function maximumAddable(?int $stock): ?int
+    {
+        return app(CatalogItemAllowanceService::class)->maximumAddableQuantity(
+            $stock,
+            $this->getAttribute('remaining_user_quota'),
+        );
+    }
+
+    private function unavailableMessage(?int $stock): ?string
+    {
+        return app(CatalogItemAllowanceService::class)->unavailableMessage(
+            $stock,
+            $this->getAttribute('remaining_user_quota'),
+        );
+    }
+}

app/Domains/Commerce/Catalog/Resources/CatalogVariantOptionsResource.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Catalog\Resources;
+namespace App\Domains\Commerce\Catalog\Resources;
 
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;

app/Domains/Commerce/Catalog/Services/CatalogInventoryService.php

@@ -1,13 +1,13 @@
 <?php
 
-namespace App\Domains\Catalog\Services;
+namespace App\Domains\Commerce\Catalog\Services;
 
-use App\Domains\Catalog\Enums\CatalogItemType;
-use App\Domains\Catalog\Enums\InventoryPolicy;
-use App\Domains\Catalog\Models\BundleComponent;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\Inventory;
-use App\Domains\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Enums\CatalogItemType;
+use App\Domains\Commerce\Catalog\Enums\InventoryPolicy;
+use App\Domains\Commerce\Catalog\Models\BundleComponent;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Inventory;
+use App\Domains\Commerce\Catalog\Models\Variant;
 use Illuminate\Support\Facades\DB;
 
 class CatalogInventoryService
@@ -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
@@ -45,9 +63,14 @@ class CatalogInventoryService
 
             $selection->loadMissing('variants.inventory');
 
-            return $selection->variants->sum(
-                fn (Variant $variant): int => $variant->inventory->availableStock(),
-            );
+            return $selection->variants
+                ->filter(fn (Variant $variant): bool => $variant->isSellable())
+                ->unique(fn (Variant $variant): string => $variant->inventory_id === null
+                    ? 'object:'.spl_object_id($variant->inventory)
+                    : 'id:'.$variant->inventory_id)
+                ->sum(
+                    fn (Variant $variant): int => $variant->inventory->availableStock(),
+                );
         }
 
         $requirements = $this->inventoryRequirements($selection);

app/Domains/Commerce/Catalog/Services/CatalogItemAllowanceService.php

@@ -1,13 +1,17 @@
 <?php
 
-namespace App\Domains\Catalog\Services;
+namespace App\Domains\Commerce\Catalog\Services;
 
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Purchase\Services\UserPurchaseLimitService;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Purchase\Services\UserPurchaseLimitService;
 use Illuminate\Support\Collection;
 
 class CatalogItemAllowanceService
 {
+    private const USER_QUOTA_REACHED_MESSAGE = 'Alcanzaste el cupo máximo permitido para este producto.';
+
+    private const OUT_OF_STOCK_MESSAGE = 'Este producto no tiene stock disponible.';
+
     public function __construct(
         private readonly UserPurchaseLimitService $purchaseLimits,
     ) {}
@@ -37,4 +41,17 @@ class CatalogItemAllowanceService
 
         return min($availableStock, $remainingUserQuota);
     }
+
+    public function unavailableMessage(?int $availableStock, ?int $remainingUserQuota): ?string
+    {
+        if ($remainingUserQuota !== null && $remainingUserQuota <= 0) {
+            return self::USER_QUOTA_REACHED_MESSAGE;
+        }
+
+        if ($availableStock !== null && $availableStock <= 0) {
+            return self::OUT_OF_STOCK_MESSAGE;
+        }
+
+        return null;
+    }
 }

app/Domains/Commerce/Catalog/Services/CatalogService.php

@@ -1,18 +1,18 @@
 <?php
 
-namespace App\Domains\Catalog\Services;
+namespace App\Domains\Commerce\Catalog\Services;
 
-use App\Domains\Attachable\Models\Attachment;
-use App\Domains\Attachable\Services\AttachmentService;
-use App\Domains\Catalog\Enums\CatalogItemType;
-use App\Domains\Catalog\Models\Attribute;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\Category;
-use App\Domains\Catalog\Models\Inventory;
-use App\Domains\Catalog\Models\ItemAttribute;
-use App\Domains\Catalog\Models\Variant;
-use App\Domains\Event\Models\EventDate;
-use App\Domains\Tenant\Models\Tenant;
+use App\Shared\Attachable\Models\Attachment;
+use App\Shared\Attachable\Services\AttachmentService;
+use App\Domains\Commerce\Catalog\Enums\CatalogItemType;
+use App\Domains\Commerce\Catalog\Models\Attribute;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Category;
+use App\Domains\Commerce\Catalog\Models\Inventory;
+use App\Domains\Commerce\Catalog\Models\ItemAttribute;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Ticketing\Event\Models\EventDate;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Pagination\LengthAwarePaginator;
 use Illuminate\Support\Facades\DB;
@@ -205,6 +205,14 @@ class CatalogService
         ]);
 
         $visibleVariants = $catalogItem->visibleVariants();
+        if ($catalogItem->type === CatalogItemType::Standard
+            && ($catalogItem->inventory_id !== null || $catalogItem->variants->isNotEmpty())
+            && (($catalogItem->variants->isNotEmpty() && $visibleVariants->isEmpty())
+                || ! $catalogItem->isAvailable())) {
+            throw new NotFoundHttpException('Catalog item is out of stock.');
+        }
+
+        $catalogItem->setRelation('variants', $visibleVariants);
         $selectedVariant = $variantId === null
             ? $visibleVariants->first()
             : $visibleVariants->firstWhere('id', $variantId);
@@ -230,8 +238,8 @@ class CatalogService
         $startsWithPattern = "{$normalizedTerm}%";
 
         $paginator = CatalogItem::query()
-            ->where('tenant_code', $tenant->codigo)
-            ->whereVariantsAvailable()
+            ->forTenantCatalog($tenant)
+            ->whereAvailable()
             ->where(function (Builder $query) use ($containsPattern): void {
                 $query
                     ->whereRaw('LOWER(nombre) LIKE ?', [$containsPattern])
@@ -279,9 +287,9 @@ class CatalogService
         int $page,
     ): LengthAwarePaginator {
         return CatalogItem::query()
-            ->where('tenant_code', $tenant->codigo)
+            ->forTenantCatalog($tenant)
             ->where('category_id', $category->id)
-            ->whereVariantsAvailable()
+            ->whereAvailable()
             ->with([
                 'attachments',
                 'inventory',
@@ -317,9 +325,13 @@ class CatalogService
                 ->findOrFail($variant->catalog_item_id);
             $variant->delete();
 
-            if (! $catalogItem->variants()->exists()) {
+            $sellableVariants = $catalogItem->variants()
+                ->whereNull('sales_disabled_at')
+                ->whereNull('replaced_by_variant_id');
+
+            if (! (clone $sellableVariants)->exists()) {
                 $this->delete($catalogItem);
-            } elseif (($minimumPrice = $catalogItem->variants()->min('precio')) !== null) {
+            } elseif (($minimumPrice = (clone $sellableVariants)->min('precio')) !== null) {
                 $catalogItem->update(['precio' => $minimumPrice]);
             }
 
@@ -357,6 +369,8 @@ class CatalogService
             $componentItem = CatalogItem::query()
                 ->whereKey($catalogItemId)
                 ->where('tenant_code', $bundle->tenant_code)
+                ->when($bundle->event_id !== null, fn (Builder $query): Builder => $query
+                    ->where('event_id', $bundle->event_id))
                 ->first();
 
             if ($componentItem === null) {
@@ -392,7 +406,11 @@ class CatalogService
                 ]);
             }
 
-            if ($variantId !== null && ! $componentItem->variants()->whereKey($variantId)->exists()) {
+            if ($variantId !== null && ! $componentItem->variants()
+                ->whereKey($variantId)
+                ->whereNull('sales_disabled_at')
+                ->whereNull('replaced_by_variant_id')
+                ->exists()) {
                 throw ValidationException::withMessages([
                     "components.{$index}.variant_id" => [
                         __('api.catalog.component_variant_invalid'),

app/Domains/Commerce/Catalog/Services/ExpireStockReservationsService.php

@@ -0,0 +1,185 @@
+<?php
+
+namespace App\Domains\Commerce\Catalog\Services;
+
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Catalog\Models\StockReservation;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Commerce\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 ReleaseCheckoutService $purchases,
+        private readonly StockReservationService $reservations,
+    ) {}
+
+    /**
+     * @return array{purchases: int, cart_reservations: int, orphan_reservations: int, failed: int}
+     */
+    public function expireOverdue(): array
+    {
+        $summary = [
+            'purchases' => 0,
+            'cart_reservations' => 0,
+            'orphan_reservations' => 0,
+            'failed' => 0,
+        ];
+        $lastReservationId = 0;
+
+        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');
+
+            foreach ($reservationIds as $reservationId) {
+                $lastReservationId = (int) $reservationId;
+
+                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);
+
+        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/Commerce/Catalog/Services/FeaturedGroupService.php

@@ -1,12 +1,13 @@
 <?php
 
-namespace App\Domains\Catalog\Services;
+namespace App\Domains\Commerce\Catalog\Services;
 
-use App\Domains\Catalog\Enums\FeaturedGroupSource;
-use App\Domains\Catalog\Enums\GroupLayout;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\FeaturedGroup;
-use App\Domains\Catalog\Resources\CatalogFeaturedItemResource;
+use App\Domains\Commerce\Catalog\Enums\FeaturedGroupSource;
+use App\Domains\Commerce\Catalog\Enums\GroupLayout;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\FeaturedGroup;
+use App\Domains\Commerce\Catalog\Resources\CatalogFeaturedItemResource;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Pagination\LengthAwarePaginator;
 
@@ -19,10 +20,10 @@ class FeaturedGroupService
         private readonly CatalogItemAllowanceService $allowances,
     ) {}
 
-    public function itemsResponse(FeaturedGroup $featuredGroup, int $page, ?int $userId = null): array
+    public function itemsResponse(FeaturedGroup $featuredGroup, Tenant $tenant, int $page, ?int $userId = null): array
     {
         if ($featuredGroup->group_layout !== GroupLayout::Paginated) {
-            $query = $this->itemsQuery($featuredGroup);
+            $query = $this->itemsQuery($featuredGroup, $tenant);
 
             if ($featuredGroup->group_layout === GroupLayout::Single) {
                 $query->limit(1);
@@ -35,7 +36,7 @@ class FeaturedGroupService
             return CatalogFeaturedItemResource::collection($items)->resolve();
         }
 
-        $paginator = $this->paginateItems($featuredGroup, $page);
+        $paginator = $this->paginateItems($featuredGroup, $tenant, $page);
         $this->attachGroup($paginator->getCollection(), $featuredGroup);
         $this->allowances->attach($paginator->getCollection(), $userId);
 
@@ -45,11 +46,20 @@ class FeaturedGroupService
     }
 
     /** @return Builder<CatalogItem> */
-    private function itemsQuery(FeaturedGroup $featuredGroup): Builder
+    private function itemsQuery(FeaturedGroup $featuredGroup, Tenant $tenant): Builder
     {
         $query = CatalogItem::query()
-            ->where('catalog_items.tenant_code', $featuredGroup->tenant_code)
-            ->whereVariantsAvailable()
+            ->forTenantCatalog($tenant)
+            ->whereAvailable()
+            ->where(function (Builder $query): void {
+                $query
+                    ->whereDoesntHave('category')
+                    ->orWhereHas(
+                        'category',
+                        fn (Builder $categoryQuery): Builder => $categoryQuery
+                            ->where('is_enabled', true),
+                    );
+            })
             ->with([
                 'inventory',
                 'attachments',
@@ -73,15 +83,18 @@ class FeaturedGroupService
             FeaturedGroupSource::Category => $query
                 ->where('catalog_items.category_id', $featuredGroup->category_id)
                 ->orderBy('catalog_items.id'),
-            FeaturedGroupSource::All => $query->orderBy('catalog_items.id'),
+            FeaturedGroupSource::All => $query
+                ->orderBy('catalog_items.group_order')
+                ->orderBy('catalog_items.id'),
         };
     }
 
     private function paginateItems(
         FeaturedGroup $featuredGroup,
+        Tenant $tenant,
         int $page,
     ): LengthAwarePaginator {
-        $paginator = $this->itemsQuery($featuredGroup)->paginate(
+        $paginator = $this->itemsQuery($featuredGroup, $tenant)->paginate(
             perPage: self::ITEMS_PER_PAGE,
             pageName: 'page',
             page: $page,

app/Domains/Commerce/Catalog/Services/OnTicketFeaturedGroupService.php

@@ -1,13 +1,13 @@
 <?php
 
-namespace App\Domains\Catalog\Services;
+namespace App\Domains\Commerce\Catalog\Services;
 
-use App\Domains\Catalog\Enums\FeaturedGroupSource;
-use App\Domains\Catalog\Enums\GroupLayout;
-use App\Domains\Catalog\Enums\ProductLayout;
-use App\Domains\Catalog\Models\Category;
-use App\Domains\Catalog\Models\FeaturedGroup;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Commerce\Catalog\Enums\FeaturedGroupSource;
+use App\Domains\Commerce\Catalog\Enums\GroupLayout;
+use App\Domains\Commerce\Catalog\Enums\ProductLayout;
+use App\Domains\Commerce\Catalog\Models\Category;
+use App\Domains\Commerce\Catalog\Models\FeaturedGroup;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Support\Facades\DB;
 

app/Domains/Commerce/Catalog/Services/StockReservationService.php

@@ -0,0 +1,497 @@
+<?php
+
+namespace App\Domains\Commerce\Catalog\Services;
+
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Cart\Models\CartItem;
+use App\Domains\Commerce\Catalog\Exceptions\StockReservationExpiredException;
+use App\Domains\Commerce\Catalog\Models\Inventory;
+use App\Domains\Commerce\Catalog\Models\StockReservation;
+use App\Domains\Commerce\Catalog\Models\StockReservationLine;
+use App\Domains\Commerce\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_EVENT_DATE_RESCHEDULED = 'event_date_rescheduled';
+
+    public const REASON_EVENT_DATE_SUSPENDED = 'event_date_suspended';
+
+    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 syncCart(Cart $cart): ?StockReservation
+    {
+        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);
+
+            $reservation = $lockedCart->current_stock_reservation_id === null
+                ? null
+                : StockReservation::query()->lockForUpdate()->find($lockedCart->current_stock_reservation_id);
+
+            if ($reservation !== null) {
+                $this->assertUsableCartReservation($reservation);
+            }
+
+            if ($requirements === []) {
+                if ($reservation !== null && $reservation->status === StockReservation::STATUS_ACTIVE) {
+                    $this->finalizeLocked(
+                        $reservation,
+                        StockReservation::STATUS_RELEASED,
+                        self::REASON_CART_EMPTY,
+                    );
+                }
+
+                $lockedCart->update(['current_stock_reservation_id' => null]);
+                $cart->current_stock_reservation_id = null;
+
+                return null;
+            }
+
+            if ($reservation === null) {
+                $reservation = StockReservation::query()->create([
+                    'status' => StockReservation::STATUS_ACTIVE,
+                    'expires_at' => $this->expiration(),
+                ]);
+                $lockedCart->update(['current_stock_reservation_id' => $reservation->getKey()]);
+            }
+
+            if (Purchase::query()->where('stock_reservation_id', $reservation->getKey())->exists()) {
+                throw new \InvalidArgumentException('La reserva vinculada a una compra no se puede modificar.');
+            }
+
+            $currentLines = StockReservationLine::query()
+                ->where('stock_reservation_id', $reservation->getKey())
+                ->orderBy('inventory_id')
+                ->lockForUpdate()
+                ->get()
+                ->keyBy('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()
+                ->keyBy('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 ($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;
+                }
+
+                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);
+            }
+        });
+    }
+
+    public function returnToCart(Purchase $purchase, Cart $cart): StockReservation
+    {
+        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 ($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.');
+            }
+
+            /** @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');
+        });
+    }
+
+    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 {
+        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;
+            }
+
+            /** @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 clearExpirationForReview(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_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' => null]);
+        });
+    }
+
+    /**
+     * @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 assertUsableCartReservation(StockReservation $reservation): void
+    {
+        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
+    {
+        return now()->addMinutes(
+            max(1, (int) config('catalog.stock_reservation_expiration_minutes', 30)),
+        );
+    }
+}

app/Domains/Commerce/Catalog/Services/VariantReplacementService.php

@@ -0,0 +1,263 @@
+<?php
+
+namespace App\Domains\Commerce\Catalog\Services;
+
+use App\Domains\Commerce\Catalog\Models\BundleComponent;
+use App\Domains\Commerce\Catalog\Models\Inventory;
+use App\Domains\Commerce\Catalog\Models\StockReservation;
+use App\Domains\Commerce\Catalog\Models\StockReservationLine;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Ticketing\Event\Models\EventDate;
+use Illuminate\Support\Collection;
+
+class VariantReplacementService
+{
+    /** @return Collection<int, Variant> */
+    public function replaceEventDate(EventDate $source, EventDate $destination): Collection
+    {
+        $variants = Variant::query()
+            ->whereNull('sales_disabled_at')
+            ->whereNull('replaced_by_variant_id')
+            ->where(function ($query) use ($source): void {
+                $query->where('event_date_id', $source->getKey())
+                    ->orWhereHas('eventDates', fn ($eventDates) => $eventDates
+                        ->where('event_dates.id', $source->getKey()));
+            })
+            ->with(['eventDates', 'eventDate', 'definitions', 'allAttachments'])
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+
+        return $variants->map(function (Variant $variant) use ($source, $destination): Variant {
+            $destinationDateIds = $variant->selectedEventDates()
+                ->pluck('id')
+                ->map(fn ($id): int => (int) $id === (int) $source->getKey()
+                    ? (int) $destination->getKey()
+                    : (int) $id)
+                ->unique()
+                ->sort()
+                ->values();
+
+            $replacement = $this->findEquivalent($variant, $destinationDateIds)
+                ?? $this->cloneWithDates($variant, $destinationDateIds);
+
+            $variant->update([
+                'replaced_by_variant_id' => $replacement->getKey(),
+                'sales_disabled_at' => now(),
+            ]);
+
+            BundleComponent::query()
+                ->where('component_variant_id', $variant->getKey())
+                ->update(['component_variant_id' => $replacement->getKey()]);
+
+            return $replacement;
+        })->values();
+    }
+
+    public function disableForSuspension(EventDate $eventDate): void
+    {
+        $variants = Variant::query()
+            ->whereNull('sales_disabled_at')
+            ->whereNull('replaced_by_variant_id')
+            ->where(function ($query) use ($eventDate): void {
+                $query->where('event_date_id', $eventDate->getKey())
+                    ->orWhereHas('eventDates', fn ($eventDates) => $eventDates
+                        ->where('event_dates.id', $eventDate->getKey()));
+            })
+            ->with(['eventDates', 'eventDate', 'definitions', 'allAttachments'])
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+
+        foreach ($variants as $variant) {
+            $remainingDateIds = $variant->selectedEventDates()
+                ->filter(fn (EventDate $date): bool => $date->suspended_at === null
+                    && $date->rescheduled_to_event_date_id === null)
+                ->pluck('id')
+                ->map(fn ($id): int => (int) $id)
+                ->unique()
+                ->sort()
+                ->values();
+
+            if ($remainingDateIds->isEmpty()) {
+                $variant->update(['sales_disabled_at' => now()]);
+
+                continue;
+            }
+
+            $replacement = $this->findEquivalent($variant, $remainingDateIds);
+            if ($replacement === null) {
+                $replacement = $this->cloneWithDates($variant, $remainingDateIds);
+            } else {
+                $this->mergeInventoryInto($variant, $replacement);
+            }
+
+            $variant->update([
+                'replaced_by_variant_id' => $replacement->getKey(),
+                'sales_disabled_at' => now(),
+            ]);
+
+            BundleComponent::query()
+                ->where('component_variant_id', $variant->getKey())
+                ->update(['component_variant_id' => $replacement->getKey()]);
+        }
+    }
+
+    /** @param Collection<int, int> $eventDateIds */
+    private function findEquivalent(Variant $source, Collection $eventDateIds): ?Variant
+    {
+        $definitionSignature = $this->definitionSignature($source);
+        $dateSignature = $eventDateIds->map(fn ($id): int => (int) $id)->sort()->values()->all();
+
+        return Variant::query()
+            ->where('catalog_item_id', $source->catalog_item_id)
+            ->whereKeyNot($source->getKey())
+            ->whereNull('sales_disabled_at')
+            ->whereNull('replaced_by_variant_id')
+            ->with(['eventDates', 'eventDate', 'definitions'])
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get()
+            ->first(fn (Variant $candidate): bool => $this->definitionSignature($candidate) === $definitionSignature
+                && $candidate->selectedEventDates()
+                    ->pluck('id')
+                    ->map(fn ($id): int => (int) $id)
+                    ->sort()
+                    ->values()
+                    ->all() === $dateSignature
+            );
+    }
+
+    /** @param Collection<int, int> $eventDateIds */
+    private function cloneWithDates(Variant $source, Collection $eventDateIds): Variant
+    {
+        $replacementInventory = $this->cloneInventory($source);
+        $replacement = $source->replicate([
+            'event_date_id',
+            'inventory_id',
+            'replaced_by_variant_id',
+            'sales_disabled_at',
+        ]);
+        $replacement->inventory_id = $replacementInventory->getKey();
+        $replacement->event_date_id = $eventDateIds->count() === 1
+            ? $eventDateIds->first()
+            : null;
+        $replacement->save();
+        $replacement->eventDates()->sync($eventDateIds->all());
+
+        $replacement->definitions()->createMany(
+            $source->definitions
+                ->map(fn ($definition): array => [
+                    'item_attribute_id' => $definition->item_attribute_id,
+                    'value' => $definition->value,
+                ])
+                ->all(),
+        );
+
+        $attachments = $source->allAttachments
+            ->mapWithKeys(fn ($attachment): array => [
+                $attachment->getKey() => [
+                    'orden' => $attachment->pivot->orden,
+                    'is_enabled' => $attachment->pivot->is_enabled,
+                ],
+            ])
+            ->all();
+        $replacement->allAttachments()->sync($attachments);
+
+        return $replacement->load(['eventDates', 'eventDate', 'definitions', 'allAttachments']);
+    }
+
+    private function cloneInventory(Variant $source): Inventory
+    {
+        $activeLines = StockReservationLine::query()
+            ->where('inventory_id', $source->inventory_id)
+            ->whereHas('reservation', fn ($reservation) => $reservation
+                ->where('status', StockReservation::STATUS_ACTIVE))
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+        $sourceInventory = Inventory::query()
+            ->whereKey($source->inventory_id)
+            ->lockForUpdate()
+            ->firstOrFail();
+        $reservedStock = (int) $activeLines->sum('quantity');
+
+        if ($sourceInventory->reserved_stock !== $reservedStock) {
+            throw new \LogicException('El inventario reservado de la variante es inconsistente.');
+        }
+
+        $replacementInventory = Inventory::query()->create([
+            'sold_units' => $sourceInventory->sold_units,
+            'refunded_units' => $sourceInventory->refunded_units,
+            'reserved_stock' => $reservedStock,
+            'real_stock' => $sourceInventory->real_stock,
+        ]);
+
+        if ($activeLines->isNotEmpty()) {
+            StockReservationLine::query()
+                ->whereKey($activeLines->modelKeys())
+                ->update(['inventory_id' => $replacementInventory->getKey()]);
+        }
+        $sourceInventory->update(['reserved_stock' => 0]);
+
+        return $replacementInventory;
+    }
+
+    private function mergeInventoryInto(Variant $source, Variant $destination): void
+    {
+        if ($source->inventory_id === $destination->inventory_id) {
+            return;
+        }
+
+        $inventories = Inventory::query()
+            ->whereKey([$source->inventory_id, $destination->inventory_id])
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get()
+            ->keyBy('id');
+        $sourceInventory = $inventories->get($source->inventory_id);
+        $destinationInventory = $inventories->get($destination->inventory_id);
+        if ($sourceInventory === null || $destinationInventory === null) {
+            throw new \LogicException('No se encontró el inventario de una variante.');
+        }
+
+        $activeLines = StockReservationLine::query()
+            ->where('inventory_id', $source->inventory_id)
+            ->whereHas('reservation', fn ($reservation) => $reservation
+                ->where('status', StockReservation::STATUS_ACTIVE))
+            ->orderBy('id')
+            ->lockForUpdate()
+            ->get();
+        if ($sourceInventory->reserved_stock !== (int) $activeLines->sum('quantity')) {
+            throw new \LogicException('El inventario reservado de la variante es inconsistente.');
+        }
+
+        $destinationInventory->update([
+            'real_stock' => $destinationInventory->real_stock + $sourceInventory->real_stock,
+            'reserved_stock' => $destinationInventory->reserved_stock + $sourceInventory->reserved_stock,
+            'sold_units' => $destinationInventory->sold_units + $sourceInventory->sold_units,
+            'refunded_units' => $destinationInventory->refunded_units + $sourceInventory->refunded_units,
+        ]);
+        if ($activeLines->isNotEmpty()) {
+            StockReservationLine::query()
+                ->whereKey($activeLines->modelKeys())
+                ->update(['inventory_id' => $destinationInventory->getKey()]);
+        }
+        $sourceInventory->update([
+            'real_stock' => 0,
+            'reserved_stock' => 0,
+            'sold_units' => 0,
+            'refunded_units' => 0,
+        ]);
+    }
+
+    /** @return list<string> */
+    private function definitionSignature(Variant $variant): array
+    {
+        return $variant->definitions
+            ->map(fn ($definition): string => $definition->item_attribute_id.'\0'.$definition->value)
+            ->sort()
+            ->values()
+            ->all();
+    }
+}

app/Domains/Commerce/Catalog/Services/VariantSelectionService.php

@@ -1,11 +1,11 @@
 <?php
 
-namespace App\Domains\Catalog\Services;
+namespace App\Domains\Commerce\Catalog\Services;
 
-use App\Domains\Catalog\Enums\InventoryPolicy;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\ItemAttribute;
-use App\Domains\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Enums\InventoryPolicy;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\ItemAttribute;
+use App\Domains\Commerce\Catalog\Models\Variant;
 use Illuminate\Support\Collection;
 
 class VariantSelectionService

app/Domains/Commerce/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.
 

app/Domains/Commerce/Catalog/routes/adminapp.php

@@ -1,6 +1,6 @@
 <?php
 
-use App\Domains\Catalog\Controllers\AdminApp\OnTicketFeaturedGroupController;
+use App\Domains\Commerce\Catalog\Controllers\AdminApp\OnTicketFeaturedGroupController;
 use Illuminate\Support\Facades\Route;
 
 Route::prefix('v1/adminapp/tenant')

app/Domains/Commerce/Catalog/routes/api.php

@@ -1,6 +1,6 @@
 <?php
 
-use App\Domains\Catalog\Controllers\CatalogController;
+use App\Domains\Commerce\Catalog\Controllers\CatalogController;
 use Illuminate\Support\Facades\Route;
 
 Route::prefix('tenants/{tenant:codigo}')->group(function (): void {
@@ -13,7 +13,6 @@ Route::prefix('tenants/{tenant:codigo}')->group(function (): void {
         ->name('categories.show');
     Route::get('catalog-items/{catalogItem}', [CatalogController::class, 'show']);
     Route::post('catalog-items/{catalogItem}/variant-options', [CatalogController::class, 'variantOptions']);
-    Route::post('catalog-items', [CatalogController::class, 'store']);
 });
 
 require __DIR__.'/adminapp.php';

app/Domains/Commerce/Purchase/Controllers/PurchaseController.php

@@ -1,19 +1,17 @@
 <?php
 
-namespace App\Domains\Purchase\Controllers;
+namespace App\Domains\Commerce\Purchase\Controllers;
 
-use App\Domains\Integration\Services\TelepagosIntegrationService;
-use App\Domains\Purchase\Models\Purchase;
-use App\Domains\Purchase\Models\PurchaseItem;
-use App\Domains\Purchase\Requests\PaymentIntentRequest;
-use App\Domains\Purchase\Requests\StartCheckoutRequest;
-use App\Domains\Purchase\Requests\UpdatePurchaseCustomerRequest;
-use App\Domains\Purchase\Requests\UpdatePurchaseItemRequest;
-use App\Domains\Purchase\Resources\PurchaseResource;
-use App\Domains\Purchase\Services\Checkout\PurchaseResponseLoader;
-use App\Domains\Purchase\Services\CheckoutService;
-use App\Domains\Purchase\Services\PurchaseStateGuard;
-use App\Domains\Tenant\Models\Tenant;
+use App\Shared\Integration\Services\TelepagosIntegrationService;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Commerce\Purchase\Requests\PaymentIntentRequest;
+use App\Domains\Commerce\Purchase\Requests\StartCheckoutRequest;
+use App\Domains\Commerce\Purchase\Requests\UpdatePurchaseCustomerRequest;
+use App\Domains\Commerce\Purchase\Resources\PurchaseResource;
+use App\Domains\Commerce\Purchase\Services\Checkout\PurchaseResponseLoader;
+use App\Domains\Commerce\Purchase\Services\CheckoutService;
+use App\Domains\Commerce\Purchase\Services\PurchaseStateGuard;
+use App\Domains\Core\Tenant\Models\Tenant;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
@@ -26,13 +24,23 @@ class PurchaseController extends Controller
 {
     public function index(Request $request, Tenant $tenant): JsonResponse
     {
+        $statusParam = $request->query('status');
+        $statuses = is_string($statusParam)
+            ? collect(explode(',', $statusParam))
+                ->map(fn (string $status): string => trim($status))
+                ->filter()
+                ->unique()
+                ->values()
+                ->all()
+            : [];
+
         return PurchaseResource::collection(
             Purchase::query()
+                ->with('stockReservation')
                 ->where('tenant_codigo', $tenant->codigo)
                 ->where('user_id', $request->user()->id)
-                ->when($request->query('status'), function ($query, $status) {
-                    $query->where('status', $status);
-                })
+                ->when($statuses !== [], fn ($query) => $query->whereIn('status', $statuses))
+                ->orderBy('status')
                 ->latest()
                 ->paginateFromRequest()
         )->response();
@@ -81,58 +89,10 @@ class PurchaseController extends Controller
         );
     }
 
-    public function updateItem(
-        UpdatePurchaseItemRequest $request,
-        Tenant $tenant,
-        Purchase $compra,
-        PurchaseItem $item,
-        CheckoutService $checkoutService,
-    ): PurchaseResource {
-        $compra = $this->resolveScopedPurchase($tenant, $request->user()->id, $compra);
-
-        return PurchaseResource::make(
-            $checkoutService->updateItem(
-                $compra,
-                $item,
-                $request->exists('quantity') ? (int) $request->validated('quantity') : null,
-                $request->exists('variant_id') ? (int) $request->validated('variant_id') : null,
-                $request->exists('variant_id'),
-            ),
-        );
-    }
-
-    public function prepareItemEditing(
-        Request $request,
-        Tenant $tenant,
-        Purchase $compra,
-        CheckoutService $checkoutService,
-    ): PurchaseResource {
-        $compra = $this->resolveScopedPurchase($tenant, $request->user()->id, $compra);
-
-        return PurchaseResource::make(
-            $checkoutService->prepareItemEditing($compra),
-        );
-    }
-
-    public function removeItem(
-        Request $request,
-        Tenant $tenant,
-        Purchase $compra,
-        PurchaseItem $item,
-        CheckoutService $checkoutService,
-    ): PurchaseResource {
-        $compra = $this->resolveScopedPurchase($tenant, $request->user()->id, $compra);
-
-        return PurchaseResource::make(
-            $checkoutService->removeItem($compra, $item),
-        );
-    }
-
     public function paymentIntent(
         PaymentIntentRequest $request,
         Tenant $tenant,
         Purchase $compra,
-        CheckoutService $checkoutService,
         PurchaseStateGuard $purchaseState,
     ): JsonResponse {
         $compra = $this->resolveScopedPurchase($tenant, $request->user()->id, $compra);
@@ -141,7 +101,12 @@ class PurchaseController extends Controller
             ? preg_replace('/\D+/', '', (string) $request->validated('transfer_payer_dni'))
             : null;
 
-        $updated = DB::transaction(function () use ($compra, $method, $purchaseState, $transferPayerDni): bool {
+        $updated = DB::transaction(function () use (
+            $compra,
+            $method,
+            $purchaseState,
+            $transferPayerDni,
+        ): bool {
             /** @var Purchase|null $purchase */
             $purchase = Purchase::query()
                 ->whereKey($compra->getKey())
@@ -163,12 +128,11 @@ class PurchaseController extends Controller
                 return false;
             }
 
+            $purchaseState->lockCurrentCart($purchase);
+
             $purchaseUpdate = [
                 'payment_method' => $method,
                 'status' => Purchase::STATUS_PENDING_PAYMENT,
-                'expires_at' => now()->addMinutes(
-                    max(1, (int) config("purchase.payment_expiration_minutes.{$method}", 30))
-                ),
                 'total' => $purchase->calculateCurrentTotalAmount(),
             ];
 
@@ -188,7 +152,6 @@ class PurchaseController extends Controller
 
         $compra->refresh();
         $totalAmount = (float) $compra->total;
-        $checkoutService->syncReservationExpiration($compra);
 
         if ($method === 'transfer') {
             $telepagosService = new TelepagosIntegrationService;

app/Domains/Commerce/Purchase/Events/PurchasePaid.php

@@ -1,8 +1,7 @@
 <?php
 
-namespace App\Domains\Purchase\Events;
+namespace App\Domains\Commerce\Purchase\Events;
 
-use App\Domains\Purchase\Models\Purchase;
 use Illuminate\Foundation\Events\Dispatchable;
 use Illuminate\Queue\SerializesModels;
 
@@ -10,5 +9,5 @@ class PurchasePaid
 {
     use Dispatchable, SerializesModels;
 
-    public function __construct(public readonly Purchase $purchase) {}
+    public function __construct(public readonly int $purchaseId) {}
 }

app/Domains/Commerce/Purchase/Exceptions/InsufficientStockException.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Purchase\Exceptions;
+namespace App\Domains\Commerce\Purchase\Exceptions;
 
 use RuntimeException;
 

app/Domains/Commerce/Purchase/Exceptions/PurchaseExpiredException.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Purchase\Exceptions;
+namespace App\Domains\Commerce\Purchase\Exceptions;
 
 use RuntimeException;
 

app/Domains/Commerce/Purchase/Exceptions/PurchaseLimitExceededException.php

@@ -1,8 +1,8 @@
 <?php
 
-namespace App\Domains\Purchase\Exceptions;
+namespace App\Domains\Commerce\Purchase\Exceptions;
 
-use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
 use Illuminate\Validation\ValidationException;
 
 class PurchaseLimitExceededException extends ValidationException

app/Domains/Commerce/Purchase/Models/Purchase.php

@@ -1,29 +1,30 @@
 <?php
 
-namespace App\Domains\Purchase\Models;
+namespace App\Domains\Commerce\Purchase\Models;
 
-use App\Domains\Auth\Models\User;
-use App\Domains\Cart\Models\Cart;
-use App\Domains\Catalog\Models\StockReservation;
-use App\Domains\Logging\Models\Concerns\LogsValueChanges;
-use App\Domains\Purchase\Events\PurchasePaid;
-use App\Domains\Tenant\Models\Tenant;
-use App\Domains\Ticket\Models\Ticket;
+use App\Domains\Core\Auth\Models\User;
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Catalog\Models\StockReservation;
+use App\Shared\Logging\Models\Concerns\LogsValueChanges;
+use App\Domains\Commerce\Purchase\Events\PurchasePaid;
+use App\Domains\Core\Tenant\Models\Tenant;
+use App\Domains\Ticketing\Ticket\Models\Ticket;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasManyThrough;
 use Illuminate\Database\Eloquent\Relations\HasOne;
 use Illuminate\Support\Facades\DB;
 
 #[Fillable([
     'cart_id',
+    'stock_reservation_id',
     'tenant_codigo',
     'user_id',
     'status',
     'payment_method',
-    'expires_at',
     'total',
     'dni',
     'transfer_payer_dni',
@@ -39,6 +40,8 @@ class Purchase extends Model
 
     public const STATUS_PENDING_PAYMENT = 'pending_payment';
 
+    public const STATUS_IN_REVIEW = 'in_review';
+
     public const STATUS_PAID = 'paid';
 
     public const STATUS_CANCELLED = 'cancelled';
@@ -47,19 +50,93 @@ class Purchase extends Model
 
     public const STATUS_EXPIRED = 'expired';
 
+    public const STATUS_SUPERSEDED = 'superseded';
+
+    public const ADMIN_STATUS_INCOMPLETE = 'incomplete';
+
+    public const ADMIN_STATUS_AWAITING_PAYMENT = 'awaiting_payment';
+
+    public const ADMIN_STATUS_CONFIRMED = 'confirmed';
+
+    public const ADMIN_STATUS_CANCELLED = 'cancelled';
+
     /** @return list<string> */
     public static function statuses(): array
     {
         return [
             self::STATUS_CREATED,
             self::STATUS_PENDING_PAYMENT,
+            self::STATUS_IN_REVIEW,
             self::STATUS_PAID,
             self::STATUS_CANCELLED,
             self::STATUS_REJECTED,
             self::STATUS_EXPIRED,
+            self::STATUS_SUPERSEDED,
         ];
     }
 
+    /**
+     * @return array<string, array{name: string, statuses: list<string>}>
+     */
+    public static function adminStatuses(): array
+    {
+        return [
+            self::ADMIN_STATUS_INCOMPLETE => [
+                'name' => 'Por completar datos',
+                'statuses' => [self::STATUS_CREATED],
+            ],
+            self::ADMIN_STATUS_AWAITING_PAYMENT => [
+                'name' => 'Esperando pago',
+                'statuses' => [self::STATUS_PENDING_PAYMENT, self::STATUS_IN_REVIEW],
+            ],
+            self::ADMIN_STATUS_CONFIRMED => [
+                'name' => 'Confirmado',
+                'statuses' => [self::STATUS_PAID],
+            ],
+            self::ADMIN_STATUS_CANCELLED => [
+                'name' => 'Anulado',
+                'statuses' => [
+                    self::STATUS_CANCELLED,
+                    self::STATUS_REJECTED,
+                    self::STATUS_EXPIRED,
+                    self::STATUS_SUPERSEDED,
+                ],
+            ],
+        ];
+    }
+
+    /** @return list<string> */
+    public static function adminStatusCodes(): array
+    {
+        return array_keys(self::adminStatuses());
+    }
+
+    /** @return list<string> */
+    public static function realStatusesForAdminStatus(string $adminStatus): array
+    {
+        return self::adminStatuses()[$adminStatus]['statuses'] ?? [];
+    }
+
+    public static function adminStatusFor(string $realStatus): ?string
+    {
+        foreach (self::adminStatuses() as $adminStatus => $definition) {
+            if (in_array($realStatus, $definition['statuses'], true)) {
+                return $adminStatus;
+            }
+        }
+
+        return null;
+    }
+
+    public static function adminStatusNameFor(string $realStatus): ?string
+    {
+        $adminStatus = self::adminStatusFor($realStatus);
+
+        return $adminStatus === null
+            ? null
+            : self::adminStatuses()[$adminStatus]['name'];
+    }
+
     protected $table = 'compras';
 
     /** @var array<int, string> */
@@ -71,8 +148,8 @@ class Purchase extends Model
     {
         return [
             'cart_id' => 'integer',
+            'stock_reservation_id' => 'integer',
             'user_id' => 'integer',
-            'expires_at' => 'datetime',
             'total' => 'decimal:2',
         ];
     }
@@ -109,18 +186,21 @@ class Purchase extends Model
         return $this->hasMany(PurchaseItem::class, 'compra_id');
     }
 
-    /**
-     * @return HasMany<Ticket, $this>
-     */
-    public function tickets(): HasMany
+    /** @return HasManyThrough<Ticket, PurchaseItem, $this> */
+    public function tickets(): HasManyThrough
     {
-        return $this->hasMany(Ticket::class, 'source_purchase_id');
+        return $this->hasManyThrough(
+            Ticket::class,
+            PurchaseItem::class,
+            'compra_id',
+            'source_purchase_item_id',
+        );
     }
 
-    /** @return HasMany<StockReservation, $this> */
-    public function stockReservations(): HasMany
+    /** @return BelongsTo<StockReservation, $this> */
+    public function stockReservation(): BelongsTo
     {
-        return $this->hasMany(StockReservation::class);
+        return $this->belongsTo(StockReservation::class);
     }
 
     /**
@@ -139,6 +219,12 @@ class Purchase extends Model
         return $this->hasMany(TelepagosPayment::class, 'compra_id');
     }
 
+    /** @return HasMany<TelepagosPaymentCandidate, $this> */
+    public function telepagosPaymentCandidates(): HasMany
+    {
+        return $this->hasMany(TelepagosPaymentCandidate::class, 'compra_id');
+    }
+
     public function getTotalAmount(): float
     {
         if ($this->total !== null) {
@@ -154,12 +240,7 @@ class Purchase extends Model
             return (float) $this->getRelation('items')->sum('total');
         }
 
-        $itemsTotal = (float) $this->items()->sum('total');
-        if ($itemsTotal > 0 || $this->items()->exists()) {
-            return $itemsTotal;
-        }
-
-        return (float) ($this->cart?->getTotalAmount() ?? $this->total ?? 0);
+        return (float) $this->items()->sum('total');
     }
 
     protected function valueChangeTenantCode(): string
@@ -192,7 +273,7 @@ class Purchase extends Model
                 'status' => self::STATUS_PAID,
             ]);
 
-            PurchasePaid::dispatch($this);
+            PurchasePaid::dispatch($this->getKey());
         });
     }
 }

app/Domains/Commerce/Purchase/Models/PurchaseItem.php

@@ -1,14 +1,17 @@
 <?php
 
-namespace App\Domains\Purchase\Models;
+namespace App\Domains\Commerce\Purchase\Models;
 
-use App\Domains\Attachable\Models\Attachment;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\Variant;
+use App\Shared\Attachable\Models\Attachment;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Ticketing\Ticket\Models\Ticket;
+use App\Domains\Ticketing\Ticket\Models\TicketRefund;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 
 #[Fillable([
     'compra_id',
@@ -56,6 +59,18 @@ class PurchaseItem extends Model
         return $this->belongsTo(Purchase::class, 'compra_id');
     }
 
+    /** @return HasMany<Ticket, $this> */
+    public function tickets(): HasMany
+    {
+        return $this->hasMany(Ticket::class, 'source_purchase_item_id');
+    }
+
+    /** @return HasMany<TicketRefund, $this> */
+    public function ticketRefunds(): HasMany
+    {
+        return $this->hasMany(TicketRefund::class);
+    }
+
     /** @return BelongsTo<Attachment, $this> */
     public function imageAttachment(): BelongsTo
     {

app/Domains/Commerce/Purchase/Models/TelepagosPayment.php

@@ -1,15 +1,15 @@
 <?php
 
-namespace App\Domains\Purchase\Models;
+namespace App\Domains\Commerce\Purchase\Models;
 
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 
 #[Fillable([
     'compra_id',
-    'matched_purchase_ids',
     'cuit_buyer',
     'cvu_buyer',
     'amount',
@@ -30,7 +30,6 @@ class TelepagosPayment extends Model
     {
         return [
             'compra_id' => 'integer',
-            'matched_purchase_ids' => 'array',
             'amount' => 'decimal:2',
         ];
     }
@@ -42,4 +41,10 @@ class TelepagosPayment extends Model
     {
         return $this->belongsTo(Purchase::class, 'compra_id');
     }
+
+    /** @return HasMany<TelepagosPaymentCandidate, $this> */
+    public function candidates(): HasMany
+    {
+        return $this->hasMany(TelepagosPaymentCandidate::class, 'telepagos_payment_id');
+    }
 }

app/Domains/Commerce/Purchase/Models/TelepagosPaymentCandidate.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Domains\Commerce\Purchase\Models;
+
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+#[Fillable([
+    'telepagos_payment_id',
+    'compra_id',
+    'dni_matches',
+    'dni_distance',
+    'payment_dni',
+    'purchase_dni',
+    'amount_matches',
+    'payment_amount',
+    'purchase_amount',
+    'amount_difference',
+    'match_reason',
+    'confidence',
+])]
+class TelepagosPaymentCandidate extends Model
+{
+    protected $table = 'telepagos_payment_candidates';
+
+    protected function casts(): array
+    {
+        return [
+            'telepagos_payment_id' => 'integer',
+            'compra_id' => 'integer',
+            'dni_matches' => 'boolean',
+            'dni_distance' => 'integer',
+            'amount_matches' => 'boolean',
+            'payment_amount' => 'decimal:2',
+            'purchase_amount' => 'decimal:2',
+            'amount_difference' => 'decimal:2',
+        ];
+    }
+
+    public function payment(): BelongsTo
+    {
+        return $this->belongsTo(TelepagosPayment::class, 'telepagos_payment_id');
+    }
+
+    public function purchase(): BelongsTo
+    {
+        return $this->belongsTo(Purchase::class, 'compra_id');
+    }
+}

app/Domains/Commerce/Purchase/Models/TelepagosQr.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Purchase\Models;
+namespace App\Domains\Commerce\Purchase\Models;
 
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;

app/Domains/Commerce/Purchase/Requests/PaymentIntentRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Purchase\Requests;
+namespace App\Domains\Commerce\Purchase\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;

app/Domains/Commerce/Purchase/Requests/StartCheckoutRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Purchase\Requests;
+namespace App\Domains\Commerce\Purchase\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;

app/Domains/Commerce/Purchase/Requests/UpdatePurchaseCustomerRequest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Purchase\Requests;
+namespace App\Domains\Commerce\Purchase\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 

app/Domains/Commerce/Purchase/Resources/PurchaseItemResource.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Domains\Commerce\Purchase\Resources;
+
+use App\Domains\Commerce\Purchase\Models\PurchaseItem;
+use App\Domains\Core\Tenant\Models\StorefrontWebsiteType;
+use App\Domains\Core\Tenant\Models\Tenant;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin PurchaseItem */
+class PurchaseItemResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        $tenant = $request->route('tenant');
+        $usesEventSummary = $tenant instanceof Tenant
+            && $tenant->storefrontWebsiteType?->checkout_summary_type
+                === StorefrontWebsiteType::CHECKOUT_SUMMARY_EVENT;
+        $displayImage = ! $tenant instanceof Tenant
+            || (! $usesEventSummary && $tenant->display_cart_item_images);
+
+        $imageUrl = $displayImage
+            ? $this->imageAttachment?->getTemporaryUrl(1440)
+            : null;
+
+        return [
+            'id' => $this->id,
+            'quantity' => (int) $this->cantidad,
+            'unit_price' => $this->formatMoney($this->precio_unitario),
+            'line_total' => $this->formatMoney($this->total),
+            'source_catalog_item_id' => $this->source_catalog_item_id,
+            'source_variant_id' => $this->source_variant_id,
+            'item_details' => [
+                'nombre' => $this->item_nombre,
+                'descripcion' => $this->descripcion,
+                'slug' => $this->slug,
+                'imagen' => $this->when(! $usesEventSummary, $imageUrl),
+                'attributes' => $this->variant_attributes ?? [],
+            ],
+        ];
+    }
+
+    private function formatMoney(float|int|string|null $amount): string
+    {
+        return number_format((float) ($amount ?? 0), 2, '.', '');
+    }
+}

app/Domains/Commerce/Purchase/Resources/PurchaseResource.php

@@ -0,0 +1,182 @@
+<?php
+
+namespace App\Domains\Commerce\Purchase\Resources;
+
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Commerce\Purchase\Models\PurchaseItem;
+use App\Domains\Commerce\Purchase\Models\TelepagosPaymentCandidate;
+use App\Domains\Core\Tenant\Models\StorefrontWebsiteType;
+use App\Domains\Core\Tenant\Models\Tenant;
+use App\Domains\Ticketing\Event\Models\Event;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/**
+ * @mixin Purchase
+ */
+class PurchaseResource extends JsonResource
+{
+    /**
+     * @return array<string, mixed>
+     */
+    public function toArray(Request $request): array
+    {
+        $serverTime = now();
+        $expiresAt = $this->stockReservation?->expires_at;
+        $items = $this->resource->relationLoaded('items')
+            ? $this->resource->getRelation('items')
+            : collect();
+        $ticketsCount = array_key_exists('tickets_count', $this->resource->getAttributes())
+            ? (int) $this->resource->getAttribute('tickets_count')
+            : null;
+        $paymentVerification = $this->resolvePaymentVerification();
+        $tenant = $request->route('tenant');
+        $usesEventSummary = $tenant instanceof Tenant
+            && $tenant->storefrontWebsiteType?->checkout_summary_type
+                === StorefrontWebsiteType::CHECKOUT_SUMMARY_EVENT;
+        /** @var Event|null $checkoutEvent */
+        $checkoutEvent = $usesEventSummary
+            ? $items
+                ->map(fn (PurchaseItem $item) => $item->sourceCatalogItem?->event)
+                ->filter()
+                ->unique('id')
+                ->first()
+            : null;
+
+        $subtotal = $items->isNotEmpty()
+            ? $items->reduce(
+                fn (float $carry, PurchaseItem $item): float => $carry + $this->resolveItemSubtotal($item),
+                0.0,
+            )
+            : (float) ($this->total ?? 0);
+
+        $total = $this->status === Purchase::STATUS_PAID && $this->total !== null
+            ? (float) $this->total
+            : ($items->isNotEmpty()
+                ? $items->reduce(
+                    fn (float $carry, PurchaseItem $item): float => $carry + $this->resolveItemTotal($item),
+                    0.0,
+                )
+                : (float) ($this->total ?? 0));
+
+        return [
+            'id' => $this->id,
+            'cart_id' => $this->cart_id,
+            'tenant_codigo' => $this->tenant_codigo,
+            'user_id' => $this->user_id,
+            'created_at' => $this->created_at,
+            'status' => $this->status,
+            'payment_method' => $this->payment_method,
+            'expires_at' => $expiresAt,
+            'expires_in_seconds' => $expiresAt === null
+                ? null
+                : max(0, $expiresAt->getTimestamp() - $serverTime->getTimestamp()),
+            'server_time' => $serverTime,
+            'dni' => $this->dni,
+            'transfer_payer_dni' => $this->transfer_payer_dni,
+            'telefono' => $this->telefono,
+            'nombre_apellido' => $this->nombre_apellido,
+            'email' => $this->email,
+            'items_source' => $items->isNotEmpty() ? 'purchase' : null,
+            'items' => PurchaseItemResource::collection($items),
+            'event' => $this->when($usesEventSummary, fn () => $checkoutEvent === null
+                ? null
+                : [
+                    'id' => $checkoutEvent->id,
+                    'title' => $checkoutEvent->title,
+                    'image' => $checkoutEvent->attachment?->getTemporaryUrl(1440),
+                ]),
+            'tickets_count' => $this->when($ticketsCount !== null, $ticketsCount),
+            'has_generated_tickets' => $this->when($ticketsCount !== null, $ticketsCount > 0),
+            'payment_verification' => $this->when($paymentVerification !== null, $paymentVerification),
+            'subtotal' => $this->formatMoney($subtotal),
+            'total' => $this->formatMoney($total),
+        ];
+    }
+
+    protected function resolveItemSubtotal(PurchaseItem $item): float
+    {
+        return (float) $item->precio_unitario * $item->cantidad;
+    }
+
+    protected function resolveItemTotal(PurchaseItem $item): float
+    {
+        return (float) ($item->total ?? 0);
+    }
+
+    protected function formatMoney(float|int|string|null $amount): string
+    {
+        return number_format((float) ($amount ?? 0), 2, '.', '');
+    }
+
+    /** @return array<string, mixed>|null */
+    private function resolvePaymentVerification(): ?array
+    {
+        if (
+            $this->status !== Purchase::STATUS_IN_REVIEW
+            || $this->payment_method !== 'transfer'
+            || ! $this->resource->relationLoaded('telepagosPaymentCandidates')
+        ) {
+            return null;
+        }
+
+        $candidates = $this->resource
+            ->getRelation('telepagosPaymentCandidates')
+            ->sort(fn (TelepagosPaymentCandidate $left, TelepagosPaymentCandidate $right): int => $this->comparePaymentCandidates($left, $right))
+            ->values();
+        /** @var TelepagosPaymentCandidate|null $primary */
+        $primary = $candidates->first();
+
+        return [
+            'status' => $primary === null ? 'pending' : 'candidate',
+            'candidate_count' => $candidates->count(),
+            'primary' => $primary === null ? null : [
+                'reason' => $primary->match_reason,
+                'dni_distance' => $primary->dni_distance,
+                'payment_amount' => $this->formatMoney($primary->payment_amount),
+                'purchase_amount' => $this->formatMoney($primary->purchase_amount),
+                'amount_difference' => $this->formatMoney($primary->amount_difference),
+                'confidence' => $primary->confidence,
+                'detected_at' => $primary->payment?->created_at?->toIso8601String(),
+            ],
+            'reasons' => $candidates
+                ->pluck('match_reason')
+                ->unique()
+                ->values()
+                ->all(),
+        ];
+    }
+
+    private function comparePaymentCandidates(
+        TelepagosPaymentCandidate $left,
+        TelepagosPaymentCandidate $right,
+    ): int {
+        $reasonComparison = $this->paymentCandidateRank($left->match_reason)
+            <=> $this->paymentCandidateRank($right->match_reason);
+
+        if ($reasonComparison !== 0) {
+            return $reasonComparison;
+        }
+
+        $differenceComparison = (float) $left->amount_difference <=> (float) $right->amount_difference;
+
+        if ($differenceComparison !== 0) {
+            return $differenceComparison;
+        }
+
+        $leftTimestamp = $left->payment?->created_at?->getTimestamp() ?? 0;
+        $rightTimestamp = $right->payment?->created_at?->getTimestamp() ?? 0;
+
+        return ($rightTimestamp <=> $leftTimestamp) ?: ($right->id <=> $left->id);
+    }
+
+    private function paymentCandidateRank(string $reason): int
+    {
+        return match ($reason) {
+            'ambiguous_exact_match' => 0,
+            'exact_dni_near_amount' => 1,
+            'exact_amount_near_dni' => 2,
+            default => 3,
+        };
+    }
+}

app/Domains/Commerce/Purchase/Services/Checkout/CatalogSelectionResolver.php

@@ -1,11 +1,11 @@
 <?php
 
-namespace App\Domains\Purchase\Services\Checkout;
+namespace App\Domains\Commerce\Purchase\Services\Checkout;
 
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\Inventory;
-use App\Domains\Catalog\Models\Variant;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Inventory;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Validation\ValidationException;
 use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 
@@ -20,7 +20,7 @@ class CatalogSelectionResolver
         /** @var CatalogItem|null $catalogItem */
         $catalogItem = CatalogItem::query()
             ->whereKey($catalogItemId)
-            ->where('tenant_code', $tenant->codigo)
+            ->forTenantCatalog($tenant)
             ->lockForUpdate()
             ->first();
 
@@ -28,6 +28,12 @@ class CatalogSelectionResolver
             throw new NotFoundHttpException('Catalog item not found for tenant.');
         }
 
+        if (! $catalogItem->isSaleOpen()) {
+            throw ValidationException::withMessages([
+                "{$fieldPrefix}.catalog_item_id" => ['La venta de este producto finalizó.'],
+            ]);
+        }
+
         if ($catalogItem->isBundle()) {
             if ($variantId !== null) {
                 throw ValidationException::withMessages([
@@ -41,6 +47,17 @@ class CatalogSelectionResolver
                 ]);
             }
 
+            if ($catalogItem->bundleComponents()
+                ->whereNotNull('component_variant_id')
+                ->whereHas('variant', fn ($query) => $query
+                    ->whereNotNull('sales_disabled_at')
+                    ->orWhereNotNull('replaced_by_variant_id'))
+                ->exists()) {
+                throw ValidationException::withMessages([
+                    "{$fieldPrefix}.catalog_item_id" => [__('api.cart.bundle_component_unavailable')],
+                ]);
+            }
+
             return $catalogItem;
         }
 
@@ -70,6 +87,12 @@ class CatalogSelectionResolver
             throw new NotFoundHttpException('Variant not found for catalog item.');
         }
 
+        if (! $variant->isSellable()) {
+            throw ValidationException::withMessages([
+                "{$fieldPrefix}.variant_id" => [__('api.cart.variant_unavailable')],
+            ]);
+        }
+
         $variant->setRelation('catalogItem', $catalogItem);
         $variant->setRelation(
             'inventory',

app/Domains/Commerce/Purchase/Services/Checkout/CompleteCheckoutService.php

@@ -1,11 +1,11 @@
 <?php
 
-namespace App\Domains\Purchase\Services\Checkout;
+namespace App\Domains\Commerce\Purchase\Services\Checkout;
 
-use App\Domains\Cart\Models\CartItem;
-use App\Domains\Catalog\Services\StockReservationService;
-use App\Domains\Purchase\Models\Purchase;
-use App\Domains\Purchase\Services\PurchaseStateGuard;
+use App\Domains\Commerce\Cart\Models\CartItem;
+use App\Domains\Commerce\Catalog\Services\StockReservationService;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Commerce\Purchase\Services\PurchaseStateGuard;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Validation\ValidationException;
@@ -15,7 +15,6 @@ class CompleteCheckoutService
     public function __construct(
         private readonly StockReservationService $reservations,
         private readonly SourceCartService $sourceCart,
-        private readonly PurchaseItemSnapshotFactory $snapshots,
         private readonly PurchaseStateGuard $purchaseState,
     ) {}
 
@@ -35,6 +34,8 @@ class CompleteCheckoutService
                 return $this->loadPurchase($purchase);
             }
 
+            $this->purchaseState->lockCurrentCart($purchase);
+
             $purchase->update([
                 'status' => Purchase::STATUS_PENDING_PAYMENT,
                 'total' => $purchase->calculateCurrentTotalAmount(),
@@ -54,17 +55,22 @@ class CompleteCheckoutService
                 return $this->loadPurchase($purchase);
             }
 
-            if (
-                $purchase->status !== Purchase::STATUS_PENDING_PAYMENT
-                || ($purchase->expires_at !== null && $purchase->expires_at->isPast())
-            ) {
+            if ($purchase->status === Purchase::STATUS_IN_REVIEW) {
+                return $this->loadPurchase($purchase);
+            }
+
+            $this->purchaseState->lockCurrentCart($purchase);
+
+            if ($purchase->status !== Purchase::STATUS_PENDING_PAYMENT) {
                 throw ValidationException::withMessages([
                     'purchase' => __('api.purchase.not_available_for_review'),
                 ]);
             }
 
-            $purchase->update(['expires_at' => null]);
-            $this->reservations->syncPurchaseExpiration($purchase);
+            $purchase->update([
+                'status' => Purchase::STATUS_IN_REVIEW,
+            ]);
+            $this->reservations->clearExpirationForReview($purchase);
 
             return $this->loadPurchase($purchase);
         });
@@ -84,25 +90,26 @@ class CompleteCheckoutService
                 Purchase::STATUS_CANCELLED,
                 Purchase::STATUS_REJECTED,
                 Purchase::STATUS_EXPIRED,
+                Purchase::STATUS_SUPERSEDED,
             ], true)) {
                 throw ValidationException::withMessages([
                     'purchase' => __('api.purchase.cannot_confirm'),
                 ]);
             }
 
-            if ($purchase->items()->exists()) {
-                $cart = $purchase->cart()->withTrashed()->lockForUpdate()->first();
-                if ($cart?->status === 'converted' && $cart->trashed()) {
-                    return;
-                }
-
+            if (! $purchase->items()->exists()) {
                 throw ValidationException::withMessages([
                     'items' => __('api.purchase.inconsistent_reservation'),
                 ]);
             }
 
-            $cart = $purchase->cart()->lockForUpdate()->first();
-            if ($cart === null || $cart->status !== 'checkout') {
+            $cart = $this->purchaseState->lockCurrentCart($purchase);
+
+            if ($cart->status === 'converted' && $cart->trashed()) {
+                return;
+            }
+
+            if (! in_array($cart->status, ['active', 'checkout'], true)) {
                 throw ValidationException::withMessages([
                     'items' => __('api.purchase.inconsistent_reservation'),
                 ]);
@@ -115,10 +122,32 @@ class CompleteCheckoutService
                 ]);
             }
 
+            $snapshotQuantities = $purchase->items()
+                ->lockForUpdate()
+                ->get(['source_catalog_item_id', 'source_variant_id', 'cantidad'])
+                ->groupBy(fn ($item): string => $this->itemKey(
+                    (int) $item->source_catalog_item_id,
+                    $item->source_variant_id === null ? null : (int) $item->source_variant_id,
+                ))
+                ->map(fn (Collection $items): int => (int) $items->sum('cantidad'))
+                ->sortKeys()
+                ->all();
+            $cartQuantities = $cartItems
+                ->groupBy(fn (CartItem $item): string => $this->itemKey(
+                    (int) $item->catalog_item_id,
+                    $item->variant_id === null ? null : (int) $item->variant_id,
+                ))
+                ->map(fn (Collection $items): int => (int) $items->sum('cantidad'))
+                ->sortKeys()
+                ->all();
+
+            if ($snapshotQuantities !== $cartQuantities) {
+                throw ValidationException::withMessages([
+                    'items' => __('api.purchase.inconsistent_reservation'),
+                ]);
+            }
+
             $this->loadCartItems($cartItems);
-            $purchase->items()->createMany(
-                $this->snapshots->fromCartItems($cartItems),
-            );
 
             foreach ($cartItems as $cartItem) {
                 $selection = $cartItem->selectedItem();
@@ -128,13 +157,14 @@ class CompleteCheckoutService
                     ]);
                 }
 
-                try {
-                    $this->reservations->commit($cartItem, $selection);
-                } catch (\InvalidArgumentException) {
-                    throw ValidationException::withMessages([
-                        'items' => __('api.purchase.inconsistent_reservation'),
-                    ]);
-                }
+            }
+
+            try {
+                $this->reservations->commit($purchase);
+            } catch (\InvalidArgumentException) {
+                throw ValidationException::withMessages([
+                    'items' => __('api.purchase.inconsistent_reservation'),
+                ]);
             }
 
             $this->sourceCart->finalize($purchase);
@@ -145,9 +175,11 @@ class CompleteCheckoutService
     {
         return in_array($purchase->status, [
             Purchase::STATUS_PAID,
+            Purchase::STATUS_IN_REVIEW,
             Purchase::STATUS_CANCELLED,
             Purchase::STATUS_REJECTED,
             Purchase::STATUS_EXPIRED,
+            Purchase::STATUS_SUPERSEDED,
         ], true);
     }
 
@@ -159,16 +191,12 @@ class CompleteCheckoutService
 
     private function loadPurchase(Purchase $purchase): Purchase
     {
-        return $purchase->load([
-            'items.imageAttachment',
-            'cart.items.catalogItem.inventory',
-            'cart.items.catalogItem.attachments',
-            'cart.items.variant.inventory',
-            'cart.items.variant.attachments',
-            'cart.items.variant.definitions.itemAttribute.attribute',
-            'cart.items.variant.eventDates',
-            'cart.items.variant.eventDate',
-        ]);
+        return $purchase->load(['items.imageAttachment', 'stockReservation']);
+    }
+
+    private function itemKey(int $catalogItemId, ?int $variantId): string
+    {
+        return $catalogItemId.':'.($variantId ?? 'none');
     }
 
     /** @param Collection<int, CartItem> $cartItems */

app/Domains/Commerce/Purchase/Services/Checkout/EditCheckoutService.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Domains\Commerce\Purchase\Services\Checkout;
+
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Commerce\Purchase\Services\PurchaseStateGuard;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
+
+class EditCheckoutService
+{
+    public function __construct(
+        private readonly PurchaseResponseLoader $responses,
+        private readonly PurchaseStateGuard $purchaseState,
+    ) {}
+
+    /** @param array<string, string> $customerData */
+    public function updateCustomer(Purchase $purchase, array $customerData): Purchase
+    {
+        return DB::transaction(function () use ($purchase, $customerData): Purchase {
+            /** @var Purchase $purchase */
+            $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+            $this->purchaseState->assertNotExpired($purchase);
+
+            if (! in_array($purchase->status, [
+                Purchase::STATUS_CREATED,
+                Purchase::STATUS_PENDING_PAYMENT,
+            ], true)) {
+                throw ValidationException::withMessages([
+                    'purchase' => __('api.purchase.not_editable'),
+                ]);
+            }
+
+            $this->purchaseState->lockCurrentCart($purchase);
+
+            $purchase->update($customerData);
+
+            return $this->responses->load($purchase);
+        });
+    }
+}

app/Domains/Commerce/Purchase/Services/Checkout/InsufficientStockMessageBuilder.php

@@ -1,10 +1,10 @@
 <?php
 
-namespace App\Domains\Purchase\Services\Checkout;
+namespace App\Domains\Commerce\Purchase\Services\Checkout;
 
-use App\Domains\Catalog\Enums\InventorySubject;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Enums\InventorySubject;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Variant;
 
 class InsufficientStockMessageBuilder
 {

app/Domains/Commerce/Purchase/Services/Checkout/PurchaseItemSnapshotFactory.php

@@ -1,43 +1,14 @@
 <?php
 
-namespace App\Domains\Purchase\Services\Checkout;
+namespace App\Domains\Commerce\Purchase\Services\Checkout;
 
-use App\Domains\Attachable\Models\Attachment;
-use App\Domains\Cart\Models\CartItem;
-use App\Domains\Catalog\Models\Variant;
+use App\Shared\Attachable\Models\Attachment;
+use App\Domains\Commerce\Cart\Models\CartItem;
+use App\Domains\Commerce\Catalog\Models\Variant;
 use Illuminate\Support\Collection;
 
 class PurchaseItemSnapshotFactory
 {
-    /** @return array<string, mixed> */
-    public function fromVariant(Variant $variant, int $quantity): array
-    {
-        $variant->loadMissing([
-            'attachments',
-            'catalogItem.attachments',
-            'definitions.itemAttribute.attribute.options',
-            'eventDates',
-            'eventDate',
-        ]);
-        $unitPrice = $variant->getPrice();
-
-        return [
-            'source_variant_id' => $variant->id,
-            'image_attachment_id' => $variant->attachments->first()?->id
-                ?? $variant->catalogItem->attachments->first()?->id,
-            'nombre' => $variant->catalogItem->nombre,
-            'descripcion' => $variant->getDescription(),
-            'slug' => $variant->catalogItem->slug,
-            'item_nombre' => $variant->getName(),
-            'variant_attributes' => $this->snapshotAttributes($variant),
-            'cantidad' => $quantity,
-            'precio_unitario' => $unitPrice,
-            'discount_total' => null,
-            'tax_total' => null,
-            'total' => $unitPrice * $quantity,
-        ];
-    }
-
     /**
      * @param  Collection<int, CartItem>  $cartItems
      * @return array<int, array<string, mixed>>

app/Domains/Commerce/Purchase/Services/Checkout/PurchaseResponseLoader.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Domains\Commerce\Purchase\Services\Checkout;
+
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Core\Tenant\Models\StorefrontWebsiteType;
+
+class PurchaseResponseLoader
+{
+    public function load(Purchase $purchase): Purchase
+    {
+        $purchase->loadMissing('tenant.storefrontWebsiteType');
+        $usesEventSummary = $purchase->tenant?->storefrontWebsiteType?->checkout_summary_type
+            === StorefrontWebsiteType::CHECKOUT_SUMMARY_EVENT;
+        $relations = [
+            'tenant',
+            'items.sourceCatalogItem.event.attachment',
+            'stockReservation',
+        ];
+
+        if (! $usesEventSummary) {
+            $relations[] = 'items.imageAttachment';
+        }
+
+        if (
+            $purchase->status === Purchase::STATUS_IN_REVIEW
+            && $purchase->payment_method === 'transfer'
+        ) {
+            $relations[] = 'telepagosPaymentCandidates.payment';
+        }
+
+        return $purchase->load($relations);
+    }
+}

app/Domains/Commerce/Purchase/Services/Checkout/ReleaseCheckoutService.php

@@ -0,0 +1,262 @@
+<?php
+
+namespace App\Domains\Commerce\Purchase\Services\Checkout;
+
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Cart\Models\CartItem;
+use App\Domains\Commerce\Catalog\Models\StockReservation;
+use App\Domains\Commerce\Catalog\Services\StockReservationService;
+use App\Domains\Commerce\Purchase\Exceptions\PurchaseExpiredException;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
+
+class ReleaseCheckoutService
+{
+    public function __construct(
+        private readonly StockReservationService $reservations,
+    ) {}
+
+    public function cancel(Purchase $purchase): Purchase
+    {
+        return $this->release($purchase, Purchase::STATUS_CANCELLED);
+    }
+
+    public function cancelFromAdmin(Purchase $purchase): Purchase
+    {
+        return $this->release($purchase, Purchase::STATUS_CANCELLED, allowInReviewCancellation: true);
+    }
+
+    public function expire(Purchase $purchase): Purchase
+    {
+        return $this->release($purchase, Purchase::STATUS_EXPIRED);
+    }
+
+    private function release(
+        Purchase $purchase,
+        string $targetStatus,
+        bool $allowInReviewCancellation = false,
+    ): Purchase {
+        return DB::transaction(function () use (
+            $purchase,
+            $targetStatus,
+            $allowInReviewCancellation,
+        ): Purchase {
+            $purchase = $this->lockPurchase($purchase);
+
+            if ($purchase->status === Purchase::STATUS_EXPIRED
+                && $targetStatus === Purchase::STATUS_CANCELLED) {
+                return $this->loadPurchase($purchase);
+            }
+
+            if ($purchase->status === Purchase::STATUS_EXPIRED
+                && $targetStatus !== Purchase::STATUS_EXPIRED) {
+                throw new PurchaseExpiredException;
+            }
+
+            if ($purchase->status === Purchase::STATUS_PAID) {
+                if ($targetStatus === Purchase::STATUS_EXPIRED) {
+                    return $this->loadPurchase($purchase);
+                }
+
+                throw ValidationException::withMessages([
+                    'purchase' => __('api.purchase.paid_cannot_cancel'),
+                ]);
+            }
+
+            if (
+                $purchase->status === Purchase::STATUS_IN_REVIEW
+                && $targetStatus === Purchase::STATUS_CANCELLED
+                && ! $allowInReviewCancellation
+            ) {
+                return $this->createNewCartWithoutCancelling($purchase);
+            }
+
+            if ($this->isAlreadyReleased($purchase)) {
+                return $this->loadPurchase($purchase);
+            }
+
+            $cart = $purchase->cart()->withTrashed()->lockForUpdate()->first();
+
+            // Leaving checkout is allowed at the exact instant the reservation
+            // expires. Finish the expiration while holding the purchase lock so
+            // the request is idempotent with the scheduled expiration job.
+            if ($targetStatus === Purchase::STATUS_CANCELLED
+                && $this->hasOverdueActiveReservation($purchase)) {
+                $targetStatus = Purchase::STATUS_EXPIRED;
+            }
+
+            if ($targetStatus === Purchase::STATUS_CANCELLED
+                && $cart?->status === 'active'
+                && in_array($purchase->status, [
+                    Purchase::STATUS_CREATED,
+                    Purchase::STATUS_PENDING_PAYMENT,
+                ], true)) {
+                if ($this->hasUnavailableVariants($cart)) {
+                    $this->releasePurchaseReservations($purchase, $targetStatus, $cart);
+                    $cart->update([
+                        'status' => Cart::STATUS_EXPIRED,
+                        'current_purchase_id' => null,
+                        'current_stock_reservation_id' => null,
+                    ]);
+                } else {
+                    $this->reservations->returnToCart($purchase, $cart);
+                }
+                $purchase->update(['status' => Purchase::STATUS_CANCELLED]);
+
+                return $this->loadPurchase($purchase);
+            }
+
+            if (
+                $targetStatus === Purchase::STATUS_EXPIRED
+                && (! in_array($purchase->status, [
+                    Purchase::STATUS_CREATED,
+                    Purchase::STATUS_PENDING_PAYMENT,
+                ], true) || ! $this->hasOverdueActiveReservation($purchase))
+            ) {
+                return $this->loadPurchase($purchase);
+            }
+
+            $this->releasePurchaseReservations($purchase, $targetStatus, $cart);
+
+            $purchase->update(['status' => $targetStatus]);
+
+            return $this->loadPurchase($purchase);
+        });
+    }
+
+    private function hasUnavailableVariants(Cart $cart): bool
+    {
+        return $cart->items()
+            ->whereNotNull('variant_id')
+            ->with(['variant.eventDate', 'variant.eventDates'])
+            ->lockForUpdate()
+            ->get()
+            ->contains(fn (CartItem $item): bool => $item->variant === null
+                || ! $item->variant->isSellable());
+    }
+
+    private function releasePurchaseReservations(
+        Purchase $purchase,
+        string $targetStatus,
+        ?Cart $cart,
+    ): void {
+        try {
+            $this->reservations->releaseForPurchase(
+                $purchase,
+                $targetStatus === Purchase::STATUS_EXPIRED
+                    ? StockReservation::STATUS_EXPIRED
+                    : StockReservation::STATUS_RELEASED,
+                $targetStatus === Purchase::STATUS_CANCELLED
+                    ? StockReservationService::REASON_PURCHASE_CANCELLED
+                    : ($targetStatus === Purchase::STATUS_REJECTED
+                        ? StockReservationService::REASON_PAYMENT_REJECTED
+                        : null),
+            );
+        } catch (\InvalidArgumentException) {
+            throw ValidationException::withMessages([
+                'items' => __('api.purchase.inconsistent_reservation'),
+            ]);
+        }
+
+        if ($cart === null) {
+            return;
+        }
+
+        if ($targetStatus === Purchase::STATUS_EXPIRED
+            && in_array($cart->status, [Cart::STATUS_ACTIVE, Cart::STATUS_CHECKOUT], true)) {
+            Cart::query()
+                ->whereKey($cart->getKey())
+                ->where('current_purchase_id', $purchase->getKey())
+                ->where('current_stock_reservation_id', $purchase->stock_reservation_id)
+                ->update([
+                    'status' => Cart::STATUS_EXPIRED,
+                    'current_purchase_id' => null,
+                ]);
+
+            return;
+        }
+
+        if ($cart->status === Cart::STATUS_ACTIVE) {
+            $cartUpdate = [
+                'current_purchase_id' => null,
+                'current_stock_reservation_id' => null,
+            ];
+
+            Cart::query()
+                ->whereKey($cart->getKey())
+                ->where('current_purchase_id', $purchase->getKey())
+                ->update($cartUpdate);
+
+            return;
+        }
+
+        if ($cart->status !== Cart::STATUS_CHECKOUT) {
+            return;
+        }
+
+        if (! $cart->trashed()) {
+            $cart->update(['status' => Cart::STATUS_CONVERTED]);
+            $cart->delete();
+        }
+    }
+
+    private function createNewCartWithoutCancelling(Purchase $purchase): Purchase
+    {
+        return DB::transaction(function () use ($purchase): Purchase {
+            $purchase = $this->lockPurchase($purchase);
+
+            if ($purchase->status !== Purchase::STATUS_IN_REVIEW || $purchase->user_id === null) {
+                return $this->loadPurchase($purchase);
+            }
+
+            /** @var Cart|null $sourceCart */
+            $sourceCart = $purchase->cart()->withTrashed()->lockForUpdate()->first();
+            if ($sourceCart !== null && ! $sourceCart->trashed() && $sourceCart->status === 'active') {
+                $sourceCart->update(['status' => 'checkout']);
+            }
+
+            Cart::query()->firstOrCreate([
+                'tenant_codigo' => $purchase->tenant_codigo,
+                'user_id' => $purchase->user_id,
+                'guest_token' => null,
+                'status' => 'active',
+                'origin' => Cart::ORIGIN_USER,
+            ]);
+
+            return $this->loadPurchase($purchase);
+        });
+    }
+
+    private function isAlreadyReleased(Purchase $purchase): bool
+    {
+        return in_array($purchase->status, [
+            Purchase::STATUS_CANCELLED,
+            Purchase::STATUS_REJECTED,
+            Purchase::STATUS_EXPIRED,
+            Purchase::STATUS_SUPERSEDED,
+        ], true);
+    }
+
+    private function lockPurchase(Purchase $purchase): Purchase
+    {
+        /** @var Purchase */
+        return Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
+    }
+
+    private function loadPurchase(Purchase $purchase): Purchase
+    {
+        return $purchase->load(['items.imageAttachment', 'stockReservation']);
+    }
+
+    private function hasOverdueActiveReservation(Purchase $purchase): bool
+    {
+        /** @var StockReservation|null $reservation */
+        $reservation = $purchase->stockReservation()->lockForUpdate()->first();
+
+        return $reservation !== null
+            && $reservation->status === StockReservation::STATUS_ACTIVE
+            && $reservation->expires_at !== null
+            && ! $reservation->expires_at->isFuture();
+    }
+}

app/Domains/Commerce/Purchase/Services/Checkout/SourceCartService.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Domains\Commerce\Purchase\Services\Checkout;
+
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+
+class SourceCartService
+{
+    public function finalize(Purchase $purchase): void
+    {
+        $sourceCart = $this->findSourceCart($purchase);
+
+        if ($sourceCart === null || $sourceCart->trashed()) {
+            return;
+        }
+
+        $sourceCart->update([
+            'status' => 'converted',
+            'guest_token' => null,
+        ]);
+        $sourceCart->delete();
+    }
+
+    private function findSourceCart(Purchase $purchase): ?Cart
+    {
+        if ($purchase->cart_id === null) {
+            return null;
+        }
+
+        /** @var Cart|null */
+        return Cart::withTrashed()
+            ->whereKey($purchase->cart_id)
+            ->lockForUpdate()
+            ->first();
+    }
+}

app/Domains/Commerce/Purchase/Services/Checkout/StartCheckoutService.php

@@ -1,17 +1,20 @@
 <?php
 
-namespace App\Domains\Purchase\Services\Checkout;
+namespace App\Domains\Commerce\Purchase\Services\Checkout;
 
-use App\Domains\Cart\Models\Cart;
-use App\Domains\Cart\Models\CartItem;
-use App\Domains\Catalog\Models\CatalogItem;
-use App\Domains\Catalog\Models\Variant;
-use App\Domains\Catalog\Services\CatalogInventoryService;
-use App\Domains\Catalog\Services\StockReservationService;
-use App\Domains\Purchase\Exceptions\InsufficientStockException;
-use App\Domains\Purchase\Models\Purchase;
-use App\Domains\Purchase\Services\UserPurchaseLimitService;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Commerce\Cart\Models\Cart;
+use App\Domains\Commerce\Cart\Models\CartItem;
+use App\Domains\Commerce\Cart\Services\CartVariantReplacementService;
+use App\Domains\Commerce\Catalog\Exceptions\StockReservationExpiredException;
+use App\Domains\Commerce\Catalog\Models\CatalogItem;
+use App\Domains\Commerce\Catalog\Models\Variant;
+use App\Domains\Commerce\Catalog\Services\CatalogInventoryService;
+use App\Domains\Commerce\Catalog\Services\StockReservationService;
+use App\Domains\Commerce\Purchase\Exceptions\InsufficientStockException;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Commerce\Purchase\Services\UserPurchaseLimitService;
+use App\Domains\Core\Tenant\Models\Tenant;
+use Illuminate\Support\Carbon;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Validation\ValidationException;
@@ -26,6 +29,8 @@ class StartCheckoutService
         private readonly CatalogSelectionResolver $selections,
         private readonly InsufficientStockMessageBuilder $stockMessages,
         private readonly PurchaseResponseLoader $responses,
+        private readonly PurchaseItemSnapshotFactory $snapshots,
+        private readonly CartVariantReplacementService $variantReplacements,
     ) {}
 
     /** @param array<string, mixed> $purchaseData */
@@ -168,21 +173,31 @@ class StartCheckoutService
                 'cantidad' => $line['quantity'],
             ]);
 
-            try {
-                $this->reservations->reserve($cartItem, $line['selection'], $line['quantity']);
-            } catch (\InvalidArgumentException) {
-                $availableQuantity = $this->inventory->availableQuantity($line['selection']) ?? 0;
-
-                throw new InsufficientStockException([
-                    $this->unavailableItem($line, $availableQuantity),
-                ]);
-            }
-
             $cartItem->setRelation('catalogItem', $line['catalog_item']);
             $cartItem->setRelation('variant', $line['selection'] instanceof Variant ? $line['selection'] : null);
             $cartItems->push($cartItem);
         }
 
+        try {
+            $this->reservations->syncCart($cart);
+        } catch (\InvalidArgumentException) {
+            $unavailable = $resolvedLines
+                ->map(function (array $line): ?array {
+                    $availableQuantity = $this->inventory->availableQuantity($line['selection']);
+
+                    return $availableQuantity !== null && $availableQuantity < $line['quantity']
+                        ? $this->unavailableItem($line, $availableQuantity)
+                        : null;
+                })
+                ->filter()
+                ->values()
+                ->all();
+
+            throw new InsufficientStockException($unavailable !== [] ? $unavailable : [
+                $this->unavailableItem($resolvedLines->first(), 0),
+            ]);
+        }
+
         $purchase = $this->createPurchase(
             $tenant,
             $userId,
@@ -192,14 +207,12 @@ class StartCheckoutService
             ),
             $cart->getKey(),
         );
+        $cart->update(['current_purchase_id' => $purchase->getKey()]);
+        $this->reservations->attachToPurchase($cart, $purchase, $this->checkoutExpiration());
 
-        foreach ($cartItems as $index => $cartItem) {
-            $this->reservations->attachToPurchase(
-                $cartItem,
-                $resolvedLines->get($index)['selection'],
-                $purchase,
-            );
-        }
+        $cartItems = $cart->items()->orderBy('id')->lockForUpdate()->get();
+        $this->loadCartItems($cartItems);
+        $purchase->items()->createMany($this->snapshots->fromCartItems($cartItems));
 
         return $this->loadPurchase($purchase);
     }
@@ -239,6 +252,7 @@ class StartCheckoutService
         int $cartId,
     ): Purchase {
         $cart = $this->resolveCart($tenant, $userId, $cartId);
+        $this->variantReplacements->replaceHistoricalVariants($cart);
         $cartItems = $cart->items()->lockForUpdate()->get();
 
         if ($cartItems->isEmpty()) {
@@ -251,6 +265,7 @@ class StartCheckoutService
         $this->verifyTenantItems($tenant, $cartItems);
         $this->assertCartPurchaseLimits($tenant, $userId, $cartItems, $cart->getKey());
         $cart->setRelation('items', $cartItems);
+        $this->reservations->syncCart($cart);
 
         $purchase = $this->createPurchase(
             $tenant,
@@ -259,42 +274,76 @@ class StartCheckoutService
             $cart->getTotalAmount(),
             $cart->getKey(),
         );
-        foreach ($cartItems as $cartItem) {
-            $this->reservations->attachToPurchase(
-                $cartItem,
-                $cartItem->selectedItem(),
-                $purchase,
-            );
-        }
-
-        // The purchase owns the reservation until checkout finishes. The cart is
-        // retained so it can be restored if the purchase is cancelled or expires.
-        $cart->update([
-            'status' => 'checkout',
-            'guest_token' => null,
-        ]);
+        $cart->update(['current_purchase_id' => $purchase->getKey()]);
+        $this->reservations->attachToPurchase($cart, $purchase, $this->checkoutExpiration());
+        $purchase->items()->createMany($this->snapshots->fromCartItems($cartItems));
 
         return $this->loadPurchase($purchase);
     }
 
     private function resolveCart(Tenant $tenant, int $userId, int $cartId): Cart
     {
+        /** @var Cart|null $candidate */
+        $candidate = Cart::query()->find($cartId);
+
+        $this->assertCartCanCheckout($candidate, $tenant, $userId);
+
+        $candidatePurchaseId = $candidate->current_purchase_id;
+        $currentPurchase = $candidatePurchaseId === null
+            ? null
+            : Purchase::query()->lockForUpdate()->find($candidatePurchaseId);
+
         /** @var Cart|null $cart */
         $cart = Cart::query()->lockForUpdate()->find($cartId);
 
-        if ($cart === null || $cart->tenant_codigo !== $tenant->codigo || $cart->user_id !== $userId) {
-            throw new NotFoundHttpException('Cart not found for tenant.');
+        $this->assertCartCanCheckout($cart, $tenant, $userId);
+
+        if ($cart->current_purchase_id !== $candidatePurchaseId) {
+            if ($cart->current_purchase_id !== null) {
+                throw ValidationException::withMessages([
+                    'cart_id' => __('api.purchase.checkout_in_progress'),
+                ]);
+            }
+
+            $currentPurchase = null;
         }
 
-        if ($cart->status !== 'active') {
+        if ($currentPurchase?->status === Purchase::STATUS_PAID) {
             throw ValidationException::withMessages([
-                'cart_id' => __('api.purchase.inactive_cart'),
+                'cart_id' => __('api.purchase.checkout_in_progress'),
+            ]);
+        }
+
+        if ($currentPurchase !== null && in_array($currentPurchase->status, [
+            Purchase::STATUS_CREATED,
+            Purchase::STATUS_PENDING_PAYMENT,
+        ], true)) {
+            $this->reservations->returnToCart($currentPurchase, $cart);
+            $currentPurchase->update([
+                'status' => Purchase::STATUS_SUPERSEDED,
             ]);
         }
 
         return $cart;
     }
 
+    private function assertCartCanCheckout(?Cart $cart, Tenant $tenant, int $userId): void
+    {
+        if ($cart === null || $cart->tenant_codigo !== $tenant->codigo || $cart->user_id !== $userId) {
+            throw new NotFoundHttpException('Cart not found for tenant.');
+        }
+
+        if ($cart->status === Cart::STATUS_EXPIRED) {
+            throw new StockReservationExpiredException;
+        }
+
+        if ($cart->status !== Cart::STATUS_ACTIVE) {
+            throw ValidationException::withMessages([
+                'cart_id' => __('api.purchase.inactive_cart'),
+            ]);
+        }
+    }
+
     /** @param Collection<int, CartItem> $cartItems */
     private function verifyTenantItems(Tenant $tenant, Collection $cartItems): void
     {
@@ -310,6 +359,13 @@ class StartCheckoutService
                     'cart_id' => __('api.purchase.catalog_item_wrong_tenant'),
                 ]);
             }
+
+            if ($tenant->active_event_id !== null
+                && $item->catalogItem->event_id !== $tenant->active_event_id) {
+                throw ValidationException::withMessages([
+                    'cart_id' => __('api.purchase.catalog_item_missing'),
+                ]);
+            }
         }
     }
 
@@ -362,13 +418,17 @@ class StartCheckoutService
             'user_id' => $userId,
             'status' => Purchase::STATUS_CREATED,
             'payment_method' => null,
-            'expires_at' => now()->addMinutes(
-                max(1, (int) config('purchase.checkout_expiration_minutes', 30)),
-            ),
             'total' => $total,
         ]);
     }
 
+    private function checkoutExpiration(): Carbon
+    {
+        return now()->addMinutes(
+            max(1, (int) config('purchase.checkout_expiration_minutes', 30)),
+        );
+    }
+
     /** @param Collection<int, CartItem> $cartItems */
     private function loadCartItems(Collection $cartItems): void
     {

app/Domains/Commerce/Purchase/Services/CheckoutService.php

@@ -1,15 +1,13 @@
 <?php
 
-namespace App\Domains\Purchase\Services;
+namespace App\Domains\Commerce\Purchase\Services;
 
-use App\Domains\Catalog\Services\StockReservationService;
-use App\Domains\Purchase\Models\Purchase;
-use App\Domains\Purchase\Models\PurchaseItem;
-use App\Domains\Purchase\Services\Checkout\CompleteCheckoutService;
-use App\Domains\Purchase\Services\Checkout\EditCheckoutService;
-use App\Domains\Purchase\Services\Checkout\ReleaseCheckoutService;
-use App\Domains\Purchase\Services\Checkout\StartCheckoutService;
-use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Commerce\Purchase\Models\Purchase;
+use App\Domains\Commerce\Purchase\Services\Checkout\CompleteCheckoutService;
+use App\Domains\Commerce\Purchase\Services\Checkout\EditCheckoutService;
+use App\Domains\Commerce\Purchase\Services\Checkout\ReleaseCheckoutService;
+use App\Domains\Commerce\Purchase\Services\Checkout\StartCheckoutService;
+use App\Domains\Core\Tenant\Models\Tenant;
 use Illuminate\Support\Facades\DB;
 
 /**
@@ -24,7 +22,6 @@ class CheckoutService
         private readonly EditCheckoutService $editor,
         private readonly CompleteCheckoutService $completer,
         private readonly ReleaseCheckoutService $releaser,
-        private readonly StockReservationService $reservations,
     ) {}
 
     /** @param array<string, mixed> $purchaseData */
@@ -49,32 +46,6 @@ class CheckoutService
         return $this->editor->updateCustomer($purchase, $customerData);
     }
 
-    public function updateItem(
-        Purchase $purchase,
-        PurchaseItem $purchaseItem,
-        ?int $quantity,
-        ?int $variantId,
-        bool $updateVariant,
-    ): Purchase {
-        return $this->editor->updateItem(
-            $purchase,
-            $purchaseItem,
-            $quantity,
-            $variantId,
-            $updateVariant,
-        );
-    }
-
-    public function prepareItemEditing(Purchase $purchase): Purchase
-    {
-        return $this->editor->prepareItemEditing($purchase);
-    }
-
-    public function removeItem(Purchase $purchase, PurchaseItem $purchaseItem): Purchase
-    {
-        return $this->editor->removeItem($purchase, $purchaseItem);
-    }
-
     public function confirmPurchase(Purchase $purchase): void
     {
         $this->completer->confirm($purchase);
@@ -95,23 +66,13 @@ class CheckoutService
         return $this->releaser->cancel($purchase);
     }
 
-    public function cancelPurchaseWithoutRestoringCart(Purchase $purchase): Purchase
+    public function cancelPurchaseFromAdmin(Purchase $purchase): Purchase
     {
-        return $this->releaser->cancelWithoutRestoringCart($purchase);
+        return $this->releaser->cancelFromAdmin($purchase);
     }
 
     public function expirePurchase(Purchase $purchase): Purchase
     {
         return $this->releaser->expire($purchase);
     }
-
-    public function expireOverduePurchases(): int
-    {
-        return $this->releaser->expireOverdue();
-    }
-
-    public function syncReservationExpiration(Purchase $purchase): void
-    {
-        $this->reservations->syncPurchaseExpiration($purchase);
-    }
 }

app/Domains/Commerce/Purchase/Services/DniDistanceService.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace App\Domains\Commerce\Purchase\Services;
+
+/**
+ * Measures likely DNI typing errors using the optimal-string-alignment
+ * variant of the Damerau-Levenshtein distance.
+ *
+ * The returned value is the minimum number of single-character edits needed
+ * to transform one DNI into the other. Supported edits are insertion,
+ * deletion, substitution and transposition of two adjacent digits.
+ */
+class DniDistanceService
+{
+    /**
+     * Calculate the edit distance between two normalized DNI strings.
+     *
+     * Each matrix cell [row][column] stores the minimum edits required to
+     * transform the first $row digits of $left into the first $column digits
+     * of $right. The bottom-right cell therefore contains the final distance.
+     */
+    public function distance(string $left, string $right): int
+    {
+        $left = $this->normalize($left);
+        $right = $this->normalize($right);
+        $leftLength = strlen($left);
+        $rightLength = strlen($right);
+        $matrix = [];
+
+        // Transforming a prefix into an empty string requires deleting every digit.
+        for ($row = 0; $row <= $leftLength; $row++) {
+            $matrix[$row] = [$row];
+        }
+
+        // Transforming an empty string into a prefix requires inserting every digit.
+        for ($column = 0; $column <= $rightLength; $column++) {
+            $matrix[0][$column] = $column;
+        }
+
+        for ($row = 1; $row <= $leftLength; $row++) {
+            for ($column = 1; $column <= $rightLength; $column++) {
+                $substitutionCost = $left[$row - 1] === $right[$column - 1] ? 0 : 1;
+                $deletionDistance = $matrix[$row - 1][$column] + 1;
+                $insertionDistance = $matrix[$row][$column - 1] + 1;
+                $substitutionDistance = $matrix[$row - 1][$column - 1] + $substitutionCost;
+
+                // Keep the cheapest way to align the two prefixes at this position.
+                $matrix[$row][$column] = min(
+                    $deletionDistance,
+                    $insertionDistance,
+                    $substitutionDistance,
+                );
+
+                // Count two adjacent inverted digits as one edit instead of two substitutions.
+                if (
+                    $row > 1
+                    && $column > 1
+                    && $left[$row - 1] === $right[$column - 2]
+                    && $left[$row - 2] === $right[$column - 1]
+                ) {
+                    $matrix[$row][$column] = min(
+                        $matrix[$row][$column],
+                        $matrix[$row - 2][$column - 2] + 1,
+                    );
+                }
+            }
+        }
+
+        return $matrix[$leftLength][$rightLength];
+    }
+
+    /**
+     * Keep only digits and left-pad seven-digit DNIs so comparisons preserve
+     * the leading zero that is present when the DNI is extracted from a CUIT.
+     */
+    public function normalize(string $dni): string
+    {
+        $digits = preg_replace('/\D+/', '', $dni) ?? '';
+
+        return str_pad($digits, 8, '0', STR_PAD_LEFT);
+    }
+}

app/Domains/Commerce/Purchase/Services/PurchaseRefundSummaryService.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Commerce\Purchase\Services;
+
+use App\Domains\Core\Tenant\Models\Tenant;
+use App\Domains\Ticketing\Ticket\Models\TicketRefund;
+use Illuminate\Database\Eloquent\Builder;
+
+class PurchaseRefundSummaryService
+{
+    public function totalForTenant(Tenant $tenant): string
+    {
+        $total = TicketRefund::query()
+            ->whereHas(
+                'purchaseItem.purchase',
+                fn (Builder $query): Builder => $query->where('tenant_codigo', $tenant->codigo)
+            )
+            ->sum('amount');
+
+        return number_format((float) $total, 2, '.', '');
+    }
+}