Bump version to 0.16.3

CHANGELOG.md

@@ -4,6 +4,285 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.16.3] - 2026-09-10
+
+### Fixed
+- Stripe `createAndConfirm()` built its `PaymentIntent` params with
+  `'automatic_payment_methods' => isset($data['payment_method']) ? null : ['enabled' => true]`. The
+  Stripe PHP SDK does not omit `null`-valued params from `create()` — it serializes them to an empty
+  string (`ApiRequestor::_encodeObjects()` → `Util::utf8(null)`), and Stripe's API rejects an empty
+  `automatic_payment_methods`. Every Stripe charge failed before it started whenever a
+  `payment_method` was supplied (i.e. every real charge in this flow). Fixed by building `$params`
+  conditionally so the key is either omitted entirely or set to `['enabled' => true]`, never `null`.
+- `Modules\Core\Payment\Filament\Resources\PaymentMethodResource`'s "Driver status" column only
+  flagged a payment method whose driver *class* no longer resolves (`driver_missing_at`) — it gave
+  no indication when a driver resolves fine but fails `Configurable::isConfigured()` (e.g. Stripe
+  enabled in the DB with no `services.stripe.key` set), which `CheckoutService::getPaymentMethods()`
+  filters out identically. An admin had no way to tell "this method is silently absent at checkout
+  because of missing config" from "everything's fine" at a glance. The same icon column now also
+  reflects `isConfigured()`, with a tooltip distinguishing "driver not found" from "missing required
+  configuration" from "fully configured."
+- `Modules\Core\Payment\Pipelines\Cart\ApplyCashOnDeliveryFee` (now `ApplyPaymentMethodFee`) had two
+  stacked bugs that together meant a configured payment-method fee (e.g. €5 on Cash on Delivery)
+  never actually reached the cart total:
+  - `PaymentMethod::where(...)->value('data->fee')` silently returned `null` on Postgres — Laravel's
+    query builder does not translate the `->` JSON-path column-selector syntax in `value()`/`pluck()`
+    the way it does inside `where()` clauses, so this resolved to a discarded
+    `stdClass::$data->fee` property access instead of the actual fee. Fixed by loading the model and
+    reading the cast `->data['fee']` attribute instead.
+  - Even with the fee correctly read, adding it directly to `$cart->shippingTotal` didn't survive:
+    `Lunar\Pipelines\Cart\CalculateTax`, which runs later in the same cart-calculation pipeline,
+    unconditionally recomputes `shippingTotal` (and shipping tax) from `$cart->shippingBreakdown`'s
+    item sum — silently discarding anything set only on the plain property. Fixed by adding the fee
+    as its own `Lunar\Base\ValueObjects\Cart\ShippingBreakdownItem` on `shippingBreakdown` instead,
+    so it survives `CalculateTax`'s recompute and is correctly included in shipping tax too.
+  - Also generalized while fixing: the pipeline was hardcoded to the literal type string
+    `cash-on-delivery`. Renamed to `ApplyPaymentMethodFee` and changed it to look up whichever
+    `PaymentMethod` row matches `Cart::meta['payment_method']` and apply its own `data.fee` if
+    present — works for any payment method configured with a fee, not just one specific slug.
+- `Modules\Core\Checkout\Services\CheckoutService::selectPaymentMethod()` called `$cart->calculate()`
+  after saving the new payment method, but `Lunar\Models\Cart::calculate()` no-ops if the cart
+  instance was already calculated earlier in the same request (`Cart::isCalculated()`) —
+  `Lunar\Managers\CartSessionManager` memoizes one `Cart` instance per request, so this was true on
+  every request where the checkout page's initial render had already calculated the cart. The
+  result: after switching payment methods, the just-saved `meta['payment_method']` change was
+  persisted, but the cart's totals silently kept reflecting whichever method was calculated *first*
+  in the request — a shopper switching from Cash in Hand to Cash on Delivery would keep seeing Cash
+  in Hand's total, with no COD fee applied, until something else forced a fresh calculation. Fixed
+  by calling `$cart->recalculate()` instead, which forces the pipeline to re-run.
+
+## [0.16.2] - 2026-09-09
+
+### Fixed
+- `Lunar\Base\ShippingManifest` is a request-lifetime singleton whose `getOptions()` re-runs the
+  shipping modifier pipeline without ever clearing its `$options` collection first, and whose
+  `addOption()` keeps the first entry per `getIdentifier()` and silently drops any later one. In
+  practice, an option resolved for an earlier shipping address (or cart state) shadowed the
+  correct one after the address/region changed within the same request — e.g. a carrier priced
+  differently across two zones that both match an address would keep quoting the stale zone's
+  price, and `ApplyShipping` would price the cart total off that same stale option. Renamed
+  `Modules\Core\Shipping\Listeners\FlushLivePricingCache` to
+  `Modules\Core\Shipping\Listeners\InvalidateShippingOptions` and had it additionally call
+  `ShippingManifest::clearOptions()`, merged in because both invalidations fire on the exact same
+  event set (`CartLineAdded`, `CartLineUpdated`, `CartLineRemoved`, `CartCleared`,
+  `ShippingAddressSet`) — the only inputs the shipping modifier pipeline depends on.
+
+## [0.16.1] - 2026-09-09
+
+### Fixed
+- OTP login page (`resources/views/auth/filament/pages/login.blade.php`) had no visible spacing
+  between the email/OTP input, error text, and buttons following the Filament v3 → v4 upgrade.
+  The view relied on a bare `grid gap-y-4` Tailwind utility class, but since this view ships from
+  the `boboko-core` package rather than a consuming app, that class was never present in any
+  host app's compiled Tailwind output. Replaced with an inline `style` (flex column, `row-gap:
+  1rem`) so the layout no longer depends on the consuming app's Tailwind content scanning.
+
+## [0.16.0] - 2026-09-08
+
+### Added
+- `Modules\Core\Checkout\Services\CheckoutService::setRecoveryConsent(bool $consent): Cart` — the
+  shopper's promotional/abandoned-cart-recovery opt-in, given once during guest checkout and
+  deliberately independent of `setShippingAddress()`/`setBillingAddress()`: consent is a
+  cart-level decision, not tied to any one `CartAddress` — changing which address is on the cart
+  later never resets or re-asks for it. Only an explicit call to this method (the checkbox itself
+  being submitted) ever changes it; calling it again with `false` is how a later opt-out is
+  recorded, per the legal requirement that consent be provable and withdrawable. Stored on
+  `Cart::meta` (interim, per the design this implements — a real column/consent record is the
+  eventual target, tracked as follow-up) as `recovery_consent` (bool), `recovery_consent_at`
+  (ISO 8601, `null` when `false`), and `recovery_consent_policy_version`
+  (`config('legal.privacy_policy_version')` at the moment of consent, so a later dispute is
+  answered from what was actually agreed to). Dispatches new
+  `Modules\Core\Checkout\Events\RecoveryConsentSet`. Newsletter opt-in is explicitly a separate
+  scope — never merged into this flag.
+- `Modules\Core\Checkout\Services\CheckoutService::initiatePayment()` now requires `bool
+  $termsAccepted` and `string $policyVersion` as mandatory parameters (not optional data a caller
+  might omit) — throws the new `Modules\Core\Checkout\Exceptions\TermsNotAcceptedException`
+  *before* `Cart::createOrder()` is ever called if `$termsAccepted` is `false`, so an order can
+  never exist without a recorded acceptance (refused, not created-then-flagged). On success,
+  writes `terms_accepted` (`true`), `terms_accepted_at` (ISO 8601), and
+  `terms_accepted_policy_version` onto the created `Order`'s own `meta` — the durable,
+  order-level audit trail for a consumer-contract acceptance dispute, written directly (not via
+  an event/listener) since the `Order` row doesn't exist until `createOrder()` returns.
+- `Modules\Core\Cart\Commands\DetectAbandonedCarts` — both its `CartAbandoned` and
+  `CheckoutAbandoned` detection queries now require `meta->recovery_consent = true`. A
+  non-consenting cart's abandonment is never dispatched at all (not merely filtered later at
+  whatever future recovery-email send step reads it) — the correct enforcement point per the
+  legal requirement that recovery/marketing sends only ever reach carts that opted in.
+- `config/legal.php` (merged by a new `Modules\Core\Providers\CheckoutServiceProvider`) —
+  `privacy_policy_version`/`terms_version`, plain `env()`-backed strings bumped by whoever edits
+  the corresponding legal page. Recorded alongside every consent/acceptance rather than read live
+  at dispute time, so what a shopper actually agreed to is answered from the cart/order itself.
+  `CheckoutServiceProvider` itself is new — `Checkout` previously had no dedicated service
+  provider at all (its service/events were resolved/dispatched without one).
+
+## [0.15.0] - 2026-09-07
+
+### Changed
+- **Breaking:** `Modules\Core\Payment\Models\PaymentMethod` is now the full DB-instance layer for
+  Payment, same three-layer split (registry / DB instance / cross-cutting config) `Shipping`
+  already has via `ShippingMethod` — see `docs/payments.md`. Every value that used to live in
+  `config('lunar.payments.types.{type}.*')` (`payment_driver`, `capture_mode`, `captured_status`)
+  moves onto the `PaymentMethod` row itself as real columns: `driver` (the new
+  `PaymentDriverRegistry` key — NOT the same as `type`; two rows can share one driver), `name`
+  (admin-facing label, nothing played this role before), `capture_mode`, `captured_status`,
+  `authorized_status`, `position` (admin-controlled ordering, new — reorderable in the Filament
+  table), `driver_missing_at`. `config('lunar.payments.types')` is gone entirely; `config/
+  payment.php` now holds only `cart_pipeline` (genuinely cross-cutting — every store gets the
+  same pipeline wiring regardless of how many payment methods it configures).
+- **Breaking:** `Modules\Core\Payment\Services\PaymentDriverResolver` is deleted, replaced by
+  `Modules\Core\Payment\Services\PaymentDriverRegistry` — `register(string $key, string
+  $driverClass)`/`resolve(string $key): ?object`/`all(): array<string, string>`. Deliberately
+  knows nothing about `PaymentMethod` or the database (mirrors `Lunar\Shipping\Managers\
+  ShippingManager`'s built-in-methods + `Manager::extend()` split, purpose-built rather than
+  extending `Illuminate\Support\Manager` — Payment's drivers implement several independent
+  capability interfaces at once, not one uniform contract). Built-ins (`OfflinePaymentDriver`
+  as `'offline'`, `StripePaymentDriver` as `'stripe'`) registered in
+  `PaymentServiceProvider::boot()`, exactly how `Shipping::extend('acs', ...)` already works.
+- **Breaking:** `Modules\Core\Checkout\Services\CheckoutService::getPaymentMethods()` now returns
+  `Illuminate\Support\Collection<int, PaymentMethod>` (ordered by `position`), not
+  `array<string>`. A method is offered only once three independent checks all pass — `enabled`
+  (admin turned it on), `driver_missing_at` is null (the driver class still exists), and the
+  resolved driver's own `Configurable::isConfigured()` (its runtime requirements are met) — each
+  failure meaning something different to an admin diagnosing why a method isn't showing up.
+  `initiatePayment()` resolves the driver via the selected row's own `driver` column, not `type`.
+- `Modules\Core\Payment\Filament\Resources\PaymentMethodResource` — `canCreate()`/`canDelete()`
+  now both `true` (previously hardcoded `false`, since a row could only ever be a config-defined
+  type before this release). New create/edit form (`name`, `type`, `driver` — a `Select`
+  populated live from `PaymentDriverRegistry::all()`, `capture_mode`, `captured_status`,
+  `authorized_status`); reorderable table (`->reorderable('position')`); a distinct "Driver
+  status" icon column (separate from the `enabled` toggle) showing whether `driver_missing_at`
+  is set.
+- `Modules\Core\Order\Listeners\ApplyResolvedPaymentStatus` reads `captured_status`/
+  `authorized_status` off the `PaymentMethod` row (`where('type', $event->type)`) instead of
+  `config(...)`.
+- `Modules\Core\Command\InstallLunarCommand::seedPaymentMethods()` no longer iterates
+  `config('lunar.payments.types')` — it seeds exactly one opinionated `cash-on-delivery` starter
+  row, every value a plain literal in the command itself (not sourced from config or the
+  registry — a driver has no business carrying opinions about what its captured order status
+  should be called; that's a merchant decision). Skip-if-exists, same as before.
+
+### Added
+- `php artisan boboko:payment:sync-drivers` — reconciles every `PaymentMethod` row's `driver`
+  against `PaymentDriverRegistry`, setting `driver_missing_at` when a driver no longer resolves
+  (a package removed, a custom `register()` call deleted) and clearing it automatically if that
+  driver is registered again in a later deploy. Deliberately its own standalone command, meant to
+  run unconditionally on every container start/deploy (Dockerfile entrypoint, alongside
+  `migrate`) — "did the set of registered drivers change" is a deploy-time event, cheap enough to
+  check every time regardless of whether anything actually changed. Verified live: flags a row
+  whose `driver` was manually corrupted, and auto-clears the flag once the driver resolves again.
+- `docs/payments.md` — new "Registry, DB instance, and cross-cutting config" section: the
+  three-layer split researched against `Shipping`'s own already-existing pattern and three real
+  e-commerce platforms (Shopify, WooCommerce, Medusa.js), the "would a store ever plausibly want
+  two different answers to this" test for deciding config vs. DB-column placement, and the
+  three-check availability chain.
+
+- `Modules\Core\Payment\Services\PaymentMethodCache` (`Cache::rememberForever`, same pattern as
+  `Localization\Services\LanguageCache`) + `Modules\Core\Payment\Services\PaymentMethodService`
+  (`create`/`update`/`delete`/`list`) — the single read/write gateway for `PaymentMethod` now used
+  by every Filament resource action (create, edit, edit-fee, delete, the inline `enabled` toggle)
+  instead of the Eloquent model directly, so the cache is invalidated and
+  `PaymentMethodCreated`/`PaymentMethodUpdated`/`PaymentMethodDeleted`/`PaymentMethodsReordered`
+  dispatch on every write, with no exceptions other than Filament's own drag-to-reorder (which
+  does a raw bulk SQL `UPDATE` on the position column directly via
+  `CanReorderRecords`/`reorderTable()`, before `afterReordering()` fires — a confirmed, unavoidable
+  Filament limitation; the reorder hook only clears the cache and dispatches
+  `PaymentMethodsReordered` afterward). `CheckoutService::getPaymentMethods()` and
+  `ApplyResolvedPaymentStatus` both now read through the cache instead of querying `PaymentMethod`
+  directly.
+- `Modules\Core\Payment\Models\CoreTransaction` (a `Lunar\Models\Transaction` subclass) +
+  `Modules\Core\Payment\Support\TransactionDriverAdapter`, registered via
+  `Lunar\Facades\ModelManifest::replace(Lunar\Models\Contracts\Transaction::class,
+  CoreTransaction::class)` — the same contract-swap mechanism already used elsewhere for
+  `Customer`/`Staff`. Fixes a real crash (`InvalidArgumentException: Driver [cash-on-delivery] not
+  supported`) the first time anything called `$transaction->refund()`/`->capture()`:
+  `Lunar\Models\Transaction::driver()` calls Lunar's own, entirely separate
+  `Lunar\Facades\Payments::driver()` manager, which had never heard of any of this codebase's
+  driver keys. `CoreTransaction::driver()` returns `TransactionDriverAdapter` instead, which
+  resolves the transaction's real `PaymentMethod`/`PaymentDriverRegistry` driver and calls it —
+  Lunar's own admin panel "Refund"/"Capture" buttons now transparently reach the real payment
+  system underneath, including correctly reporting failure (not a silently-faked success) when
+  the resolved driver doesn't implement `SupportsRefunds`/`SupportsCaptures`.
+- `TransactionDriverAdapter::refundVia(Transaction $transaction, ?string $driverKey, int $amount,
+  ?string $notes = null)` — refund through an explicitly chosen driver, independent of the one
+  the original payment went through (e.g. a cash-on-delivery order refunded via Bank Transfer,
+  which has no notion of the original offline payment at all). The order page's refund action
+  gained a "Refund via" `Select` (every `PaymentDriverRegistry` driver implementing
+  `SupportsRefunds`, defaulting to the transaction's own driver) that routes through this method
+  instead of `Lunar\Models\Transaction::refund()`, whose fixed signature has no room for a driver
+  override.
+- `Modules\Core\Payment\Drivers\BankTransferPaymentDriver` (registered as `'bank-transfer'`) —
+  manual/attested, same trust model as `OfflinePaymentDriver`: no gateway call, `pay()`/`refund()`
+  decide success immediately on a staff member's say-so. Implements both `SupportsPay` and
+  `SupportsRefunds`; exists specifically so a payment taken through a different method can still
+  be refunded via bank transfer. The admin UI for receiving a payment this way (bank reference,
+  notes, proof-of-transfer upload) is a follow-up — the driver itself is complete and usable via
+  the registry today.
+- `Modules\Core\Order\Filament\Infolists\TransactionEntry` (swapped in for Lunar's own
+  `Lunar\Admin\Support\Infolists\Components\Transaction` via a new
+  `OrderTransactionsExtension::extendTransactionsRepeatableEntry()` hook) — the order page's
+  transaction cards now also show a note recorded in `Transaction.meta['notes']` when the `notes`
+  column itself is empty. `Order\Services\TransactionRecorder` only ever wrote `notes` from
+  `PaymentResult::$failureReason`, which is never set on a successful result — a manual driver's
+  staff-entered note (e.g. `BankTransferPaymentDriver`'s) was being recorded but had nowhere to
+  render.
+- `Modules\Core\Payment\Listeners\LogPaymentMethodActivity` — `PaymentMethod` now has an admin
+  activity trail, unlike `Order`/`Transaction`/`Staff` it previously had none. Routes
+  `PaymentMethodCreated`/`Updated`/`Deleted` through the existing `Logging\ActivityLogService`
+  (the same one `Localization\Listeners\LogTranslationActivity` already uses) rather than adding
+  `PaymentMethod` to `Lunar\Base\Traits\LogsActivity`'s generic model-observer logging —
+  `PaymentMethodUpdated::$old`/`PaymentMethodDeleted::$method`'s snapshot already carry more
+  deliberate before/after context than Eloquent's own dirty-attribute diffing would reconstruct.
+  `PaymentMethodsReordered` is deliberately NOT logged — a multi-row position change doesn't fit
+  `ActivityLogService`'s one-`Model`-subject shape, and isn't worth a new method for a low-stakes,
+  purely-cosmetic setting.
+- New `payment_methods.refunded_status` column + form field (same `Select` pattern as
+  `captured_status`/`authorized_status`) — `ApplyResolvedPaymentStatus` now also reacts to
+  `PaymentRefunded`, so `Order.status` actually changes on a refund; before this, only the
+  *derived* `Order::paymentStatus()` reflected a refund (reading `transactions` live), while the
+  stored `status` column — what admin filtering, customer emails, etc. actually key off — never
+  moved. Resolves the ORIGINAL payment method for this lookup, not the refund event's own
+  `$type`: a refund routed through a different driver via `refundVia()` (e.g. cash-on-delivery
+  refunded through Bank Transfer) carries the REFUND driver's registry key as `$event->type`,
+  which usually isn't even a real `PaymentMethod.type` — the listener now finds the order's
+  earliest successful `capture`/`intent` transaction instead and reads `refunded_status` off
+  *that* transaction's own `PaymentMethod` row, since that's the payment the refund is actually
+  reversing. Deliberately no `void_status` yet — a void never moved money, so it doesn't carry
+  the same "the customer needs to see this changed" weight a refund does.
+
+### Fixed
+- Existing `PaymentMethod` rows seeded before this release (`cash-on-delivery`, `cash-in-hand`)
+  had `driver`/`capture_mode`/`captured_status` all `NULL` after the migration ran — a data
+  backfill was required (not automated by the migration itself) to restore them to a resolvable
+  state; flagged here since a consuming app upgrading past this release needs the same backfill
+  for its own pre-existing rows before `getPaymentMethods()` will offer them again.
+- `Lunar\Admin\Filament\Resources\OrderResource\Pages\ManageOrder::getRefundAction()`/
+  `getCaptureAction()` and `OrderItemsTable::getBulkRefundAction()` report a failed refund/capture
+  by calling `$action->failureNotification(...)`, `$action->failure()`, then `$action->halt()` —
+  but `Filament\Actions\Concerns\InteractsWithActions::callMountedAction()` only ever sends that
+  notification from a code path that runs after the action's closure returns normally; `halt()`
+  throws `Filament\Support\Exceptions\Halt`, caught by an earlier `catch` block that rolls back and
+  returns, so the notification was built but never sent — clicking "Refund" on a payment method
+  that genuinely can't be refunded looked like nothing happened at all, no error, no toast. Real,
+  pre-existing Filament/Lunar bug, invisible until this release's `TransactionDriverAdapter` made
+  an honest failure (rather than a hard crash or a silently-faked success) actually reachable.
+  Fixed via new `Modules\Core\Order\Filament\Extensions\OrderRefundActionsExtension`/
+  `OrderItemsTableExtension`, which wrap the affected actions' closures to send the queued failure
+  notification themselves before re-throwing `Halt`.
+- `TransactionDriverAdapter::refund()`/`capture()` never included `order_id` in the `$context`
+  passed to the driver, so `Order\Listeners\RecordPaymentTransaction`/`ApplyResolvedPaymentStatus`
+  (both requiring `$context['order_id']`) silently no-op'd for every admin-initiated refund/capture
+  through any driver — no audit `Transaction` row was ever created, regardless of whether the
+  refund/capture itself succeeded. Fixed by passing `$transaction->order_id` through.
+
+## [0.14.0] - 2026-09-03
+
+### Changed
+- **Breaking:** `Modules\Core\Catalog\Services\ProductSearchService::search()` now returns `Modules\Core\Catalog\DTOs\ProductListingResult` — the exact same shape `ProductService::list()` already returns — instead of a bare `Illuminate\Database\Eloquent\Collection<Product>` of hydrated models with no pagination at all. New signature: `search(string $query, ?ProductFilters $filters = null, ?ProductSort $sort = null, int $perPage = 24, int $page = 1): ProductListingResult`. `->products` is a real `LengthAwarePaginator` of plain, localized indexed-document arrays (not Eloquent models, not Scout's raw response) — a search results page and a category listing page are now interchangeable from a controller's perspective: same DTO, same `ProductCard::fromIndexed()` mapping, same pagination/sort/tag/price-slider handling. `->priceBounds`/`->availableTags` are scoped to the search query itself (delegated to `ProductService::priceSliderBounds()`/`availableTags()`, both of which already accepted a `$query` param for this).
+- `Modules\Core\Catalog\Services\ProductService::availableTags()` is now `public` (was `private`) and takes an optional `$query` parameter, so `ProductSearchService::search()` can reuse it directly instead of reimplementing the same facet call.
+
+### Added
+- `Modules\Core\Catalog\Support\ProductDocumentLocalizer` — the per-locale field resolution and raw-Meilisearch-response unwrapping (`withLocalizedFields()`, `hitsFrom()`) extracted out of `ProductService` into its own class, since `ProductSearchService` needed the exact same logic against the exact same kind of document. Both services now depend on this one class instead of `ProductService` owning logic a second service also needed.
+
 ## [0.13.0] - 2026-09-03
 
 ### Changed

composer.json

@@ -2,7 +2,7 @@
   "name": "boboko/core",
   "description": "Core module — authentication and shared panel behaviour",
   "type": "library",
-  "version": "0.13.1",
+  "version": "0.16.3",
   "autoload": {
     "psr-4": {
       "Modules\\Core\\": "src/"
@@ -37,6 +37,7 @@
         "Modules\\Core\\Providers\\CoreServiceProvider",
         "Modules\\Core\\Providers\\AuthServiceProvider",
         "Modules\\Core\\Providers\\CustomerServiceProvider",
+        "Modules\\Core\\Providers\\CheckoutServiceProvider",
         "Modules\\Core\\Providers\\PaymentServiceProvider",
         "Modules\\Core\\Providers\\LocalizationServiceProvider",
         "Modules\\Core\\Providers\\CatalogServiceProvider",

config/legal.php

@@ -0,0 +1,21 @@
+<?php
+
+return [
+    /*
+    |--------------------------------------------------------------------------
+    | Policy versions
+    |--------------------------------------------------------------------------
+    |
+    | Plain version strings, bumped by whoever edits the corresponding legal
+    | page — recorded alongside every consent/acceptance so a later dispute
+    | ("what did the shopper actually agree to?") can be answered from the
+    | order/cart itself rather than a live lookup against whatever the pages
+    | say TODAY. Not tied to any CMS/database row on purpose — this stays a
+    | plain config value the same way payment.php's cart_pipeline is a plain
+    | cross-cutting setting, not a per-instance one.
+    |
+    */
+    'privacy_policy_version' => env('LEGAL_PRIVACY_POLICY_VERSION', '2026-01-01'),
+
+    'terms_version' => env('LEGAL_TERMS_VERSION', '2026-01-01'),
+];

config/payment.php

@@ -1,48 +1,28 @@
 <?php
 
-use Modules\Core\Payment\Drivers\OfflinePaymentDriver;
+use Modules\Core\Payment\Pipelines\Cart\ApplyPaymentMethodFee;
-use Modules\Core\Payment\Pipelines\Cart\ApplyCashOnDeliveryFee;
 
 return [
-    /*
-    |--------------------------------------------------------------------------
-    | Lunar payment types merged in by Boboko Core
-    |--------------------------------------------------------------------------
-    |
-    | These are merged into config('lunar.payments.types') so every app using
-    | boboko-core gets cash-on-delivery out of the box, without publishing
-    | Lunar's own config.
-    |
-    | 'payment_driver' is boboko-owned, alongside Lunar's own 'driver' key —
-    | the driver instance Modules\Core\Payment\Services\PaymentDriverResolver
-    | resolves via the container. 'capture_mode' ('pay' or 'authorize') is
-    | also boboko-owned — which contract method
-    | CheckoutService::initiatePayment() calls for this type. Kept on the
-    | same row as 'driver' rather than a second, separately-keyed map, so a
-    | type's full definition lives in one place.
-    |
-    */
-    'types' => [
-        'cash-on-delivery' => [
-            'driver' => 'offline',
-            'payment_driver' => OfflinePaymentDriver::class,
-            'capture_mode' => 'pay',
-            'captured_status' => 'payment-offline',
-            'fee' => 0,
-        ],
-    ],
-
     /*
     |--------------------------------------------------------------------------
     | Lunar cart pipeline additions
     |--------------------------------------------------------------------------
     |
     | Appended to config('lunar.cart.pipelines.cart') after ApplyShipping so
-    | the cash-on-delivery fee is added to the shipping total before the
+    | the selected payment method's own fee (if any) is added to the
-    | final Calculate step sums everything up.
+    | shipping total before the final Calculate step sums everything up.
+    |
+    | This is the one thing left in this file — everything about WHICH
+    | payment methods exist (driver mapping, capture_mode, statuses) moved
+    | onto Modules\Core\Payment\Models\PaymentMethod's own row (see
+    | docs/payments.md): that's a per-instance, merchant decision, not a
+    | store-wide-singular setting, so it never belonged in config at all.
+    | This pipeline registration IS genuinely cross-cutting — every store
+    | using this driver gets the same cart-pipeline wiring, regardless of
+    | how many payment methods it configures.
     |
     */
     'cart_pipeline' => [
-        ApplyCashOnDeliveryFee::class,
+        ApplyPaymentMethodFee::class,
     ],
 ];

database/migrations/2026_09_05_000001_add_driver_columns_to_payment_methods.php

@@ -0,0 +1,52 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * Moves the driver mapping and per-type behavior that used to live in
+ * config('lunar.payments.types.{type}.*') onto the PaymentMethod row
+ * itself — same DB-instance-vs-config split Modules\Core\Shipping's own
+ * shipping_methods table already has (code/driver/name/enabled columns,
+ * no driver mapping in any config file). See docs/payments.md.
+ *
+ *   - driver: the Modules\Core\Payment\Services\PaymentDriverRegistry key
+ *     (NOT the same as `type` — two rows can share one driver).
+ *   - name: admin-facing label. Nothing played this role before; `type`
+ *     was always the machine slug.
+ *   - capture_mode / captured_status / authorized_status: per-instance
+ *     behavior — fails the "would a store ever want two different answers
+ *     to this" cross-cutting-config test, so these move off config.
+ *   - position: admin-controlled display/checkout order.
+ *   - driver_missing_at: set by the payment:sync-drivers command when
+ *     `driver` no longer resolves via the registry — deliberately
+ *     separate from `enabled`, so a driver vanishing (a deploy removed
+ *     it) is never confused with an admin's own manual toggle, and a
+ *     driver that comes back later auto-clears this with no admin action.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('payment_methods', function (Blueprint $table) {
+            $table->string('name')->nullable()->after('type');
+            $table->string('driver')->nullable()->after('name');
+            $table->string('capture_mode')->nullable()->after('driver');
+            $table->string('captured_status')->nullable()->after('capture_mode');
+            $table->string('authorized_status')->nullable()->after('captured_status');
+            $table->unsignedInteger('position')->default(0)->after('authorized_status');
+            $table->timestamp('driver_missing_at')->nullable()->after('position');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('payment_methods', function (Blueprint $table) {
+            $table->dropColumn([
+                'name', 'driver', 'capture_mode', 'captured_status',
+                'authorized_status', 'position', 'driver_missing_at',
+            ]);
+        });
+    }
+};

database/migrations/2026_09_08_000001_add_refunded_status_to_payment_methods.php

@@ -0,0 +1,38 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * captured_status/authorized_status (added in 2026_09_05_000001) cover a
+ * payment being taken, but nothing wrote Order.status on a REFUND —
+ * Order::paymentStatus() (Order\Support\OrderStatus::payment(), derived
+ * live from transactions) already reflects a refund correctly, but the
+ * stored status column — the one admin filtering, customer emails, etc.
+ * actually key off — never moved. Same reasoning as captured_status/
+ * authorized_status: a store could plausibly want a different resulting
+ * status per payment method (e.g. a "Refunded" vs. a "Refund Pending"
+ * variant), so this is a PaymentMethod column, not cross-cutting config.
+ *
+ * Deliberately no separate void_status — void never moved money (it
+ * releases an authorization hold before any capture), so it doesn't carry
+ * the same "the customer needs to see this changed" weight a refund does;
+ * add one later if a real need for it shows up.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('payment_methods', function (Blueprint $table) {
+            $table->string('refunded_status')->nullable()->after('authorized_status');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('payment_methods', function (Blueprint $table) {
+            $table->dropColumn('refunded_status');
+        });
+    }
+};

resources/views/auth/filament/pages/login.blade.php

@@ -2,7 +2,7 @@
 
     @if (! $otpSent)
         <form wire:submit="requestOtp">
-            <div class="grid gap-y-4">
+            <div style="display: flex; flex-direction: column; row-gap: 1rem;">
                 <x-filament::input.wrapper>
                     <x-filament::input
                         type="email"
@@ -24,7 +24,7 @@
         </form>
     @else
         <form wire:submit="authenticate">
-            <div class="grid gap-y-4">
+            <div style="display: flex; flex-direction: column; row-gap: 1rem;">
                 <p class="text-sm text-gray-500">
                     A login code was sent to <strong>{{ $email }}</strong>.
                 </p>

resources/views/order/infolists/transaction.blade.php

@@ -0,0 +1,127 @@
+@php
+    $transaction = $getRecord();
+    $notes = $transaction->notes ?: ($transaction->meta['notes'] ?? null);
+@endphp
+
+@once
+    @php
+        $renderPaymentIcons();
+    @endphp
+@endonce
+<div
+    @class([
+        'text-sm rounded-lg shadow-md border dark:bg-gray-900',
+        'text-gray-950 dark:text-white',
+        match($transaction->type){
+            'refund' => 'border-orange-300',
+            'intent' => 'border-sky-300',
+            'capture' => 'border-green-300',
+            default => 'border-gray-300',
+        },
+        '!border-red-500 bg-red-50' => !$transaction->success,
+        'bg-gray-50' => $transaction->success,
+    ])
+>
+    <div class="p-2 space-y-2">
+        <div class="px-4 py-2 rounded text-xs bg-white dark:bg-gray-800 shadow text-gray-600 dark:text-gray-400 ring-1 ring-gray-100 dark:ring-gray-700">
+            <span>{{ $transaction->driver }}</span> //
+            <span>{{ $transaction->reference }}</span>
+        </div>
+
+        <div class="flex items-center justify-between p-4 bg-white dark:bg-gray-800 rounded shadow ring-1 ring-gray-100 dark:ring-gray-700">
+            <div class="flex items-center gap-6">
+                <div>
+                    <strong class="text-xs">
+                        {{ $transaction->status }}
+                    </strong>
+                </div>
+
+                <div>
+                    <svg viewBox="0 0 50 50" class="w-10">
+                        <use xlink:href="#{{ strtolower($transaction->card_type) }}"></use>
+                    </svg>
+                </div>
+
+                @if($transaction->last_four)
+                    <p class="text-sm">
+                        <span class="inline-block -translate-y-px">
+                            &lowast;&lowast;&lowast;&lowast; &lowast;&lowast;&lowast;&lowast; &lowast;&lowast;&lowast;&lowast;
+                        </span>
+
+                        <span class="font-medium">
+                            {{ (string) $transaction->last_four }}
+                        </span>
+                    </p>
+                @endif
+            </div>
+
+            <strong
+                @class([
+                    "text-sm",
+                    'text-red-500' => !$transaction->success,
+                    match($transaction->type){
+                        'refund' => "text-orange-500",
+                        default => "text-gray-900 dark:text-gray-100",
+                    },
+                ])
+            >
+                @if($transaction->type == 'refund')-@endif{{ $transaction->amount->formatted }}
+            </strong>
+        </div>
+
+        <div class="px-4 py-2 bg-white dark:bg-gray-800 shadow rounded flex items-center justify-between text-gray-600 dark:text-gray-400 ring-1 ring-gray-100 dark:ring-gray-700">
+            <div class="text-xs flex items-center gap-2">
+                <div>
+                    <x-filament::icon
+                        icon="heroicon-o-clock"
+                        class="w-4"
+                    />
+                </div>
+                <span>{{ $transaction->created_at->format('jS F Y h:ia') }}</span>
+            </div>
+
+            <div class="flex space-x-2">
+            @foreach($transaction->paymentChecks() as $check)
+                    <x-filament::badge
+                        :icon="$check->successful ? 'heroicon-m-check' : 'heroicon-m-x-mark'"
+                        :color="$check->successful ?  \Filament\Support\Colors\Color::Sky : 'gray'"
+                    >
+                        {{ $check->label }}: {{ $check->message }}
+                    </x-filament::badge>
+            @endforeach
+            </div>
+        </div>
+
+        @if($notes)
+            <div class="px-4 py-2 bg-white dark:bg-gray-800 shadow flex items-center rounded gap-2 ring-1 ring-gray-100 dark:ring-gray-700">
+                <div>
+                    <x-filament::icon
+                        icon="heroicon-o-chat-bubble-oval-left-ellipsis"
+                        class="w-4"
+                    />
+                </div>
+
+                <p class="text-sm">{{ $notes }}</p>
+            </div>
+        @endif
+    </div>
+
+    <div
+        @class([
+            "bottom-0 left-0 block w-full text-center rounded-b-lg border-t text-xs py-1",
+            "!bg-red-50 !dark:bg-red-400/10 !border-red-300 !text-red-600 !dark:text-red-400" => !$transaction->success,
+            match($transaction->type){
+                'refund' => "bg-orange-50 dark:bg-orange-400/10 border-orange-300 text-orange-600 dark:text-orange-400",
+                'intent' => "bg-sky-50 dark:bg-sky-400/10 border-sky-300 text-sky-600 dark:text-sky-400",
+                'capture' => "bg-green-50 dark:bg-green-400/10 border-green-300 text-green-600 dark:text-green-400",
+                default => "bg-gray-50 dark:bg-gray-400/10 border-gray-300 text-gray-600 dark:text-gray-400",
+            },
+        ])
+    >
+        @if(!$transaction->success)
+            {{ __('lunarpanel::order.transactions.failed') }}
+        @else
+            {{ __('lunarpanel::order.transactions.'.$transaction->type) }}
+        @endif
+    </div>
+</div>

src/Cart/Commands/DetectAbandonedCarts.php

@@ -31,6 +31,13 @@ use Modules\Core\Recovery\Events\CheckoutAbandoned;
  * state at all; every cart still matching the query below refires its event
  * on every run until Recovery (not yet built — see
  * docs/recovery-strategies.md) owns its own dedup/tracking table.
+ *
+ * Both queries require meta->recovery_consent = true — CartAbandoned/
+ * CheckoutAbandoned exist specifically to drive future recovery-email
+ * sends (Checkout\Services\CheckoutService::setRecoveryConsent() is where
+ * that consent is actually recorded), and a non-consenting cart's
+ * abandonment must never be dispatched at all, not merely filtered later
+ * at send time — see docs referenced above for the legal reasoning.
  */
 class DetectAbandonedCarts extends Command
 {
@@ -48,6 +55,7 @@ class DetectAbandonedCarts extends Command
         Cart::query()
             ->whereDoesntHave('orders')
             ->where('updated_at', '<=', $cutoff)
+            ->where('meta->recovery_consent', true)
             ->with('lines')
             ->chunkById(200, function ($carts) use (&$cartsAbandoned) {
                 foreach ($carts as $cart) {
@@ -64,6 +72,7 @@ class DetectAbandonedCarts extends Command
         Cart::query()
             ->whereHas('orders', fn ($query) => $query->whereNull('placed_at'))
             ->where('updated_at', '<=', $cutoff)
+            ->where('meta->recovery_consent', true)
             ->with(['orders' => fn ($query) => $query->whereNull('placed_at')])
             ->chunkById(200, function ($carts) use (&$checkoutsAbandoned) {
                 foreach ($carts as $cart) {

src/Catalog/Services/ProductSearchService.php

@@ -2,12 +2,14 @@
 
 namespace Modules\Core\Catalog\Services;
 
-use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Pagination\LengthAwarePaginator;
 use Lunar\Facades\AttributeManifest;
 use Lunar\Models\Language;
 use Lunar\Models\Product;
 use Modules\Core\Catalog\DTOs\ProductFilters;
+use Modules\Core\Catalog\DTOs\ProductListingResult;
 use Modules\Core\Catalog\Enums\ProductSort;
+use Modules\Core\Catalog\Support\ProductDocumentLocalizer;
 use Modules\Core\Catalog\Support\ProductFilterBuilder;
 
 /**
@@ -21,20 +23,37 @@ class ProductSearchService
 {
     public function __construct(
         private readonly ProductFilterBuilder $filterBuilder,
+        private readonly ProductDocumentLocalizer $localizer,
+        private readonly ProductService $products,
     ) {}
 
     /**
+     * Returns the exact same Modules\Core\Catalog\DTOs\ProductListingResult
+     * ProductService::list() does — a search results page and a category
+     * listing page consume identically shaped data, one call each. The
+     * paginator itself carries plain, localized indexed-document arrays
+     * (not hydrated Product models), same as list().
+     *
+     * priceBounds/availableTags are delegated to ProductService's own
+     * priceSliderBounds()/availableTags() rather than reimplemented here —
+     * both already accept a $query param for exactly this reason (a search
+     * page's slider/tag sidebar should reflect only the products search
+     * actually matched, not the whole catalog).
+     *
      * $filters/$sort apply the exact same semantics ProductService::list()
      * uses for collection browsing (same ProductFilterBuilder, same
      * ProductSort::toMeilisearchSort()) — a shopper narrowing a text search
      * by price/brand/stock gets identical filter behavior to narrowing a
      * category listing, since both go through the same Meilisearch `filter`
      * clause underneath.
-     *
-     * @return Collection<int, Product>
      */
-    public function search(string $query, ?ProductFilters $filters = null, ?ProductSort $sort = null): Collection
+    public function search(
-    {
+        string $query,
+        ?ProductFilters $filters = null,
+        ?ProductSort $sort = null,
+        int $perPage = 24,
+        int $page = 1,
+    ): ProductListingResult {
         $options = [
             'attributesToSearchOn' => $this->searchableFields(),
             'filter' => $this->filterBuilder->build($filters),
@@ -44,9 +63,26 @@ class ProductSearchService
             $options['sort'] = [$sort->toMeilisearchSort()];
         }
 
-        return Product::search($query)
+        $paginator = Product::search($query)
             ->options($options)
-            ->get();
+            ->paginateRaw(perPage: $perPage, page: $page);
+
+        $data = collect($this->localizer->hitsFrom($paginator))
+            ->map(fn (array $product) => $this->localizer->withLocalizedFields($product))
+            ->all();
+
+        $products = new LengthAwarePaginator(
+            items: $data,
+            total: $paginator->total(),
+            perPage: $paginator->perPage(),
+            currentPage: $paginator->currentPage(),
+            options: ['path' => LengthAwarePaginator::resolveCurrentPath()],
+        );
+
+        $priceBounds = $this->products->priceSliderBounds($filters, $filters?->minPrice, $filters?->maxPrice, $query);
+        $availableTags = $this->products->availableTags($filters, $query);
+
+        return new ProductListingResult($products, $priceBounds, $availableTags);
     }
 
     /**

src/Catalog/Services/ProductService.php

@@ -2,17 +2,13 @@
 
 namespace Modules\Core\Catalog\Services;
 
-use Illuminate\Contracts\Pagination\LengthAwarePaginator as LengthAwarePaginatorContract;
 use Illuminate\Pagination\LengthAwarePaginator;
-use Illuminate\Support\Facades\App;
-use Lunar\Base\AttributeManifest;
-use Lunar\FieldTypes\TranslatedText;
 use Lunar\Models\Product;
-use Modules\Core\Localization\Services\LanguageCache;
 use Modules\Core\Catalog\DTOs\PriceSliderBounds;
 use Modules\Core\Catalog\DTOs\ProductFilters;
 use Modules\Core\Catalog\DTOs\ProductListingResult;
 use Modules\Core\Catalog\Enums\ProductSort;
+use Modules\Core\Catalog\Support\ProductDocumentLocalizer;
 use Modules\Core\Catalog\Support\ProductFilterBuilder;
 
 /**
@@ -27,8 +23,7 @@ use Modules\Core\Catalog\Support\ProductFilterBuilder;
 class ProductService
 {
     public function __construct(
-        private readonly LanguageCache $languages,
+        private readonly ProductDocumentLocalizer $localizer,
-        private readonly AttributeManifest $attributes,
         private readonly ProductFilterBuilder $filterBuilder,
     ) {}
 
@@ -65,8 +60,8 @@ class ProductService
             ->options($options)
             ->paginateRaw(perPage: $perPage, page: $page);
 
-        $data = collect($this->hitsFrom($paginator))
+        $data = collect($this->localizer->hitsFrom($paginator))
-            ->map(fn (array $product) => $this->withLocalizedFields($product))
+            ->map(fn (array $product) => $this->localizer->withLocalizedFields($product))
             ->all();
 
         $products = new LengthAwarePaginator(
@@ -91,12 +86,20 @@ class ProductService
      * alphabetically; Meilisearch's facetDistribution has no defined order
      * of its own.
      *
+     * $query defaults to '' (every product, same as list()'s own default
+     * text query) — same reasoning as priceRange()'s own $query: pass the
+     * shopper's search text here too so a search page's own tag sidebar
+     * reflects only the products search actually matched. Public (not
+     * private, unlike the rest of this listing-only orchestration) so
+     * ProductSearchService::search() can reuse it directly rather than
+     * reimplementing the same facet call a second time.
+     *
      * @return array<int, string>
      */
-    private function availableTags(?ProductFilters $filters): array
+    public function availableTags(?ProductFilters $filters, string $query = ''): array
     {
         $filter = $this->filterBuilder->build($filters, exclude: ['tag']);
-        $tags = $this->rawFacets('tags', $filter)['facetDistribution']['tags'] ?? [];
+        $tags = $this->rawFacets('tags', $filter, $query)['facetDistribution']['tags'] ?? [];
 
         return collect($tags)->keys()->sort()->values()->all();
     }
@@ -287,69 +290,8 @@ class ProductService
             ->options(['filter' => $filter])
             ->paginateRaw(perPage: $limit, page: 1);
 
-        return collect($this->hitsFrom($paginator))
+        return collect($this->localizer->hitsFrom($paginator))
-            ->map(fn (array $product) => $this->withLocalizedFields($product))
+            ->map(fn (array $product) => $this->localizer->withLocalizedFields($product))
             ->all();
     }
-
-    /**
-     * Resolves every translated Product attribute's current-locale value from the
-     * indexer's per-locale `{handle}_{locale}` fields (e.g. `name_el`, `name_en`,
-     * `seo_title_el`, ...) into a plain `{handle}` key, falling back to the store's
-     * default language (LanguageCache::defaultLocale()) when the current locale
-     * has no translation - e.g. a product with no English copy yet still shows its
-     * Greek name on /en/ rather than rendering blank.
-     *
-     * Which handles are translated is read from AttributeManifest - the same
-     * source Lunar's own ScoutIndexer reads when exploding a TranslatedText
-     * attribute into `{handle}_{locale}` keys at index time - rather than a fixed
-     * list, so a store's own custom translated attributes (e.g. `seo_title`) are
-     * picked up automatically with no change here. The raw per-locale keys are
-     * then stripped, since once resolved, callers only ever need the one that
-     * matched the current locale.
-     *
-     * Deliberately not config('app.locale') - App::setLocale() overwrites that
-     * config value on every request, so by request time it's just whatever the
-     * current locale already is, not a stable fallback.
-     */
-    private function withLocalizedFields(array $product): array
-    {
-        $locale = App::getLocale();
-        $fallbackLocale = $this->languages->defaultLocale();
-        $availableLocales = $this->languages->availableLocales();
-
-        foreach ($this->translatedAttributeHandles() as $handle) {
-            $product[$handle] = $product[$handle.'_'.$locale] ?? $product[$handle.'_'.$fallbackLocale] ?? null;
-
-            foreach ($availableLocales as $availableLocale) {
-                unset($product[$handle.'_'.$availableLocale]);
-            }
-        }
-
-        return $product;
-    }
-
-    /**
-     * @return array<int, string>
-     */
-    private function translatedAttributeHandles(): array
-    {
-        return $this->attributes->getSearchableAttributes((new Product)->getMorphClass())
-            ->filter(fn ($attribute) => $attribute->type === TranslatedText::class)
-            ->pluck('handle')
-            ->all();
-    }
-
-    /**
-     * For the Meilisearch driver, Scout's paginateRaw() puts the whole raw response
-     * (hits, query, processingTimeMs, ...) in items(), not a plain list of hits - the
-     * actual documents are under the 'hits' key.
-     */
-    private function hitsFrom(LengthAwarePaginatorContract $paginator): array
-    {
-        $rawResponse = $paginator->items();
-
-        return collect($rawResponse['hits'] ?? [])->values()->all();
-    }
-
 }

src/Catalog/Support/ProductDocumentLocalizer.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace Modules\Core\Catalog\Support;
+
+use Illuminate\Contracts\Pagination\LengthAwarePaginator as LengthAwarePaginatorContract;
+use Illuminate\Support\Facades\App;
+use Lunar\Base\AttributeManifest;
+use Lunar\FieldTypes\TranslatedText;
+use Lunar\Models\Product;
+use Modules\Core\Localization\Services\LanguageCache;
+
+/**
+ * Shared between Modules\Core\Catalog\Services\ProductService and
+ * ProductSearchService — both read the same kind of Meilisearch document
+ * (Modules\Core\Catalog\Services\ProductIndexer's shape) and need the
+ * exact same per-locale field resolution and raw-response unwrapping.
+ * Extracted rather than duplicated so a future fix to the localization-
+ * fallback logic only needs to be made once.
+ */
+class ProductDocumentLocalizer
+{
+    public function __construct(
+        private readonly LanguageCache $languages,
+        private readonly AttributeManifest $attributes,
+    ) {}
+
+    /**
+     * Resolves every translated Product attribute's current-locale value from the
+     * indexer's per-locale `{handle}_{locale}` fields (e.g. `name_el`, `name_en`,
+     * `seo_title_el`, ...) into a plain `{handle}` key, falling back to the store's
+     * default language (LanguageCache::defaultLocale()) when the current locale
+     * has no translation - e.g. a product with no English copy yet still shows its
+     * Greek name on /en/ rather than rendering blank.
+     *
+     * Which handles are translated is read from AttributeManifest - the same
+     * source Lunar's own ScoutIndexer reads when exploding a TranslatedText
+     * attribute into `{handle}_{locale}` keys at index time - rather than a fixed
+     * list, so a store's own custom translated attributes (e.g. `seo_title`) are
+     * picked up automatically with no change here. The raw per-locale keys are
+     * then stripped, since once resolved, callers only ever need the one that
+     * matched the current locale.
+     *
+     * Deliberately not config('app.locale') - App::setLocale() overwrites that
+     * config value on every request, so by request time it's just whatever the
+     * current locale already is, not a stable fallback.
+     */
+    public function withLocalizedFields(array $product): array
+    {
+        $locale = App::getLocale();
+        $fallbackLocale = $this->languages->defaultLocale();
+        $availableLocales = $this->languages->availableLocales();
+
+        foreach ($this->translatedAttributeHandles() as $handle) {
+            $product[$handle] = $product[$handle.'_'.$locale] ?? $product[$handle.'_'.$fallbackLocale] ?? null;
+
+            foreach ($availableLocales as $availableLocale) {
+                unset($product[$handle.'_'.$availableLocale]);
+            }
+        }
+
+        return $product;
+    }
+
+    /**
+     * For the Meilisearch driver, Scout's paginateRaw() puts the whole raw response
+     * (hits, query, processingTimeMs, ...) in items(), not a plain list of hits - the
+     * actual documents are under the 'hits' key.
+     */
+    public function hitsFrom(LengthAwarePaginatorContract $paginator): array
+    {
+        $rawResponse = $paginator->items();
+
+        return collect($rawResponse['hits'] ?? [])->values()->all();
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function translatedAttributeHandles(): array
+    {
+        return $this->attributes->getSearchableAttributes((new Product)->getMorphClass())
+            ->filter(fn ($attribute) => $attribute->type === TranslatedText::class)
+            ->pluck('handle')
+            ->all();
+    }
+}

src/Checkout/Events/RecoveryConsentSet.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Modules\Core\Checkout\Events;
+
+use Lunar\Models\Cart;
+
+/**
+ * Dispatched by CheckoutService::setRecoveryConsent() every time the
+ * shopper's promotional/abandoned-cart-recovery opt-in changes — including
+ * an explicit opt-OUT (a later submit with the checkbox unticked), not
+ * just an opt-in. $consent is the new value, already written to
+ * Cart::meta by the time this fires.
+ */
+class RecoveryConsentSet
+{
+    public function __construct(
+        public readonly Cart $cart,
+        public readonly bool $consent,
+    ) {}
+}

src/Checkout/Exceptions/TermsNotAcceptedException.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Modules\Core\Checkout\Exceptions;
+
+use RuntimeException;
+
+/**
+ * Thrown by CheckoutService::initiatePayment() when $termsAccepted is
+ * false — an Order is a consumer contract, and its acceptance must be
+ * refused rather than created-then-flagged. No Lunar exception type
+ * covers this, same reasoning as UnknownPaymentTypeException.
+ */
+class TermsNotAcceptedException extends RuntimeException
+{
+    public function __construct()
+    {
+        parent::__construct('The order cannot be placed until the terms have been accepted.');
+    }
+}

src/Checkout/Services/CheckoutService.php

@@ -13,13 +13,16 @@ use Lunar\Models\Cart;
 use Modules\Core\Cart\Services\CartService;
 use Modules\Core\Checkout\Events\BillingAddressSet;
 use Modules\Core\Checkout\Events\PaymentMethodSelected;
+use Modules\Core\Checkout\Events\RecoveryConsentSet;
 use Modules\Core\Checkout\Events\ShippingAddressSet;
 use Modules\Core\Checkout\Events\ShippingOptionSelected;
 use Modules\Core\Checkout\Exceptions\InvalidShippingOptionException;
+use Modules\Core\Checkout\Exceptions\TermsNotAcceptedException;
 use Modules\Core\Checkout\Exceptions\UnknownPaymentTypeException;
 use Modules\Core\Payment\DTOs\PaymentResult;
 use Modules\Core\Payment\Models\PaymentMethod;
-use Modules\Core\Payment\Services\PaymentDriverResolver;
+use Modules\Core\Payment\Services\PaymentDriverRegistry;
+use Modules\Core\Payment\Services\PaymentMethodCache;
 
 /**
  * Storefront-facing checkout operations, mirroring
@@ -42,7 +45,8 @@ class CheckoutService
 {
     public function __construct(
         private readonly CartService $cart,
-        private readonly PaymentDriverResolver $paymentDrivers,
+        private readonly PaymentDriverRegistry $paymentDrivers,
+        private readonly PaymentMethodCache $paymentMethods,
     ) {}
 
     public function setShippingAddress(array|Addressable $address): Cart
@@ -63,6 +67,49 @@ class CheckoutService
         return $cart;
     }
 
+    /**
+     * The shopper's promotional/abandoned-cart-recovery opt-in — a
+     * cart-level decision, deliberately independent of setShippingAddress()/
+     * setBillingAddress(): consent is given once, and must NOT be reset or
+     * re-asked just because the shopper later changes which address is on
+     * the cart (a different Addressable being set is not a withdrawal of
+     * consent). Only an explicit call to THIS method — the checkbox itself
+     * being submitted, checked or unchecked — ever changes it; calling it
+     * again with false is exactly how a later opt-out is recorded.
+     *
+     * Stored on Cart::meta (interim, per the legal design this implements —
+     * a real column/consent record is the eventual target) as
+     * recovery_consent (bool), recovery_consent_at (ISO 8601 timestamp,
+     * null when $consent is false), and recovery_consent_policy_version
+     * (config('legal.privacy_policy_version') at the moment of consent —
+     * so a later dispute is answered from what was actually agreed to,
+     * not whatever the policy says today). Separate from any future
+     * newsletter opt-in — recovery consent is its own scope, never merged
+     * with marketing-newsletter consent.
+     *
+     * Deliberately does not merge with the meta-writing pattern
+     * selectPaymentMethod() uses (read-merge-save in two separate
+     * statements) — this writes both meta keys in one save, since there's
+     * no dependency between recovery_consent and anything else needing to
+     * be persisted first.
+     */
+    public function setRecoveryConsent(bool $consent): Cart
+    {
+        $cart = $this->cart->currentOrCreate();
+
+        $cart->meta = [
+            ...($cart->meta?->toArray() ?? []),
+            'recovery_consent' => $consent,
+            'recovery_consent_at' => $consent ? now()->toIso8601String() : null,
+            'recovery_consent_policy_version' => $consent ? config('legal.privacy_policy_version') : null,
+        ];
+        $cart->save();
+
+        Event::dispatch(new RecoveryConsentSet($cart, $consent));
+
+        return $cart;
+    }
+
     /**
      * Every shipping option currently available for the cart — already
      * fully backed by the merged Shipping-Carriers work: this runs every
@@ -100,54 +147,56 @@ class CheckoutService
     }
 
     /**
-     * Every payment type currently offered to the storefront — every key
+     * Every payment method currently offered to the storefront, ordered by
-     * in config('lunar.payments.types') that is BOTH administratively
+     * Modules\Core\Payment\Models\PaymentMethod::position — a row is
-     * enabled (Modules\Core\Payment\Models\PaymentMethod::enabled) AND
+     * offered only when ALL three checks pass, each meaning something
-     * whose registered driver reports itself usable right now
+     * different to an admin diagnosing why a method isn't showing up (see
-     * (Configurable::isConfigured() — e.g. Stripe with no API key set is
+     * docs/payments.md):
-     * never offered, regardless of the enabled toggle). A type with no
+     *   1. `enabled` — an admin turned it on.
-     * PaymentMethod row at all (never seeded) is treated as not offered,
+     *   2. its `driver` still resolves via PaymentDriverRegistry — the
-     * same as disabled — nothing here creates one; see
+     *      driver class hasn't been removed (see the `payment:sync-drivers`
-     * InstallLunarCommand::seedPaymentMethods().
+     *      command, which sets `driver_missing_at` when this fails; a row
+     *      with that set is excluded here regardless of `enabled`, so a
+     *      vanished driver can never silently look "available").
+     *   3. the resolved driver reports Configurable::isConfigured() — its
+     *      own runtime requirements (e.g. an API key) are met.
      *
-     * @return array<string>
+     * @return Collection<int, PaymentMethod>
      */
-    public function getPaymentMethods(): array
+    public function getPaymentMethods(): Collection
     {
-        return PaymentMethod::where('enabled', true)
+        return $this->paymentMethods->all()
-            ->pluck('type')
+            ->filter(fn (PaymentMethod $method) => $method->enabled && $method->driver_missing_at === null)
-            ->filter(fn (string $type) => $this->paymentDrivers->resolve($type)?->isConfigured() ?? false)
+            ->filter(fn (PaymentMethod $method) => $this->paymentDrivers->resolve($method->driver)?->isConfigured() ?? false)
-            ->values()
+            ->values();
-            ->all();
     }
 
     /**
      * Records which payment type the shopper picked (Cart::meta
-     * ['payment_method']) — read by e.g. Modules\Core\Payment\Pipelines\
+     * ['payment_method']) — read by Modules\Core\Payment\Pipelines\
-     * Cart\ApplyCashOnDeliveryFee to add that type's own cart-total
+     * Cart\ApplyPaymentMethodFee to add that method's own `data.fee` (if
-     * adjustments before recalculation.
+     * any) before recalculation.
      *
      * Also snapshots Cart::fingerprint() into meta, *after* saving the
      * chosen type — the fingerprint has to reflect the final total
-     * including any payment-type-specific adjustment (e.g. a COD
+     * including any payment-method-specific fee, which only exists once
-     * surcharge), which only exists once payment_method is set and the
+     * payment_method is set and the cart recalculates. Captured here,
-     * cart recalculates. Captured here, server-side, rather than asked of
+     * server-side, rather than asked of the storefront: this is the last
-     * the storefront: this is the last moment before initiatePayment() that
+     * moment before initiatePayment() that the shopper's reviewed total is
-     * the shopper's reviewed total is known, and initiatePayment() reads it
+     * known, and initiatePayment() reads it back internally instead of
-     * back internally instead of taking a fingerprint parameter — a
+     * taking a fingerprint parameter — a storefront should never need to
-     * storefront should never need to know Cart::fingerprint() exists.
+     * know Cart::fingerprint() exists.
      *
      * Does not itself call a payment driver — selecting a method and
      * initiating payment against it are deliberately separate steps, same
      * as selecting a shipping option happens before placing the order.
      *
      * @throws UnknownPaymentTypeException if $type isn't currently offered
-     *   — see getPaymentMethods() for what that means (registered,
+     *   — see getPaymentMethods() for what that means
-     *   administratively enabled, and its driver reports itself usable)
      */
     public function selectPaymentMethod(string $type): Cart
     {
-        if (! in_array($type, $this->getPaymentMethods(), true)) {
+        if (! $this->getPaymentMethods()->contains('type', $type)) {
             throw new UnknownPaymentTypeException($type);
         }
 
@@ -155,7 +204,15 @@ class CheckoutService
         $cart->meta = [...($cart->meta?->toArray() ?? []), 'payment_method' => $type];
         $cart->save();
 
-        $cart = $cart->calculate();
+        // Cart::calculate() no-ops if this cart instance was already
+        // calculated earlier in the request (Cart::isCalculated()) — which
+        // it will have been if the shopper switches payment method after
+        // the checkout page's first render already calculated it. Without
+        // recalculate() forcing a fresh run, the just-saved payment_method
+        // (and any fee tied to it, see ApplyPaymentMethodFee) would never
+        // be reflected — the summary would keep showing whichever method
+        // was calculated first.
+        $cart = $cart->recalculate();
         $cart->meta = [...($cart->meta?->toArray() ?? []), 'checkout_fingerprint' => $cart->fingerprint()];
         $cart->save();
 
@@ -170,11 +227,9 @@ class CheckoutService
      * Order exists (Cart::createOrder() — confirmed idempotent against a
      * cart's own pre-existing, not-yet-placed-at draft; see
      * vendor/lunarphp/core/src/Actions/Carts/CreateOrder.php), then
-     * resolves the payment type selected by selectPaymentMethod() and
+     * resolves the payment method selected by selectPaymentMethod() and
-     * calls pay() or authorize() on its driver, per that type's
+     * calls pay() or authorize() on its driver, per that method's own
-     * config('lunar.payments.types.{type}.capture_mode') — boboko-core's
+     * `capture_mode` column.
-     * own types (config/payment.php) are merged into that same Lunar
-     * config key by PaymentServiceProvider::boot().
      *
      * Returns the driver's own PaymentResult UNCHANGED — this method does
      * not wait for or resolve anything past what pay()/authorize() itself
@@ -183,14 +238,6 @@ class CheckoutService
      * outcome, not an error — the caller (a storefront controller) is
      * responsible for whatever the gateway needs next.
      *
-     * KNOWN GAP, explicitly out of scope for now: PaymentResult alone does
-     * not carry gateway-specific continuation data (e.g. Stripe's
-     * PaymentIntent client_secret for a Pending result needing frontend
-     * confirmation) — that concept existed on the deleted PaymentInitiation
-     * DTO and was intentionally removed from Payment's abstraction layer.
-     * Nothing here re-introduces it; only OfflinePaymentDriver's
-     * always-Immediate-Succeeded path is fully wired end-to-end today.
-     *
      * The draft order's own $order->total (not the Cart's) is what gets
      * passed as $amount — Order::$total is Lunar's own Price-cast
      * attribute, already resolving the correct Currency via the order's
@@ -204,36 +251,62 @@ class CheckoutService
      * Same fingerprint precondition the old placeOrder() had: mandatory,
      * not optional, checked before the draft is created.
      *
+     * $termsAccepted is likewise mandatory, not optional data a caller
+     * might omit — an Order is a consumer contract, and its acceptance
+     * must be refused (TermsNotAcceptedException, before createOrder() is
+     * ever called — the order is never created-then-flagged) rather than
+     * assumed. $policyVersion is recorded alongside it on the created
+     * Order's own meta (terms_accepted, terms_accepted_at,
+     * terms_accepted_policy_version) — the order-level equivalent of
+     * setRecoveryConsent()'s cart-level record, and the durable audit
+     * trail for a later "what did the shopper actually agree to"
+     * dispute. Written directly here (not via a separate event/listener)
+     * since the Order row this attaches to doesn't exist before
+     * createOrder() runs, and nothing else needs to react to this
+     * specific write independently of the order simply existing.
+     *
      * @param  array<string, mixed>  $data  passed through untouched to
      *   the driver's pay()/authorize() — e.g. Stripe's payment_method
      *   token.
      *
      * @throws UnknownPaymentTypeException if the cart's selected
      *   payment_method (from selectPaymentMethod()) is no longer offered
-     *   — re-checked here, not just at selection time, since a type could
+     *   — re-checked here, not just at selection time, since a method
-     *   be disabled in between
+     *   could be disabled (or its driver removed) in between
+     * @throws TermsNotAcceptedException if $termsAccepted is false
      * @throws FingerprintMismatchException
      * @throws CartException
      */
-    public function initiatePayment(string $fingerprint, array $data = []): PaymentResult
+    public function initiatePayment(string $fingerprint, bool $termsAccepted, string $policyVersion, array $data = []): PaymentResult
     {
+        if (! $termsAccepted) {
+            throw new TermsNotAcceptedException;
+        }
+
         $cart = $this->cart->currentOrCreate();
         $cart->checkFingerprint($fingerprint);
 
         $type = $cart->meta['payment_method'] ?? null;
+        $method = $type !== null ? $this->getPaymentMethods()->firstWhere('type', $type) : null;
 
-        if ($type === null || ! in_array($type, $this->getPaymentMethods(), true)) {
+        if ($method === null) {
             throw new UnknownPaymentTypeException((string) $type);
         }
 
         $order = $cart->createOrder();
 
-        $driver = $this->paymentDrivers->resolve($type);
+        $order->meta = [
-        $captureMode = config("lunar.payments.types.{$type}.capture_mode", 'pay');
+            ...($order->meta?->toArray() ?? []),
+            'terms_accepted' => true,
+            'terms_accepted_at' => now()->toIso8601String(),
+            'terms_accepted_policy_version' => $policyVersion,
+        ];
+        $order->save();
 
+        $driver = $this->paymentDrivers->resolve($method->driver);
         $context = ['cart_id' => $cart->id, 'order_id' => $order->id];
 
-        return $captureMode === 'authorize'
+        return $method->capture_mode === 'authorize'
             ? $driver->authorize($type, $order->total, $data, $context)
             : $driver->pay($type, $order->total, $data, $context);
     }

src/Command/InstallLunarCommand.php

@@ -284,35 +284,39 @@ class InstallLunarCommand extends Command
     }
 
     /**
-     * Per-type skip-if-exists, same idempotent convention as
+     * A single, deliberately opinionated starter row on fresh install —
-     * seedStorefrontLabels() — a type already present (including one an
+     * `PaymentMethod` is now fully admin-creatable/deletable (see
-     * admin has since edited via the Filament Payment Methods resource) is
+     * docs/payments.md), so this is no longer "seed every config-defined
-     * left untouched. Safe to re-run after a new payment type is added to
+     * type," it's "give a fresh store one reasonable payment method to
-     * config('lunar.payments.types') (e.g. installing a Stripe/Nexi
+     * start from instead of zero." Every value here is a plain literal in
-     * package), which is the whole reason this isn't a one-time-only seed.
+     * THIS command, not sourced from config or PaymentDriverRegistry — a
+     * driver has no business carrying opinions about what its captured
+     * order status should be called; that's a merchant decision.
      *
-     * Seeded disabled — a newly-seeded row (whether from this store's
+     * Skip-if-exists on `type`, same idempotent convention as
-     * initial install, or a payment provider package installed later)
+     * seedStorefrontLabels() — an admin who has since edited or deleted
-     * shouldn't go live for shoppers before staff have actually reviewed
+     * this row (via the Filament Payment Methods resource) is left alone;
-     * it (real credentials configured, a fee set, etc.) and turned it on
+     * re-running lunar:install never recreates a deleted starter row.
-     * via the Payment Methods resource. See CheckoutService::
+     *
-     * getPaymentMethods(), which only offers a type once both 'enabled'
+     * Seeded disabled — shouldn't go live for shoppers before staff have
-     * here and its driver's own isConfigured() check pass.
+     * actually reviewed it and turned it on via the Payment Methods
+     * resource. See CheckoutService::getPaymentMethods().
      */
     private function seedPaymentMethods(): void
     {
-        $existingTypes = PaymentMethod::pluck('type');
+        if (PaymentMethod::where('type', 'cash-on-delivery')->exists()) {
-
+            return;
-        foreach (array_keys(config('lunar.payments.types', [])) as $type) {
-            if ($existingTypes->contains($type)) {
-                continue;
-            }
-
-            PaymentMethod::create([
-                'type' => $type,
-                'enabled' => false,
-                'data' => [],
-            ]);
         }
+
+        PaymentMethod::create([
+            'type' => 'cash-on-delivery',
+            'name' => 'Cash on Delivery',
+            'driver' => 'offline',
+            'capture_mode' => 'pay',
+            'captured_status' => 'payment-offline',
+            'position' => 0,
+            'enabled' => false,
+            'data' => [],
+        ]);
     }
 }

src/Command/SyncPaymentDriversCommand.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Modules\Core\Command;
+
+use Illuminate\Console\Command;
+use Modules\Core\Payment\Models\PaymentMethod;
+use Modules\Core\Payment\Services\PaymentDriverRegistry;
+
+/**
+ * Reconciles every Modules\Core\Payment\Models\PaymentMethod row's `driver`
+ * column against PaymentDriverRegistry — the registry only knows "which
+ * driver classes exist THIS deploy," and only at the moment something
+ * calls resolve(); nothing else notices a driver disappearing (a package
+ * removed, a custom Registry::register() call deleted) on its own. Meant
+ * to run unconditionally on every container start/deploy (alongside
+ * `migrate`), not on a schedule — "did the set of registered drivers
+ * change" is a deploy-time event, cheap enough to check every single time
+ * regardless of whether anything actually changed. See docs/payments.md.
+ *
+ * Sets/clears `driver_missing_at` — deliberately NOT the `enabled` column,
+ * so an admin's own manual toggle is never confused with "the driver
+ * vanished," and a driver that comes back in a later deploy auto-clears
+ * this with no admin action needed.
+ */
+class SyncPaymentDriversCommand extends Command
+{
+    protected $signature = 'boboko:payment:sync-drivers';
+
+    protected $description = 'Flag PaymentMethod rows whose driver no longer resolves via the registry, and clear the flag for ones that do again';
+
+    public function handle(PaymentDriverRegistry $registry): int
+    {
+        $missing = 0;
+        $restored = 0;
+
+        PaymentMethod::query()->each(function (PaymentMethod $method) use ($registry, &$missing, &$restored) {
+            $resolves = $method->driver !== null && $registry->resolve($method->driver) !== null;
+
+            if (! $resolves && $method->driver_missing_at === null) {
+                $method->update(['driver_missing_at' => now()]);
+                $missing++;
+            } elseif ($resolves && $method->driver_missing_at !== null) {
+                $method->update(['driver_missing_at' => null]);
+                $restored++;
+            }
+        });
+
+        $this->components->info("Payment driver sync complete: {$missing} newly flagged, {$restored} restored.");
+
+        return self::SUCCESS;
+    }
+}

src/CorePlugin.php

@@ -3,6 +3,7 @@
 namespace Modules\Core;
 
 use Lunar\Admin\Filament\Resources\OrderResource\Pages\ManageOrder;
+use Lunar\Admin\Filament\Resources\OrderResource\Pages\Components\OrderItemsTable;
 use Filament\Contracts\Plugin;
 use Filament\Panel;
 use Illuminate\Database\Eloquent\Relations\HasMany;
@@ -25,6 +26,9 @@ use Modules\Core\Cart\Filament\Resources\CartResource;
 use Modules\Core\Catalog\Filament\Extensions\ProductOptionResourceExtension;
 use Modules\Core\Catalog\Filament\Extensions\ValuesRelationManagerExtension;
 use Modules\Core\Localization\Filament\Resources\LanguageLineResource;
+use Modules\Core\Order\Filament\Extensions\OrderItemsTableExtension;
+use Modules\Core\Order\Filament\Extensions\OrderRefundActionsExtension;
+use Modules\Core\Order\Filament\Extensions\OrderTransactionsExtension;
 use Modules\Core\Payment\Filament\Resources\PaymentMethodResource;
 use Modules\Core\Review\Filament\Extensions\ProductResourceExtension;
 use Modules\Core\Review\Models\ProductReview;
@@ -62,7 +66,8 @@ class CorePlugin implements Plugin
             ValuesRelationManager::class => ValuesRelationManagerExtension::class,
             ShippingMethodResource::class => ShippingMethodResourceExtension::class,
             ListShippingMethod::class => ShippingMethodListExtension::class,
-            ManageOrder::class => OrderViewExtension::class,
+            ManageOrder::class => [OrderViewExtension::class, OrderRefundActionsExtension::class, OrderTransactionsExtension::class],
+            OrderItemsTable::class => OrderItemsTableExtension::class,
         ]);
 
         Product::macro('reviews', function (): HasMany {

src/Localization/Services/StorefrontLabels.php

@@ -24,6 +24,7 @@ class StorefrontLabels
             'nav.account' => ['en' => 'Account', 'el' => 'Λογαριασμός'],
             'nav.back' => ['en' => 'Back', 'el' => 'Πίσω'],
             'nav.contact' => ['en' => 'Contact', 'el' => 'Επικοινωνία'],
+            'nav.close' => ['en' => 'Close', 'el' => 'Κλείσιμο'],
             'cart.empty' => ['en' => 'Your cart is empty', 'el' => 'Το καλάθι σας είναι άδειο'],
             'cart.checkout' => ['en' => 'Checkout', 'el' => 'Ολοκλήρωση Παραγγελίας'],
             'cart.total' => ['en' => 'Total', 'el' => 'Σύνολο'],
@@ -38,6 +39,7 @@ class StorefrontLabels
             'auth.login' => ['en' => 'Log In', 'el' => 'Σύνδεση'],
             'auth.logout' => ['en' => 'Log Out', 'el' => 'Αποσύνδεση'],
             'search.placeholder' => ['en' => 'Search products…', 'el' => 'Αναζήτηση προϊόντων…'],
+            'search.results_for' => ['en' => 'Search results for ', 'el' => 'Αποτελέσματα αναζήτησης για '],
             'customer_reviews' => [
                 'en' => '{0} No customer reviews|{1} :count customer review|[2,*] :count customer reviews',
                 'el' => '{0} Καμία αξιολόγηση πελάτη|{1} :count αξιολόγηση πελάτη|[2,*] :count αξιολογήσεις πελατών',
@@ -66,6 +68,7 @@ class StorefrontLabels
                 'en' => '{0} No products found|{1} Showing :first–:last of :total result|[2,*] Showing :first–:last of :total results',
                 'el' => '{0} Δεν βρέθηκαν προϊόντα|{1} Εμφάνιση :first–:last από :total αποτέλεσμα|[2,*] Εμφάνιση :first–:last από :total αποτελέσματα',
             ],
+            'shop.all_products' => ['en' => 'All Products', 'el' => 'Όλα τα Προϊόντα'],
             'shop.sort_label' => ['en' => 'Sort products', 'el' => 'Ταξινόμηση προϊόντων'],
             'shop.sort_default' => ['en' => 'Default sorting', 'el' => 'Προεπιλεγμένη ταξινόμηση'],
             'shop.sort_popularity' => ['en' => 'Popularity', 'el' => 'Δημοφιλή'],

src/Order/Filament/Extensions/OrderItemsTableExtension.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Modules\Core\Order\Filament\Extensions;
+
+use Filament\Actions\BulkAction;
+use Filament\Support\Exceptions\Halt;
+use Filament\Tables\Table;
+use Lunar\Admin\Support\Extending\BaseExtension;
+
+/**
+ * Same fix as OrderRefundActionsExtension, applied to the order lines
+ * table's "bulk_refund" toolbar action (Lunar\Admin\...\OrderItemsTable::
+ * getBulkRefundAction()) — see that class's docblock for the underlying
+ * Filament bug (failureNotification()+failure()+halt() never actually
+ * sends the notification, because halt()'s Halt exception is caught before
+ * Filament reaches the code that would send it).
+ */
+class OrderItemsTableExtension extends BaseExtension
+{
+    public function extendTable(Table $table): Table
+    {
+        return $table->toolbarActions(
+            array_map(
+                fn ($action) => $action instanceof BulkAction && $action->getName() === 'bulk_refund'
+                    ? $this->fixFailureNotification($action)
+                    : $action,
+                $table->getToolbarActions(),
+            ),
+        );
+    }
+
+    private function fixFailureNotification(BulkAction $action): BulkAction
+    {
+        $originalAction = $action->getActionFunction();
+
+        if ($originalAction === null) {
+            return $action;
+        }
+
+        return $action->action(function (array $arguments) use ($action, $originalAction) {
+            try {
+                return $action->evaluate($originalAction, $arguments);
+            } catch (Halt $exception) {
+                $action->sendFailureNotification();
+
+                throw $exception;
+            }
+        });
+    }
+}

src/Order/Filament/Extensions/OrderRefundActionsExtension.php

@@ -0,0 +1,199 @@
+<?php
+
+namespace Modules\Core\Order\Filament\Extensions;
+
+use Filament\Actions\Action;
+use Filament\Forms\Components\Select;
+use Filament\Notifications\Notification;
+use Filament\Support\Exceptions\Halt;
+use Lunar\Admin\Support\Extending\ViewPageExtension;
+use Lunar\Models\Transaction;
+use Modules\Core\Payment\Contracts\SupportsRefunds;
+use Modules\Core\Payment\Models\CoreTransaction;
+use Modules\Core\Payment\Services\PaymentDriverRegistry;
+use Modules\Core\Payment\Support\TransactionDriverAdapter;
+use ReflectionProperty;
+
+/**
+ * Fixes a real bug in Lunar's own admin panel, not anything specific to how
+ * boboko resolves payment drivers: ManageOrder::getRefundAction() and
+ * ::getCaptureAction() (vendor/lunarphp/lunar/.../ManageOrder.php) both
+ * report a failed refund/capture by calling, in this order:
+ *   $action->failureNotification(...); $action->failure(); $action->halt();
+ * but Filament\Actions\Concerns\InteractsWithActions::callMountedAction()
+ * only ever calls sendFailureNotification() from a match($action->getStatus())
+ * block that runs AFTER the action's call() returns normally — halt() throws
+ * Filament\Support\Exceptions\Halt, which is caught in an earlier catch block
+ * that rolls back the DB transaction and returns null, never reaching that
+ * match block. So the notification set via failureNotification() is built
+ * but never sent: the admin sees the modal just close/reset with no
+ * indication anything happened. This was always broken in Lunar; it was
+ * invisible before because nothing in this codebase's Transaction::driver()
+ * could return a real, honest failure — see Payment\Support\
+ * TransactionDriverAdapter's own docblock for that history.
+ *
+ * Fix, for capture: wrap the action's own action() closure so that, on
+ * Halt, we call $action->sendFailureNotification() ourselves before letting
+ * the Halt continue propagating — everything else is untouched.
+ *
+ * Fix, for refund: same notification fix, but the action() closure is
+ * replaced outright (not wrapped) rather than reused, because refund also
+ * needs a "Refund via" driver Select added to the modal (see
+ * fixRefundAction()) and the actual call routed through
+ * Payment\Support\TransactionDriverAdapter::refundVia() instead of
+ * Lunar\Models\Transaction::refund() — see fixRefundAction()'s own
+ * docblock.
+ */
+class OrderRefundActionsExtension extends ViewPageExtension
+{
+    public function headerActions(array $actions): array
+    {
+        return array_map(
+            fn (Action $action) => match ($action->getName()) {
+                'refund' => $this->fixRefundAction($action),
+                'capture' => $this->fixFailureNotification($action),
+                default => $action,
+            },
+            $actions,
+        );
+    }
+
+    /**
+     * Combines both refund-only changes on top of the failure-notification
+     * fix every action here gets: adds a "Refund via" driver Select
+     * (defaulting to the transaction's own driver) to the modal, and
+     * replaces the actual refund call with one that honours that field —
+     * calling Payment\Support\TransactionDriverAdapter::refundVia()
+     * directly (bypassing Lunar\Models\Transaction::refund(), whose fixed
+     * refund(int $amount, $notes = null) signature has no room for a
+     * driver override) whenever the admin picked a driver other than the
+     * transaction's own. When left at the default, behaviour is identical
+     * to calling $transaction->refund() — refundVia() resolves to the same
+     * driver either way.
+     *
+     * The Select is appended to Lunar's own schema closure (read via
+     * reflection — HasSchema::$schema has no public getter) rather than
+     * replacing it outright, so the transaction/amount/notes/confirm
+     * fields Lunar already built are untouched.
+     */
+    private function fixRefundAction(Action $action): Action
+    {
+        $originalSchema = $this->readProtectedProperty($action, 'schema');
+
+        $action->schema(function (array $arguments) use ($action, $originalSchema) {
+            $fields = is_callable($originalSchema)
+                ? $action->evaluate($originalSchema, $arguments)
+                : ($originalSchema ?? []);
+
+            return [
+                ...$fields,
+                Select::make('driver')
+                    ->label('Refund via')
+                    ->options(fn () => $this->refundCapableDriverLabels())
+                    ->default(fn ($get) => $this->driverKeyForTransaction($get('transaction')))
+                    ->native(false)
+                    ->required(),
+            ];
+        });
+
+        return $action->action(function (array $data, Action $action) {
+            $transaction = Transaction::find($data['transaction']);
+
+            if (! $transaction instanceof CoreTransaction) {
+                $action->failureNotification(fn () => Notification::make('refund_failure')->danger()->title('Transaction not found.'))
+                    ->sendFailureNotification();
+
+                throw new Halt;
+            }
+
+            $adapter = app(TransactionDriverAdapter::class);
+            $driverKey = $data['driver'] ?? $adapter->driverKeyFor($transaction);
+
+            $response = $adapter->refundVia($transaction, $driverKey, (int) bcmul((string) $data['amount'], (string) $transaction->order->currency->factor), $data['notes'] ?? null);
+
+            if (! $response->success) {
+                $action->failureNotification(
+                    fn () => Notification::make('refund_failure')->color('danger')->title($response->message)
+                )->sendFailureNotification();
+
+                throw new Halt;
+            }
+
+            $action->success();
+        });
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function refundCapableDriverLabels(): array
+    {
+        $registry = app(PaymentDriverRegistry::class);
+
+        $labels = [];
+
+        foreach ($registry->all() as $key => $driverClass) {
+            if (app($driverClass) instanceof SupportsRefunds) {
+                $labels[$key] = $registry->label($key) ?? $key;
+            }
+        }
+
+        return $labels;
+    }
+
+    private function driverKeyForTransaction(mixed $transactionId): ?string
+    {
+        if (blank($transactionId)) {
+            return null;
+        }
+
+        $transaction = Transaction::find($transactionId);
+
+        if (! $transaction instanceof CoreTransaction) {
+            return null;
+        }
+
+        return app(TransactionDriverAdapter::class)->driverKeyFor($transaction);
+    }
+
+    private function readProtectedProperty(object $object, string $property): mixed
+    {
+        $reflected = new ReflectionProperty($object, $property);
+        $reflected->setAccessible(true);
+
+        return $reflected->getValue($object);
+    }
+
+    /**
+     * Wraps the action's own configured action() closure so that, if it
+     * halts (Lunar's closures throw via $action->halt() to signal failure —
+     * see this class's own docblock for why that alone never sends the
+     * notification queued via failureNotification()), we send that
+     * notification ourselves before letting the Halt continue propagating
+     * (still needed — it's what stops callMountedAction() from treating
+     * this as a success and closing the modal/committing the DB transaction).
+     *
+     * $this->evaluate() (not a plain call) matches exactly how Action::call()
+     * itself invokes the closure — Lunar's closures type-hint $data/$record/
+     * $action and rely on Filament's own container-style parameter
+     * resolution, not positional arguments.
+     */
+    private function fixFailureNotification(Action $action): Action
+    {
+        $originalAction = $action->getActionFunction();
+
+        if ($originalAction === null) {
+            return $action;
+        }
+
+        return $action->action(function (array $arguments) use ($action, $originalAction) {
+            try {
+                return $action->evaluate($originalAction, $arguments);
+            } catch (Halt $exception) {
+                $action->sendFailureNotification();
+
+                throw $exception;
+            }
+        });
+    }
+}

src/Order/Filament/Extensions/OrderTransactionsExtension.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Modules\Core\Order\Filament\Extensions;
+
+use Filament\Infolists\Components\RepeatableEntry;
+use Lunar\Admin\Support\Extending\ViewPageExtension;
+use Modules\Core\Order\Filament\Infolists\TransactionEntry;
+
+/**
+ * Swaps Lunar\Admin\Support\Infolists\Components\Transaction for our own
+ * TransactionEntry in the order page's transactions list — same component,
+ * different Blade view, so a Transaction.meta['notes'] value (written by
+ * a manual/attested driver like Payment\Drivers\BankTransferPaymentDriver)
+ * actually renders somewhere, instead of only the notes column Lunar's own
+ * view reads (see TransactionEntry's own docblock for why that column is
+ * usually empty for a successful manual payment/refund).
+ *
+ * Uses the extendTransactionsRepeatableEntry hook ManageOrder's own
+ * DisplaysTransactions trait already calls
+ * (getTransactionsRepeatableEntry() → callStaticLunarHook(
+ * 'extendTransactionsRepeatableEntry', ...)) — a class/component swap via
+ * a Lunar-provided hook, the same category of extension already used
+ * throughout CorePlugin, not a Blade view-path override.
+ */
+class OrderTransactionsExtension extends ViewPageExtension
+{
+    public function extendTransactionsRepeatableEntry(RepeatableEntry $entry): RepeatableEntry
+    {
+        return $entry->schema([
+            TransactionEntry::make('transaction_detail'),
+        ]);
+    }
+}

src/Order/Filament/Infolists/TransactionEntry.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Modules\Core\Order\Filament\Infolists;
+
+use Lunar\Admin\Support\Infolists\Components\Transaction as LunarTransactionEntry;
+
+/**
+ * Same component as Lunar's own Transaction infolist entry — only the
+ * Blade view differs, to also show Transaction.meta['notes'] (what
+ * Payment\Drivers\BankTransferPaymentDriver and any other manual/attested
+ * driver write a staff-entered note into — see that driver's own
+ * docblock) when the notes column itself is empty. The notes column is
+ * populated by Order\Services\TransactionRecorder from
+ * PaymentResult::$failureReason, which is only ever set on a FAILED
+ * result — a successful manual payment/refund's note would otherwise be
+ * recorded (Transaction.meta) but never shown anywhere in the admin
+ * panel, since Lunar's own view only ever reads the notes column.
+ *
+ * Registered in place of Lunar's own Transaction component via
+ * Order\Filament\Extensions\OrderTransactionsExtension's
+ * extendTransactionsRepeatableEntry() hook (see that class), not a
+ * view-path override — this is the same "swap the concrete
+ * class/component" pattern already used throughout CorePlugin
+ * (LunarPanel::extensions()), rather than shadowing Lunar's Blade file
+ * from underneath it.
+ */
+class TransactionEntry extends LunarTransactionEntry
+{
+    protected string $view = 'core::order.infolists.transaction';
+}

src/Order/Listeners/ApplyResolvedPaymentStatus.php

@@ -7,13 +7,17 @@ use Lunar\Models\Order;
 use Modules\Core\Checkout\Events\OrderPlaced;
 use Modules\Core\Payment\Events\PaymentAuthorized;
 use Modules\Core\Payment\Events\PaymentCaptured;
+use Modules\Core\Payment\Events\PaymentRefunded;
+use Modules\Core\Payment\Models\PaymentMethod;
+use Modules\Core\Payment\Services\PaymentMethodCache;
 
 /**
  * The only place an Order's status column is written in reaction to a
- * payment outcome. Registered against BOTH PaymentCaptured and
+ * payment outcome. Registered against PaymentCaptured, PaymentAuthorized,
- * PaymentAuthorized (see OrderServiceProvider) — same handler either way,
+ * AND PaymentRefunded (see OrderServiceProvider) — same handler for all
- * since both carry the same {type, result, context} shape and only differ
+ * three, differing only in which PaymentMethod column decides the
- * in which config key decides the resulting status.
+ * resulting status and, for a refund, which PaymentMethod row that even
+ * is (see resolvePaymentMethod()).
  *
  * Reads $event->context['order_id'] to find which Order this outcome
  * belongs to — Payment has no concept of an Order, so this is the one
@@ -28,11 +32,19 @@ use Modules\Core\Payment\Events\PaymentCaptured;
  *
  * Dispatches Checkout\Events\OrderPlaced itself, once placed_at is set —
  * see that event's own docblock for why this, not CheckoutService, is now
- * the dispatch point.
+ * the dispatch point. Never fires from the PaymentRefunded path — a
+ * refund can only ever happen after an order was already placed.
+ *
+ * Deliberately does NOT react to PaymentVoided — see PaymentMethod's own
+ * docblock for why there's no void_status column at all yet.
  */
 class ApplyResolvedPaymentStatus
 {
-    public function handle(PaymentCaptured|PaymentAuthorized $event): void
+    public function __construct(
+        private readonly PaymentMethodCache $paymentMethods,
+    ) {}
+
+    public function handle(PaymentCaptured|PaymentAuthorized|PaymentRefunded $event): void
     {
         $orderId = $event->context['order_id'] ?? null;
 
@@ -42,8 +54,13 @@ class ApplyResolvedPaymentStatus
 
         $order = Order::findOrFail($orderId);
 
-        $configKey = $event instanceof PaymentCaptured ? 'captured_status' : 'authorized_status';
+        $method = $this->resolvePaymentMethod($event, $order);
-        $status = config("lunar.payments.types.{$event->type}.{$configKey}");
+        $column = match (true) {
+            $event instanceof PaymentCaptured => 'captured_status',
+            $event instanceof PaymentAuthorized => 'authorized_status',
+            $event instanceof PaymentRefunded => 'refunded_status',
+        };
+        $status = $method?->{$column};
 
         if ($status === null) {
             return;
@@ -56,8 +73,40 @@ class ApplyResolvedPaymentStatus
             'placed_at' => $order->placed_at ?? now(),
         ]);
 
-        if (! $wasPlaced) {
+        if (! $wasPlaced && ! $event instanceof PaymentRefunded) {
             Event::dispatch(new OrderPlaced($order));
         }
     }
+
+    /**
+     * PaymentCaptured/PaymentAuthorized carry $event->type as the
+     * PaymentMethod.type that was actually charged — a direct lookup.
+     *
+     * PaymentRefunded's $event->type is the REFUND driver's own registry
+     * key (e.g. 'bank-transfer' — see BankTransferPaymentDriver::refund()),
+     * which may not correspond to any PaymentMethod row at all when the
+     * admin refunded through a different driver than the one that took
+     * the original payment (Payment\Support\TransactionDriverAdapter::
+     * refundVia()). refunded_status is a business decision about the
+     * ORIGINAL payment method, not the refund mechanism, so this instead
+     * finds the order's earliest successful capture/intent transaction —
+     * the actual payment the refund is reversing — and resolves that
+     * transaction's own driver (a real PaymentMethod.type) instead.
+     */
+    private function resolvePaymentMethod(PaymentCaptured|PaymentAuthorized|PaymentRefunded $event, Order $order): ?PaymentMethod
+    {
+        if (! $event instanceof PaymentRefunded) {
+            return $this->paymentMethods->all()->firstWhere('type', $event->type);
+        }
+
+        $originalType = $order->transactions()
+            ->whereIn('type', ['capture', 'intent'])
+            ->where('success', true)
+            ->oldest('created_at')
+            ->value('driver');
+
+        return $originalType !== null
+            ? $this->paymentMethods->all()->firstWhere('type', $originalType)
+            : null;
+    }
 }

src/Payment/Drivers/BankTransferPaymentDriver.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Modules\Core\Payment\Drivers;
+
+use Illuminate\Support\Str;
+use Lunar\DataTypes\Price;
+use Modules\Core\Payment\Contracts\Configurable;
+use Modules\Core\Payment\Contracts\SupportsPay;
+use Modules\Core\Payment\Contracts\SupportsRefunds;
+use Modules\Core\Payment\DTOs\PaymentResult;
+use Modules\Core\Payment\Enums\PaymentResultStatus;
+use Modules\Core\Payment\Events\PaymentCaptured;
+use Modules\Core\Payment\Events\PaymentRefunded;
+
+/**
+ * Manual/attested, same trust model as OfflinePaymentDriver — there is no
+ * bank API to call, so both pay() and refund() decide success immediately
+ * on a staff member's say-so (they've already sent/received the wire
+ * outside the system). Distinct from OfflinePaymentDriver in intent: this
+ * exists so a payment taken through a DIFFERENT method (e.g.
+ * cash-on-delivery) can still be REFUNDED via bank transfer — an admin
+ * chooses this driver explicitly in the refund action, independent of
+ * which driver the original payment went through (see
+ * Payment\Support\TransactionDriverAdapter::refundVia() and
+ * Order\Filament\Extensions\OrderRefundActionsExtension). pay() exists so
+ * the same driver also covers receiving a payment by bank transfer, but
+ * the admin UI for that (bank reference, notes, proof-of-transfer upload)
+ * is deliberately not built yet — see the follow-up work tracked from this
+ * session; pay() itself is complete and usable via the registry today.
+ *
+ * $reference is generated here for the same reason as OfflinePaymentDriver's
+ * pay(): there is no gateway to hand one back. 'notes' in $context (not
+ * $data — refund() has no $data parameter) is folded into
+ * PaymentResult::$meta, which Order\Services\TransactionRecorder::record()
+ * already writes straight into Transaction.meta with no extra plumbing.
+ */
+class BankTransferPaymentDriver implements Configurable, SupportsPay, SupportsRefunds
+{
+    /**
+     * Always true — no external dependency to be missing.
+     */
+    public function isConfigured(): bool
+    {
+        return true;
+    }
+
+    public function pay(string $type, Price $amount, array $data = [], array $context = []): PaymentResult
+    {
+        $result = new PaymentResult(
+            status: PaymentResultStatus::Succeeded,
+            reference: 'bank-transfer-'.Str::uuid(),
+            amount: $amount,
+            meta: array_filter(['notes' => $data['notes'] ?? null]),
+        );
+
+        PaymentCaptured::dispatch($type, $result, $context);
+
+        return $result;
+    }
+
+    public function refund(string $reference, Price $amount, array $context = []): PaymentResult
+    {
+        $result = new PaymentResult(
+            status: PaymentResultStatus::Succeeded,
+            reference: 'bank-transfer-'.Str::uuid(),
+            amount: $amount,
+            meta: array_filter(['notes' => $context['notes'] ?? null]),
+        );
+
+        PaymentRefunded::dispatch('bank-transfer', $result, $context);
+
+        return $result;
+    }
+}

src/Payment/Drivers/StripePaymentDriver.php

@@ -95,17 +95,21 @@ class StripePaymentDriver implements
 
     private function createAndConfirm(string $type, Price $amount, array $data, array $context, string $captureMethod): PaymentResult
     {
+        $params = [
+            'amount' => StripeManager::toStripeAmount($amount->value, $amount->currency),
+            'currency' => $amount->currency->code,
+            'capture_method' => $captureMethod,
+            'confirm' => true,
+        ];
+
+        if (isset($data['payment_method'])) {
+            $params['payment_method'] = $data['payment_method'];
+        } else {
+            $params['automatic_payment_methods'] = ['enabled' => true];
+        }
+
         try {
-            $paymentIntent = Stripe::getClient()->paymentIntents->create([
+            $paymentIntent = Stripe::getClient()->paymentIntents->create($params);
-                'amount' => StripeManager::toStripeAmount($amount->value, $amount->currency),
-                'currency' => $amount->currency->code,
-                'capture_method' => $captureMethod,
-                'confirm' => true,
-                'payment_method' => $data['payment_method'] ?? null,
-                'automatic_payment_methods' => isset($data['payment_method'])
-                    ? null
-                    : ['enabled' => true],
-            ]);
         } catch (ApiErrorException $e) {
             return $this->declined($type, $amount, $e, $context, authorizing: $captureMethod === 'manual');
         }

src/Payment/Events/PaymentMethodCreated.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Modules\Core\Payment\Models\PaymentMethod;
+
+class PaymentMethodCreated
+{
+    public function __construct(
+        public readonly PaymentMethod $method,
+    ) {}
+}

src/Payment/Events/PaymentMethodDeleted.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+class PaymentMethodDeleted
+{
+    /**
+     * @param  array<string, mixed>  $method  Snapshot of the deleted row —
+     *   already gone from the database by dispatch time, so this can't be
+     *   a fresh PaymentMethod model instance.
+     */
+    public function __construct(
+        public readonly array $method,
+    ) {}
+}

src/Payment/Events/PaymentMethodUpdated.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Modules\Core\Payment\Models\PaymentMethod;
+
+class PaymentMethodUpdated
+{
+    /**
+     * @param  array<string, mixed>  $old  Snapshot of the changed attributes
+     *   before the update.
+     */
+    public function __construct(
+        public readonly PaymentMethod $method,
+        public readonly array $old,
+    ) {}
+}

src/Payment/Events/PaymentMethodsReordered.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+class PaymentMethodsReordered
+{
+    /**
+     * @param  array<int, int>  $ids  PaymentMethod ids, in their new order —
+     *   the same array Filament's own reorderTable() already wrote to the
+     *   database directly (bulk SQL, not PaymentMethodService::update() —
+     *   see PaymentMethodResource's own docblock for why this is the one
+     *   PaymentMethod write that doesn't go through the service).
+     */
+    public function __construct(
+        public readonly array $ids,
+    ) {}
+}

src/Payment/Filament/Resources/PaymentMethodResource.php

@@ -3,21 +3,63 @@
 namespace Modules\Core\Payment\Filament\Resources;
 
 use Filament\Actions\Action;
+use Filament\Forms\Components\Select;
 use Filament\Forms\Components\TextInput;
 use Filament\Resources\Resource;
+use Filament\Schemas\Components\Component;
+use Filament\Schemas\Components\Utilities\Get;
+use Filament\Tables\Columns\IconColumn;
 use Filament\Tables\Columns\TextColumn;
 use Filament\Tables\Columns\ToggleColumn;
 use Filament\Tables\Table;
+use Illuminate\Support\Facades\Event;
+use Modules\Core\Payment\Contracts\Configurable;
+use Modules\Core\Payment\Events\PaymentMethodsReordered;
 use Modules\Core\Payment\Filament\Resources\PaymentMethodResource\Pages\ListPaymentMethods;
 use Modules\Core\Payment\Models\PaymentMethod;
+use Modules\Core\Payment\Services\PaymentDriverRegistry;
+use Modules\Core\Payment\Services\PaymentMethodCache;
+use Modules\Core\Payment\Services\PaymentMethodService;
 
 /**
- * One row per payment type key (config('lunar.payments.types')), seeded by
+ * The DB-instance layer for Payment (see docs/payments.md) — admin
- * InstallLunarCommand — never created/deleted here, only edited. `enabled`
+ * creatable/deletable, same as Lunar's own ShippingMethodResource. A row's
- * toggles inline; `data.fee` (currently the only type-specific setting, for
+ * `driver` is picked from a Select populated by
- * cash-on-delivery's flat surcharge — see ApplyCashOnDeliveryFee) is edited
+ * PaymentDriverRegistry::labels() (mirrors Modules\Core\Shipping\
- * via a modal action rather than a dedicated form field, since not every
+ * Extensions\ShippingMethodResourceExtension::driverSelect()'s use of
- * type has the same data keys.
+ * Shipping::getSupportedDrivers()), not a hardcoded options list, and
+ * never the raw driver class name — a third-party driver registered from
+ * its own package's service provider shows up here with no change to
+ * this class.
+ *
+ * Every write goes through Modules\Core\Payment\Services\
+ * PaymentMethodService — create/edit/delete/the enabled toggle all call
+ * it, not PaymentMethod::create()/update()/delete() directly, so cache
+ * invalidation and event dispatch happen in one place. The ONE exception
+ * is drag-to-reorder: Filament's own reorderTable() always writes the new
+ * `position` values via its own raw bulk SQL query before our
+ * afterReordering() hook ever runs — there is no seam to route that
+ * specific write through the service (short of disabling drag-reorder
+ * entirely and rebuilding it from scratch), so that hook only forgets the
+ * cache and dispatches PaymentMethodsReordered; the data itself is
+ * already correct in the database by the time it fires.
+ *
+ * `driver_missing_at` (set by the `boboko:payment:sync-drivers` command
+ * when a row's driver no longer resolves) drives the "Driver status"
+ * column, deliberately distinct from `enabled` — an admin needs to tell
+ * "I turned this off" apart from "this driver isn't usable right now" at
+ * a glance, not have both look like the same disabled state. That column
+ * also folds in Configurable::isConfigured() (e.g. Stripe with no API key
+ * set) — a class-resolves-but-isn't-usable state that CheckoutService::
+ * getPaymentMethods() filters out identically to a missing driver, so an
+ * admin needs the same at-a-glance warning for it, not just a silently
+ * absent checkout option.
+ *
+ * `authorized_status` only appears in the form when `capture_mode` is
+ * "Hold now, charge later" — it's simply unreachable for a "Charge
+ * immediately" method (that mode only ever produces PaymentCaptured,
+ * never PaymentAuthorized), so showing it unconditionally would just be
+ * a confusing, always-irrelevant field for most methods.
  */
 class PaymentMethodResource extends Resource
 {
@@ -35,10 +77,30 @@ class PaymentMethodResource extends Resource
     {
         return $table
             ->columns([
+                TextColumn::make('position')
+                    ->label('Order')
+                    ->sortable(),
+                TextColumn::make('name')
+                    ->label('Name')
+                    ->searchable(),
                 TextColumn::make('type')
                     ->label('Type'),
+                TextColumn::make('driver')
+                    ->label('Driver')
+                    ->formatStateUsing(fn (?string $state) => static::driverLabel($state)),
+                IconColumn::make('driver_missing_at')
+                    ->label('Driver status')
+                    ->boolean()
+                    ->state(fn (PaymentMethod $record) => ! $record->driver_missing_at && static::driverIsConfigured($record->driver))
+                    ->trueIcon('heroicon-o-check-circle')
+                    ->falseIcon('heroicon-o-exclamation-triangle')
+                    ->trueColor('success')
+                    ->falseColor('danger')
+                    ->tooltip(fn (PaymentMethod $record) => static::driverStatusTooltip($record)),
                 ToggleColumn::make('enabled')
-                    ->label('Enabled'),
+                    ->label('Enabled')
+                    ->updateStateUsing(fn (PaymentMethod $record, $state) => app(PaymentMethodService::class)
+                        ->update($record, ['enabled' => $state])),
                 TextColumn::make('data.fee')
                     ->label('Fee')
                     ->formatStateUsing(fn (?int $state) => $state
@@ -48,10 +110,110 @@ class PaymentMethodResource extends Resource
                     ->label('Last updated')
                     ->dateTime(),
             ])
+            ->reorderable('position')
+            ->afterReordering(function (array $order) {
+                app(PaymentMethodCache::class)->forget();
+
+                Event::dispatch(new PaymentMethodsReordered(array_map('intval', array_values($order))));
+            })
             ->recordActions([
+                static::editAction(),
                 static::editFeeAction(),
+                static::deleteAction(),
             ])
-            ->defaultSort('type');
+            ->defaultSort('position');
+    }
+
+    /**
+     * @return array<Component>
+     */
+    public static function getFormComponents(): array
+    {
+        return [
+            TextInput::make('name')
+                ->label('Name')
+                ->required()
+                ->maxLength(255),
+            TextInput::make('type')
+                ->label('Type')
+                ->helperText('Machine-facing slug — stored on the cart/order, used by other code to identify this method. Cannot be changed once orders reference it.')
+                ->required()
+                ->unique(ignoreRecord: true)
+                ->maxLength(255),
+            static::getDriverFormComponent(),
+            Select::make('capture_mode')
+                ->label('Capture mode')
+                ->helperText('Whether checkout charges immediately, or places a hold to settle later.')
+                ->options([
+                    'pay' => 'Charge immediately',
+                    'authorize' => 'Hold now, charge later',
+                ])
+                ->default('pay')
+                ->live()
+                ->required(),
+            static::getOrderStatusSelect('captured_status', 'Order status once paid')
+                ->helperText('Applied the moment a payment is fully charged.'),
+            static::getOrderStatusSelect('authorized_status', 'Order status once held')
+                ->helperText('Applied the moment a hold is placed, before it\'s charged.')
+                ->visible(fn (Get $get) => $get('capture_mode') === 'authorize'),
+            static::getOrderStatusSelect('refunded_status', 'Order status once refunded')
+                ->helperText('Applied when a payment taken through this method is refunded — even if the refund itself is processed through a different method.'),
+        ];
+    }
+
+    public static function getDriverFormComponent(): Component
+    {
+        return Select::make('driver')
+            ->label('Driver')
+            ->options(fn () => app(PaymentDriverRegistry::class)->labels())
+            ->required();
+    }
+
+    /**
+     * Lunar's own Order::status is a plain, admin-extensible string
+     * (config('lunar.orders.statuses')) rather than a fixed enum —
+     * deliberately so a store can add its own custom status without a
+     * code change (see docs/payments.md). This Select still reads from
+     * that same open-ended list, just so an admin picks a real status
+     * instead of typing a slug from memory.
+     */
+    private static function getOrderStatusSelect(string $name, string $label): Select
+    {
+        return Select::make($name)
+            ->label($label)
+            ->options(collect(config('lunar.orders.statuses', []))
+                ->map(fn (array $status) => $status['label'] ?? $status)
+                ->all())
+            ->native(false);
+    }
+
+    public static function getPages(): array
+    {
+        return [
+            'index' => ListPaymentMethods::route('/'),
+        ];
+    }
+
+    public static function canCreate(): bool
+    {
+        return true;
+    }
+
+    public static function canDelete($record = null): bool
+    {
+        return true;
+    }
+
+    private static function editAction(): Action
+    {
+        return Action::make('edit')
+            ->label('Edit')
+            ->icon('heroicon-o-pencil-square')
+            ->schema(static::getFormComponents())
+            ->fillForm(fn (PaymentMethod $record) => $record->only([
+                'name', 'type', 'driver', 'capture_mode', 'captured_status', 'authorized_status', 'refunded_status',
+            ]))
+            ->action(fn (PaymentMethod $record, array $data) => app(PaymentMethodService::class)->update($record, $data));
     }
 
     /**
@@ -76,7 +238,7 @@ class PaymentMethodResource extends Resource
                 'fee' => filled($record->data['fee'] ?? null) ? $record->data['fee'] / 100 : null,
             ])
             ->action(function (PaymentMethod $record, array $data) {
-                $record->update([
+                app(PaymentMethodService::class)->update($record, [
                     'data' => [
                         ...$record->data->toArray(),
                         'fee' => filled($data['fee']) ? (int) round($data['fee'] * 100) : null,
@@ -85,20 +247,51 @@ class PaymentMethodResource extends Resource
             });
     }
 
-    public static function getPages(): array
+    private static function deleteAction(): Action
     {
-        return [
+        return Action::make('delete')
-            'index' => ListPaymentMethods::route('/'),
+            ->label('Delete')
-        ];
+            ->icon('heroicon-o-trash')
+            ->color('danger')
+            ->requiresConfirmation()
+            ->action(fn (PaymentMethod $record) => app(PaymentMethodService::class)->delete($record));
     }
 
-    public static function canCreate(): bool
+    private static function driverLabel(?string $key): string
     {
-        return false;
+        if ($key === null) {
+            return '—';
+        }
+
+        return app(PaymentDriverRegistry::class)->label($key) ?? $key;
     }
 
-    public static function canDelete($record = null): bool
+    /**
+     * False for a missing driver too, since Configurable::isConfigured()
+     * has nothing to ask in that case — driverStatusTooltip() below is
+     * what tells the two reasons apart for the admin.
+     */
+    private static function driverIsConfigured(?string $key): bool
     {
-        return false;
+        $driver = $key ? app(PaymentDriverRegistry::class)->resolve($key) : null;
+
+        if (! $driver instanceof Configurable) {
+            return false;
+        }
+
+        return $driver->isConfigured();
+    }
+
+    private static function driverStatusTooltip(PaymentMethod $record): string
+    {
+        if ($record->driver_missing_at) {
+            return 'Driver not found as of '.$record->driver_missing_at->diffForHumans();
+        }
+
+        if (! static::driverIsConfigured($record->driver)) {
+            return 'Driver resolves, but is missing required configuration (e.g. an API key) — it will not be offered at checkout.';
+        }
+
+        return 'Driver resolves correctly and is fully configured.';
     }
 }

src/Payment/Filament/Resources/PaymentMethodResource/Pages/ListPaymentMethods.php

@@ -2,10 +2,31 @@
 
 namespace Modules\Core\Payment\Filament\Resources\PaymentMethodResource\Pages;
 
+use Filament\Actions;
 use Filament\Resources\Pages\ListRecords;
 use Modules\Core\Payment\Filament\Resources\PaymentMethodResource;
+use Modules\Core\Payment\Models\PaymentMethod;
+use Modules\Core\Payment\Services\PaymentMethodService;
 
 class ListPaymentMethods extends ListRecords
 {
     protected static string $resource = PaymentMethodResource::class;
+
+    protected function getHeaderActions(): array
+    {
+        return [
+            Actions\CreateAction::make()
+                ->schema(PaymentMethodResource::getFormComponents())
+                ->fillForm(fn () => [
+                    'position' => (PaymentMethod::max('position') ?? 0) + 1,
+                    'enabled' => false,
+                    'data' => [],
+                ])
+                // Every PaymentMethod write goes through PaymentMethodService
+                // — see PaymentMethodResource's own docblock — so this
+                // replaces CreateAction's default $model::create($data), not
+                // just the form/fill behavior above.
+                ->using(fn (array $data) => app(PaymentMethodService::class)->create($data)),
+        ];
+    }
 }

src/Payment/Http/Controllers/StripeWebhookController.php

@@ -23,7 +23,7 @@ use Stripe\Webhook;
  * anywhere reusable, it only gates the request through.
  *
  * Resolves the driver directly by class, not via
- * Modules\Core\Payment\Services\PaymentDriverResolver — this endpoint is
+ * Modules\Core\Payment\Services\PaymentDriverRegistry — this endpoint is
  * inherently Stripe-specific (Stripe's own webhook payload carries no
  * boboko payment-type key, only its own payment_intent id), and
  * StripePaymentDriver::handleCallback() already recovers $type itself

src/Payment/Listeners/LogPaymentMethodActivity.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Modules\Core\Payment\Listeners;
+
+use Modules\Core\Logging\ActivityLogService;
+use Modules\Core\Payment\Events\PaymentMethodCreated;
+use Modules\Core\Payment\Events\PaymentMethodDeleted;
+use Modules\Core\Payment\Events\PaymentMethodUpdated;
+use Modules\Core\Payment\Models\PaymentMethod;
+
+/**
+ * Same pattern as Localization\Listeners\LogTranslationActivity — routes
+ * PaymentMethodService's own events through the existing
+ * Logging\ActivityLogService instead of PaymentMethod separately opting
+ * into Lunar\Base\Traits\LogsActivity (Spatie's generic model-observer
+ * logging): PaymentMethodUpdated::$old and PaymentMethodDeleted::$method
+ * already carry richer, deliberate before/after context than Eloquent's
+ * own dirty-attribute diffing would reconstruct on its own.
+ *
+ * PaymentMethodDeleted's snapshot is a plain array (the row is already
+ * gone from the database by dispatch time — see that event's own
+ * docblock), so performedOn() gets an unsaved PaymentMethod instance
+ * built from it purely to carry the right subject_type/id, not a real
+ * persisted model.
+ *
+ * PaymentMethodsReordered is deliberately NOT logged here — it's a
+ * multi-row position change (ActivityLogService's methods all take one
+ * Model $subject) for a low-stakes, purely-cosmetic setting, not worth
+ * forcing into a one-subject shape or adding a new method to the shared
+ * service for.
+ */
+class LogPaymentMethodActivity
+{
+    public function __construct(
+        private readonly ActivityLogService $activityLog,
+    ) {}
+
+    public function handleCreated(PaymentMethodCreated $event): void
+    {
+        $this->activityLog->created($event->method, $event->method->getAttributes());
+    }
+
+    public function handleUpdated(PaymentMethodUpdated $event): void
+    {
+        $this->activityLog->updated(
+            $event->method,
+            $event->old,
+            $event->method->only(array_keys($event->old)),
+        );
+    }
+
+    public function handleDeleted(PaymentMethodDeleted $event): void
+    {
+        $subject = (new PaymentMethod)->forceFill($event->method);
+        $subject->exists = true;
+        $subject->id = $event->method['id'];
+
+        $this->activityLog->deleted($subject, $event->method);
+    }
+}

src/Payment/Models/CoreTransaction.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Modules\Core\Payment\Models;
+
+use Lunar\Models\Transaction;
+use Modules\Core\Payment\Support\TransactionDriverAdapter;
+
+/**
+ * Registered via Lunar\Facades\ModelManifest::replace(Lunar\Models\
+ * Contracts\Transaction::class, self::class) in PaymentServiceProvider —
+ * the same contract-swap mechanism this codebase already uses for
+ * Customer/Staff. Every place Lunar's own code resolves a transaction via
+ * Transaction::modelClass() (which reads this replacement, see
+ * Lunar\Base\Traits\HasModelExtending::modelClass()) — including
+ * Order::transactions()'s own hasMany(Transaction::modelClass()) relation
+ * — gets an instance of THIS class instead of the vendor's own
+ * Lunar\Models\Transaction. No override anywhere else is needed: this is
+ * the one seam that makes $order->transactions, and everything the admin
+ * panel's refund/capture actions call on one of those rows, silently run
+ * through our own system.
+ *
+ * Only driver() is overridden — refund()/capture()/paymentChecks() on the
+ * parent class all just call driver()->{method}(), so replacing what
+ * driver() returns is the entire fix (see TransactionDriverAdapter).
+ */
+class CoreTransaction extends Transaction
+{
+    public function driver(): TransactionDriverAdapter
+    {
+        return app(TransactionDriverAdapter::class);
+    }
+}

src/Payment/Models/PaymentMethod.php

@@ -6,17 +6,35 @@ use Illuminate\Database\Eloquent\Casts\AsArrayObject;
 use Illuminate\Database\Eloquent\Model;
 
 /**
- * Admin-editable settings for one payment type key (matching a key in
+ * A merchant-configured payment method — the DB-instance layer, admin
- * config('lunar.payments.types')) — enabled/disabled, and whatever type-
+ * creatable/deletable, same split Modules\Core\Shipping's own
- * specific data it needs (starts with 'fee' for cash-on-delivery's flat
+ * shipping_methods table already has (see docs/payments.md):
- * surcharge). Mirrors Lunar's own Discount model: a single jsonb 'data'
+ *   - type: unique, machine-facing slug (Cart::meta['payment_method'],
- * column holding keyed settings, rather than a fixed column per setting or
+ *     ApplyPaymentMethodFee's lookup key, every Payment event's $type).
- * a separate conditions table — new settings are a code change (a new key
+ *   - name: admin-facing label.
- * read from data), not a migration.
+ *   - driver: the Modules\Core\Payment\Services\PaymentDriverRegistry key
- *
+ *     — NOT the same as `type`, and not unique (two rows can share one
- * Seeded once per type by InstallLunarCommand (skip-if-exists, same
+ *     driver, e.g. two differently-named offline-style methods).
- * idempotent convention as seedStorefrontLabels()) — never auto-created on
+ *   - capture_mode: 'pay' or 'authorize' — which SupportsPay/
- * read, so a read path stays a pure read.
+ *     SupportsAuthorization method CheckoutService::initiatePayment()
+ *     calls for this row.
+ *   - captured_status / authorized_status / refunded_status: the
+ *     Order::status value Modules\Core\Order\Listeners\
+ *     ApplyResolvedPaymentStatus applies on a PaymentCaptured/
+ *     PaymentAuthorized/PaymentRefunded event. For a refund, this is
+ *     always the ORIGINAL payment method's row (the one the customer
+ *     actually paid with), never the driver the refund itself was routed
+ *     through (Payment\Support\TransactionDriverAdapter::refundVia() may
+ *     use a different one entirely — e.g. a cash-on-delivery order
+ *     refunded via a Bank Transfer driver with no PaymentMethod row of
+ *     its own) — see that listener's own docblock.
+ *   - position: admin-controlled display/checkout order.
+ *   - driver_missing_at: set by `payment:sync-drivers` when `driver` no
+ *     longer resolves via the registry — separate from `enabled`, so a
+ *     driver vanishing (a deploy removed it) is never confused with an
+ *     admin's own manual toggle.
+ *   - data: jsonb, driver-specific settings that don't warrant their own
+ *     column (starts with 'fee', the offline flat surcharge).
  */
 class PaymentMethod extends Model
 {
@@ -24,6 +42,8 @@ class PaymentMethod extends Model
 
     protected $casts = [
         'enabled' => 'boolean',
+        'position' => 'integer',
+        'driver_missing_at' => 'datetime',
         'data' => AsArrayObject::class,
     ];
 }

src/Payment/Pipelines/Cart/ApplyCashOnDeliveryFee.php

@@ -1,31 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\Pipelines\Cart;
-
-use Closure;
-use Lunar\DataTypes\Price;
-use Lunar\Models\Contracts\Cart as CartContract;
-use Modules\Core\Payment\Models\PaymentMethod;
-
-final class ApplyCashOnDeliveryFee
-{
-    /**
-     * Called just before cart totals are calculated.
-     *
-     * @param  Closure(CartContract): mixed  $next
-     */
-    public function handle(CartContract $cart, Closure $next): mixed
-    {
-        if (($cart->meta['payment_method'] ?? null) === 'cash-on-delivery') {
-            $fee = (int) (PaymentMethod::where('type', 'cash-on-delivery')->value('data->fee') ?? 0);
-
-            $cart->shippingTotal = new Price(
-                ($cart->shippingTotal?->value ?? 0) + $fee,
-                $cart->currency,
-                1
-            );
-        }
-
-        return $next($cart);
-    }
-}

src/Payment/Pipelines/Cart/ApplyPaymentMethodFee.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Modules\Core\Payment\Pipelines\Cart;
+
+use Closure;
+use Lunar\Base\ValueObjects\Cart\ShippingBreakdownItem;
+use Lunar\DataTypes\Price;
+use Lunar\Models\Contracts\Cart as CartContract;
+use Modules\Core\Payment\Models\PaymentMethod;
+
+final class ApplyPaymentMethodFee
+{
+    /**
+     * Called just before cart totals are calculated, right after
+     * Lunar\Pipelines\Cart\ApplyShipping. Generic across every
+     * Modules\Core\Payment\Models\PaymentMethod row, not just cash on
+     * delivery — whichever type the shopper picked (Cart::meta
+     * ['payment_method']), its own `data.fee` (set via the Filament "Edit
+     * fee" action) is applied if present, no matter its slug/name/driver.
+     *
+     * Must add the fee as its own Lunar\Base\ValueObjects\Cart\
+     * ShippingBreakdownItem on $cart->shippingBreakdown rather than
+     * bumping $cart->shippingTotal directly — the later Lunar\Pipelines\
+     * Cart\CalculateTax step unconditionally recomputes shippingTotal
+     * (and shipping tax) from shippingBreakdown's item sum, so a value
+     * set only on the plain property is silently discarded before the
+     * cart finishes calculating.
+     *
+     * @param  Closure(CartContract): mixed  $next
+     */
+    public function handle(CartContract $cart, Closure $next): mixed
+    {
+        $type = $cart->meta['payment_method'] ?? null;
+
+        if ($type) {
+            $fee = (int) (PaymentMethod::where('type', $type)->first()?->data['fee'] ?? 0);
+
+            if ($fee > 0) {
+                $cart->shippingBreakdown->items->put('payment-method-fee', new ShippingBreakdownItem(
+                    name: 'Payment method fee',
+                    identifier: 'payment-method-fee',
+                    price: new Price($fee, $cart->currency, 1),
+                ));
+            }
+        }
+
+        return $next($cart);
+    }
+}

src/Payment/Services/PaymentDriverRegistry.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace Modules\Core\Payment\Services;
+
+/**
+ * Which payment driver CLASSES exist this deploy — the code-registry layer,
+ * mirroring Lunar\Shipping\Managers\ShippingManager's own built-in-methods
+ * + Manager::extend() pattern, but purpose-built rather than extending
+ * Illuminate\Support\Manager: Manager's create{X}Driver() convention fits
+ * a uniform one-interface-per-driver contract (ShippingRateInterface); a
+ * Payment driver instead implements several independent, opt-in capability
+ * interfaces at once (Configurable, SupportsPay, SupportsAuthorization,
+ * ...), so there's no single "the" method to generate per driver.
+ *
+ * Deliberately knows NOTHING about Modules\Core\Payment\Models\PaymentMethod
+ * or the database — resolve() is a pure "does this key still exist"
+ * lookup. Whether a resolved driver is administratively enabled, or
+ * reports itself Configurable::isConfigured(), is the DOMAIN's job
+ * (Modules\Core\Checkout\Services\CheckoutService::getPaymentMethods()) —
+ * see docs/payments.md. This split is what lets the identical registry
+ * shape be lifted for a future Invoicing/AntiFraud domain without dragging
+ * Payment-specific concepts along with it.
+ *
+ * Built-in drivers are registered in Modules\Core\Providers\
+ * PaymentServiceProvider::boot() via register(); a consuming app or a
+ * future payment-provider package registers its own the same way, from
+ * its own service provider's boot() — exactly how Shipping::extend() works
+ * for ACS/Box Now (src/Providers/ShippingServiceProvider.php).
+ */
+class PaymentDriverRegistry
+{
+    /**
+     * @var array<string, string>
+     */
+    private array $drivers = [];
+
+    /**
+     * @var array<string, string>
+     */
+    private array $labels = [];
+
+    /**
+     * $key is the registry key a Modules\Core\Payment\Models\PaymentMethod
+     * row's own `driver` column stores — NOT the same as that row's `type`
+     * (its merchant-facing slug). Two rows can share one driver key (e.g.
+     * both 'cash-on-delivery' and 'cash-in-hand' using the same 'offline'
+     * driver with different type/name/fee).
+     *
+     * $label is a short, human-readable name (e.g. "Stripe", "Offline /
+     * Manual") — this is where that comes from, not $driverClass's own
+     * FQCN. Payment's driver classes implement several independent,
+     * opt-in capability interfaces (Configurable, SupportsPay, ...), none
+     * of which carries a display name the way Lunar\Shipping\Interfaces\
+     * ShippingRateInterface::name() does for every shipping driver — the
+     * registry is the one place that DOES know every driver at once, so
+     * it's the natural (and only) place to also hold this.
+     */
+    public function register(string $key, string $driverClass, string $label): void
+    {
+        $this->drivers[$key] = $driverClass;
+        $this->labels[$key] = $label;
+    }
+
+    /**
+     * Null if $key was never registered — deliberately non-throwing, same
+     * reasoning the old PaymentDriverResolver already had: a caller
+     * checking availability (or the payment:sync-drivers command checking
+     * every PaymentMethod row) needs "not found" to be a normal, silent
+     * result, not an exception to catch.
+     */
+    public function resolve(string $key): ?object
+    {
+        $driverClass = $this->drivers[$key] ?? null;
+
+        return $driverClass ? app($driverClass) : null;
+    }
+
+    /**
+     * Every registered key => driver class — what payment:sync-drivers
+     * checks every PaymentMethod row's `driver` column against.
+     *
+     * @return array<string, string>
+     */
+    public function all(): array
+    {
+        return $this->drivers;
+    }
+
+    /**
+     * Every registered key => human-readable label — what a Filament
+     * driver Select populates its options from (mirroring
+     * ShippingMethodResourceExtension::driverSelect()'s use of
+     * Shipping::getSupportedDrivers(), which reads each driver's own
+     * name()) — never the raw class name from all().
+     *
+     * @return array<string, string>
+     */
+    public function labels(): array
+    {
+        return $this->labels;
+    }
+
+    public function label(string $key): ?string
+    {
+        return $this->labels[$key] ?? null;
+    }
+}

src/Payment/Services/PaymentDriverResolver.php

@@ -1,34 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\Services;
-
-/**
- * Resolves a payment type key (e.g. 'stripe', 'cash-on-delivery') to its
- * registered driver instance — extracted out of CheckoutService so both it
- * and anything else needing the same lookup share one implementation
- * instead of duplicating this config read.
- *
- * Returns a plain object, not a shared interface — Payment's own drivers
- * implement several independent, orthogonal capability interfaces at once
- * (Configurable, SupportsPay, SupportsAuthorization, ...; see
- * StripePaymentDriver implementing all six). There is no single common
- * "PaymentDriver" contract to type this against; a caller checks
- * `instanceof SupportsPay` / `instanceof SupportsAuthorization` itself,
- * the same way Payment's own contracts are designed to be consumed.
- */
-class PaymentDriverResolver
-{
-    /**
-     * Null if $type has no 'payment_driver' registered in
-     * config('lunar.payments.types.<type>') at all — deliberately
-     * non-throwing so a caller like CheckoutService::getPaymentMethods()
-     * can filter unresolvable types silently rather than treating "not
-     * registered" as an error condition when just checking availability.
-     */
-    public function resolve(string $type): ?object
-    {
-        $driverClass = config("lunar.payments.types.{$type}.payment_driver");
-
-        return $driverClass ? app($driverClass) : null;
-    }
-}

src/Payment/Services/PaymentMethodCache.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Modules\Core\Payment\Services;
+
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Cache;
+use Modules\Core\Payment\Models\PaymentMethod;
+
+/**
+ * Cached read layer over PaymentMethod — the single source both
+ * Modules\Core\Checkout\Services\CheckoutService (checkout-time
+ * availability) and anything else needing the payment-method list (e.g.
+ * PaymentServiceProvider's Lunar\Facades\Payments shim, order screens
+ * showing a transaction's driver) read from, so the table is fetched once
+ * per cache lifetime rather than once per caller/request. Mirrors
+ * Modules\Core\Localization\Services\LanguageCache's exact shape.
+ *
+ * Cached forever, invalidated via forget() by
+ * Modules\Core\Payment\Observers\FlushPaymentMethodCache on
+ * PaymentMethod::saved()/deleted() — no bespoke Created/Updated/Deleted
+ * event trio needed, unlike LanguageCache's (Language is a Lunar-owned
+ * model reacted to indirectly); PaymentMethod is entirely our own model,
+ * so a plain Eloquent observer is the direct route.
+ */
+class PaymentMethodCache
+{
+    private const CACHE_KEY = 'core.payment.methods';
+
+    public function all(): Collection
+    {
+        return Cache::rememberForever(
+            self::CACHE_KEY,
+            fn () => PaymentMethod::query()->orderBy('position')->get(),
+        );
+    }
+
+    public function forget(): void
+    {
+        Cache::forget(self::CACHE_KEY);
+    }
+}

src/Payment/Services/PaymentMethodService.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace Modules\Core\Payment\Services;
+
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Event;
+use Modules\Core\Payment\Events\PaymentMethodCreated;
+use Modules\Core\Payment\Events\PaymentMethodDeleted;
+use Modules\Core\Payment\Events\PaymentMethodUpdated;
+use Modules\Core\Payment\Models\PaymentMethod;
+
+/**
+ * The single write (AND read) gateway for PaymentMethod — every Filament
+ * resource/action calls this, not PaymentMethod::create()/update()/delete()
+ * directly, so cache invalidation is one explicit step colocated with the
+ * mutation (not hidden in a model observer) and every admin change to a
+ * payment method dispatches a matching event, the same convention
+ * Modules\Core\Cart\Services\CartService already established for its own
+ * mutating methods.
+ *
+ * list() is what PaymentMethodCache actually reads through — see that
+ * class for why this needs caching at all (Modules\Core\Checkout\
+ * Services\CheckoutService and PaymentServiceProvider's Lunar\Facades\
+ * Payments shim both read the full payment-method list on the hot path).
+ */
+class PaymentMethodService
+{
+    public function __construct(
+        private readonly PaymentMethodCache $cache,
+    ) {}
+
+    /**
+     * @return Collection<int, PaymentMethod>
+     */
+    public function list(): Collection
+    {
+        return $this->cache->all();
+    }
+
+    /**
+     * @param  array<string, mixed>  $data
+     */
+    public function create(array $data): PaymentMethod
+    {
+        $method = PaymentMethod::create($data);
+
+        $this->cache->forget();
+
+        Event::dispatch(new PaymentMethodCreated($method));
+
+        return $method;
+    }
+
+    /**
+     * @param  array<string, mixed>  $data
+     */
+    public function update(PaymentMethod $method, array $data): PaymentMethod
+    {
+        $old = $method->only(array_keys($data));
+
+        $method->update($data);
+
+        $this->cache->forget();
+
+        Event::dispatch(new PaymentMethodUpdated($method, $old));
+
+        return $method;
+    }
+
+    public function delete(PaymentMethod $method): void
+    {
+        $snapshot = $method->only([
+            'id', 'type', 'name', 'driver', 'capture_mode',
+            'captured_status', 'authorized_status', 'position', 'enabled',
+        ]);
+
+        $method->delete();
+
+        $this->cache->forget();
+
+        Event::dispatch(new PaymentMethodDeleted($snapshot));
+    }
+}

src/Payment/Support/TransactionDriverAdapter.php

@@ -0,0 +1,144 @@
+<?php
+
+namespace Modules\Core\Payment\Support;
+
+use Lunar\Base\DataTransferObjects\PaymentCapture;
+use Lunar\Base\DataTransferObjects\PaymentChecks;
+use Lunar\Base\DataTransferObjects\PaymentRefund;
+use Lunar\DataTypes\Price;
+use Lunar\Models\Contracts\Transaction;
+use Modules\Core\Payment\Contracts\SupportsCaptures;
+use Modules\Core\Payment\Contracts\SupportsRefunds;
+use Modules\Core\Payment\Enums\PaymentResultStatus;
+use Modules\Core\Payment\Services\PaymentDriverRegistry;
+use Modules\Core\Payment\Services\PaymentMethodCache;
+
+/**
+ * What Modules\Core\Payment\Models\CoreTransaction::driver() returns
+ * instead of Lunar\Facades\Payments::driver($this->driver) — the point
+ * where every Lunar-native caller of a transaction's driver (today: the
+ * admin panel's "Refund"/"Capture" header actions on the order page,
+ * ManageOrder::getRefundAction()/getCaptureAction() — see
+ * $transaction->refund()/->capture() in vendor/lunarphp/core/src/Models/
+ * Transaction.php) transparently lands on OUR real payment system instead
+ * of Lunar's own, entirely separate, unused PaymentManager.
+ *
+ * Implements Lunar\Base\PaymentTypeInterface's refund()/capture()/
+ * getPaymentChecks() signatures exactly — each takes the Transaction as
+ * its own first argument (confirmed from vendor/lunarphp/core/src/Models/
+ * Transaction.php: `$this->driver()->refund($this, $amount, $notes)`),
+ * so this class holds no transaction state of its own; CoreTransaction's
+ * driver() can return one shared instance for any transaction.
+ *
+ * $transaction->driver is a Modules\Core\Payment\Models\PaymentMethod.type
+ * value (what Modules\Core\Order\Services\TransactionRecorder writes into
+ * Transaction.driver) — this resolves the REAL registry key from that
+ * type via PaymentMethodCache, then the real driver instance from
+ * PaymentDriverRegistry, so refund()/capture() called here call the
+ * ACTUAL Stripe/etc. driver, never a fake/no-op stand-in. If either
+ * lookup fails (the PaymentMethod row or its driver no longer exists),
+ * refund()/capture() report failure rather than silently doing nothing.
+ */
+class TransactionDriverAdapter
+{
+    public function __construct(
+        private readonly PaymentMethodCache $paymentMethods,
+        private readonly PaymentDriverRegistry $registry,
+    ) {}
+
+    public function refund(Transaction $transaction, int $amount, ?string $notes = null): PaymentRefund
+    {
+        return $this->refundVia($transaction, $this->driverKeyFor($transaction), $amount, $notes);
+    }
+
+    /**
+     * The PaymentDriverRegistry key $transaction was originally taken
+     * through — what refund()/capture() resolve against by default, and
+     * what Order\Filament\Extensions\OrderRefundActionsExtension defaults
+     * its "Refund via" driver Select to, before an admin overrides it.
+     */
+    public function driverKeyFor(Transaction $transaction): ?string
+    {
+        return $this->paymentMethods->all()->firstWhere('type', $transaction->driver)?->driver;
+    }
+
+    /**
+     * Same as refund(), but against an explicitly chosen driver rather than
+     * the one $transaction was originally taken through — e.g. refunding a
+     * cash-on-delivery order via a Bank Transfer driver instead of trying
+     * (and failing) to refund through the offline driver that took the
+     * original payment. $driverKey is a PaymentDriverRegistry key (e.g.
+     * 'bank-transfer'), not a PaymentMethod.type — the two only coincide
+     * when refunding through the transaction's own original driver.
+     *
+     * Called directly by Order\Filament\Extensions\
+     * OrderRefundActionsExtension when the admin picks a different driver
+     * in the refund modal, bypassing Lunar\Models\Transaction::refund()
+     * (whose fixed refund(int $amount, $notes = null) signature has no
+     * room for a driver override) — see that extension's own docblock.
+     */
+    public function refundVia(Transaction $transaction, ?string $driverKey, int $amount, ?string $notes = null): PaymentRefund
+    {
+        $driver = $driverKey !== null ? $this->registry->resolve($driverKey) : null;
+
+        if (! $driver instanceof SupportsRefunds) {
+            return new PaymentRefund(success: false, message: 'This payment method does not support refunds.');
+        }
+
+        $result = $driver->refund(
+            $transaction->reference,
+            $this->priceFor($transaction, $amount),
+            ['notes' => $notes, 'order_id' => $transaction->order_id],
+        );
+
+        return new PaymentRefund(
+            success: $result->status === PaymentResultStatus::Succeeded,
+            message: $result->failureReason,
+        );
+    }
+
+    public function capture(Transaction $transaction, int $amount = 0): PaymentCapture
+    {
+        $driver = $this->resolveDriver($transaction);
+
+        if (! $driver instanceof SupportsCaptures) {
+            return new PaymentCapture(success: false, message: 'This payment method does not support a separate capture step.');
+        }
+
+        $result = $driver->capture(
+            $transaction->reference,
+            $this->priceFor($transaction, $amount ?: $transaction->amount->value),
+            ['order_id' => $transaction->order_id],
+        );
+
+        return new PaymentCapture(
+            success: $result->status === PaymentResultStatus::Succeeded,
+            message: $result->failureReason ?? '',
+        );
+    }
+
+    /**
+     * Lunar's own PaymentChecks DTO (address/postcode/CVC verification
+     * results) has no equivalent in our own contracts — none of our
+     * drivers currently surface this level of gateway-specific detail.
+     * Empty, not null: Lunar's admin panel iterates this collection to
+     * render a checks list, so it needs to always be a valid (possibly
+     * empty) PaymentChecks, never missing entirely.
+     */
+    public function getPaymentChecks(Transaction $transaction): PaymentChecks
+    {
+        return new PaymentChecks;
+    }
+
+    private function resolveDriver(Transaction $transaction): ?object
+    {
+        $driverKey = $this->driverKeyFor($transaction);
+
+        return $driverKey !== null ? $this->registry->resolve($driverKey) : null;
+    }
+
+    private function priceFor(Transaction $transaction, int $amount): Price
+    {
+        return new Price($amount, $transaction->order->currency);
+    }
+}

src/Providers/CheckoutServiceProvider.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Modules\Core\Providers;
+
+use Illuminate\Support\ServiceProvider;
+
+class CheckoutServiceProvider extends ServiceProvider
+{
+    public function register(): void
+    {
+        $this->mergeConfigFrom(__DIR__ . '/../../config/legal.php', 'legal');
+    }
+}

src/Providers/OrderServiceProvider.php

@@ -36,6 +36,7 @@ class OrderServiceProvider extends ServiceProvider
         Event::listen(ShipmentStatusUpdatedByCarrier::class, DeriveOrderDeliveredFromShipment::class);
         Event::listen(PaymentCaptured::class, ApplyResolvedPaymentStatus::class);
         Event::listen(PaymentAuthorized::class, ApplyResolvedPaymentStatus::class);
+        Event::listen(PaymentRefunded::class, ApplyResolvedPaymentStatus::class);
         Event::listen(PaymentCaptured::class, RecordPaymentTransaction::class);
         Event::listen(PaymentAuthorized::class, RecordPaymentTransaction::class);
         Event::listen(PaymentVoided::class, RecordPaymentTransaction::class);

src/Providers/PaymentServiceProvider.php

@@ -2,24 +2,37 @@
 
 namespace Modules\Core\Providers;
 
+use Illuminate\Support\Facades\Event;
 use Illuminate\Support\ServiceProvider;
+use Lunar\Facades\ModelManifest;
+use Lunar\Models\Contracts\Transaction as TransactionContract;
 use Lunar\Pipelines\Cart\ApplyShipping;
+use Modules\Core\Command\SyncPaymentDriversCommand;
+use Modules\Core\Payment\Drivers\BankTransferPaymentDriver;
+use Modules\Core\Payment\Drivers\OfflinePaymentDriver;
+use Modules\Core\Payment\Drivers\StripePaymentDriver;
+use Modules\Core\Payment\Events\PaymentMethodCreated;
+use Modules\Core\Payment\Events\PaymentMethodDeleted;
+use Modules\Core\Payment\Events\PaymentMethodUpdated;
+use Modules\Core\Payment\Listeners\LogPaymentMethodActivity;
+use Modules\Core\Payment\Models\CoreTransaction;
+use Modules\Core\Payment\Services\PaymentDriverRegistry;
 
 class PaymentServiceProvider extends ServiceProvider
 {
     public function register(): void
     {
         $this->mergeConfigFrom(__DIR__ . '/../../config/payment.php', 'payment');
+
+        $this->app->singleton(PaymentDriverRegistry::class);
     }
 
     public function boot(): void
     {
-        config([
+        $registry = $this->app->make(PaymentDriverRegistry::class);
-            'lunar.payments.types' => array_merge(
+        $registry->register('offline', OfflinePaymentDriver::class, 'Offline / Manual');
-                config('lunar.payments.types', []),
+        $registry->register('stripe', StripePaymentDriver::class, 'Stripe');
-                config('payment.types', [])
+        $registry->register('bank-transfer', BankTransferPaymentDriver::class, 'Bank Transfer');
-            ),
-        ]);
 
         $cartPipeline = config('lunar.cart.pipelines.cart', []);
         $insertAfter = array_search(ApplyShipping::class, $cartPipeline, true);
@@ -39,6 +52,27 @@ class PaymentServiceProvider extends ServiceProvider
 
         config(['lunar.cart.pipelines.cart' => $cartPipeline]);
 
+        // Same contract-swap mechanism this codebase already uses for
+        // Customer/Staff (see e.g. consuming apps' own AppServiceProvider,
+        // ModelManifest::replace(Contracts\Customer::class, ...)) — every
+        // place Lunar's own code resolves a transaction via
+        // Transaction::modelClass() (Order::transactions()'s own relation
+        // included) gets Modules\Core\Payment\Models\CoreTransaction
+        // instead of the vendor's own Transaction. That subclass's
+        // driver() override is the ENTIRE fix for the admin panel's
+        // refund/capture actions silently landing on our real payment
+        // system — see CoreTransaction's own docblock. Lunar's own
+        // Payments facade/PaymentManager is never touched at all.
+        ModelManifest::replace(TransactionContract::class, CoreTransaction::class);
+
+        Event::listen(PaymentMethodCreated::class, [LogPaymentMethodActivity::class, 'handleCreated']);
+        Event::listen(PaymentMethodUpdated::class, [LogPaymentMethodActivity::class, 'handleUpdated']);
+        Event::listen(PaymentMethodDeleted::class, [LogPaymentMethodActivity::class, 'handleDeleted']);
+
         $this->loadRoutesFrom(__DIR__ . '/../Payment/routes/webhooks.php');
+
+        if ($this->app->runningInConsole()) {
+            $this->commands([SyncPaymentDriversCommand::class]);
+        }
     }
 }

src/Providers/ShippingServiceProvider.php

@@ -26,7 +26,7 @@ use Modules\Core\Shipping\Carriers\BoxNow\BoxNowRateDriver;
 use Modules\Core\Shipping\Contracts\CarrierFulfillmentInterface;
 use Modules\Core\Shipping\Filament\Pages\ManageShippingRates;
 use Modules\Core\Shipping\Jobs\PollShipmentTrackingJob;
-use Modules\Core\Shipping\Listeners\FlushLivePricingCache;
+use Modules\Core\Shipping\Listeners\InvalidateShippingOptions;
 use Modules\Core\Shipping\Models\Shipment;
 
 class ShippingServiceProvider extends ServiceProvider
@@ -70,7 +70,7 @@ class ShippingServiceProvider extends ServiceProvider
         });
 
         foreach ([CartLineAdded::class, CartLineUpdated::class, CartLineRemoved::class, CartCleared::class, ShippingAddressSet::class] as $event) {
-            Event::listen($event, [FlushLivePricingCache::class, 'handle']);
+            Event::listen($event, [InvalidateShippingOptions::class, 'handle']);
         }
 
         // Deferred: the Shipping facade resolves a binding registered in

src/Shipping/Concerns/CachesLivePricing.php

@@ -17,7 +17,7 @@ use Lunar\Shipping\Models\ShippingRate;
  * across carts: the quote depends on cart-specific weight/quantity/
  * destination (see docs/checkout.md).
  *
- * Invalidated by Modules\Core\Shipping\Listeners\FlushLivePricingCache on
+ * Invalidated by Modules\Core\Shipping\Listeners\InvalidateShippingOptions on
  * the only two things that can change what this cart's quote should be: a
  * cart line changing (add/update/remove/clear) or the shipping address
  * changing. Deliberately NOT invalidated on order placement — the price

src/Shipping/Listeners/InvalidateShippingOptions.php

@@ -3,6 +3,7 @@
 namespace Modules\Core\Shipping\Listeners;
 
 use Illuminate\Support\Facades\Cache;
+use Lunar\Facades\ShippingManifest;
 use Lunar\Shipping\Facades\Shipping;
 use Lunar\Shipping\Models\ShippingRate;
 use Modules\Core\Cart\Events\CartCleared;
@@ -13,17 +14,29 @@ use Modules\Core\Checkout\Events\ShippingAddressSet;
 use Modules\Core\Shipping\Contracts\SupportsLivePricing;
 
 /**
- * Flushes Modules\Core\Shipping\Concerns\CachesLivePricing's cached quotes
+ * Invalidates everything that caches or memoises resolved shipping options
- * for a cart on the only two things that can change what they should be: a
+ * for a cart, on the only two things that can change what they should be: a
  * cart line changing (weight/quantity) or the shipping address changing
- * (destination). See that trait's docblock for why order placement is
+ * (destination).
- * deliberately not a trigger here.
  *
- * Only rates whose method's driver implements SupportsLivePricing are ever
+ * Two things need clearing here, both stale for the same reason:
- * cached by CachesLivePricing, so only their ids need a forget() call —
+ *
- * no need to touch every ShippingRate row on every cart change.
+ * - Modules\Core\Shipping\Concerns\CachesLivePricing's per-rate cache (see
+ *   that trait's docblock for why order placement is deliberately not a
+ *   trigger). Only rates whose method's driver implements
+ *   SupportsLivePricing are ever cached by it, so only their ids need a
+ *   forget() call — no need to touch every ShippingRate row on every cart
+ *   change.
+ * - Lunar\Base\ShippingManifest's $options collection, which is a
+ *   request-lifetime singleton: ShippingManifest::getOptions() re-runs the
+ *   modifier pipeline on every call but never clears $options first, and
+ *   addOption() keeps the first entry per identifier and silently drops any
+ *   later one — so an option resolved for an earlier address/cart state
+ *   shadows the correct one after that state changes, within the same
+ *   request. clearOptions() forces the next getOptions() call to resolve
+ *   fresh.
  */
-class FlushLivePricingCache
+class InvalidateShippingOptions
 {
     public function handle(CartLineAdded|CartLineUpdated|CartLineRemoved|CartCleared|ShippingAddressSet $event): void
     {
@@ -32,6 +45,8 @@ class FlushLivePricingCache
         foreach ($this->livePricingRateIds() as $rateId) {
             Cache::forget("shipping.live_price.{$rateId}.{$cart->id}");
         }
+
+        ShippingManifest::clearOptions();
     }
 
     /**