spree_core 6.0.0 → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 579b3e333d378aec89721e12502e86fe2f529d99e18f087ecaf29cebe6e6b772
-  data.tar.gz: 29411570d9588634cfa2a4f559bea3bf6622c8672b90415a38ee1372a996494f
+  metadata.gz: 2407d5fb2d24d9dd893a8c9dae11cfd8aba5a4b1d621a82938a2cb7009581936
+  data.tar.gz: f3384773e3442f383e979f60d58b7b06672a72065cd8d117a114ef49827fda5e
 SHA512:
-  metadata.gz: 38eef7cff0fce557dd3b14460d3bbdf50e410fc28ae7e9c74fa59f92767078cc74531f221d7a615ba53af0297c3dd8bd9e72ab15a5f09dd5ab88ceff20b0e653
-  data.tar.gz: dd2f38e2a6c8b179610ae41ded85992b051081ed71ac110e3a078ebd595b4ea273bbdabf6b64226af1831ce7e93eda1e32591dda4f5da9969dc700aaa3d6f587
+  metadata.gz: ebc83d9db9ebc13afea53ae0b184789f32a81121dcd9608461d93fb7e2e62b020cef774e69de3404fc0d23adb62df13f770281eacd6fd4671e5c0f5328ecae5b
+  data.tar.gz: 99ecc2439e9a73c1f805898c35e48079cd573b947110951c1a8349b26934e7ea8023b55a53cfdf1b3af94a5013290c52e5a097e4e5dff61d1249af8ca3327fb7

data/app/jobs/spree/seller_transfers/execute_pending_due_job.rb

@@ -1,6 +1,7 @@
 module Spree
   module SellerTransfers
-    # Hands every seller holding an unconfirmed earning to a job of their own.
+    # Hands every seller holding an unconfirmed earning or reversal to a job of
+    # their own.
     #
     # The transfer level's counterpart to {Spree::SellerPayouts::SweepDueJob},
     # and deliberately a separate schedule rather than something the settlement
@@ -39,17 +40,18 @@ module Spree
       # @param store [Spree::Store]
       # @return [ActiveRecord::Relation<Spree::Seller>]
       def sellers_awaiting_provider(store)
-        scope = store.sellers.approved.
-                where(id: Spree::SellerTransfer.for_store(store).awaiting_provider.select(:seller_id))
+        transfers = Spree::SellerTransfer.for_store(store)
+        sending = store.sellers.approved.where(id: transfers.awaiting_provider.select(:seller_id))
 
         # A seller the provider will not accept yet keeps their earnings
         # unconfirmed, and the job would return at once. Skipped rather than
         # enqueued, because a marketplace's half-onboarded sellers are a
         # standing population and this runs often — and nothing is lost by it:
         # finishing onboarding runs the job for them directly.
-        return scope unless store.payout_provider_class.requires_payout_account?
+        sending = sending.where.not(payouts_enabled_at: nil) if store.payout_provider_class.requires_payout_account?
 
-        scope.where.not(payouts_enabled_at: nil)
+        # Money owed back is pursued whatever the seller's standing.
+        sending.or(store.sellers.where(id: transfers.reversals_awaiting_provider.select(:seller_id)))
       end
     end
   end

data/app/jobs/spree/seller_transfers/execute_pending_job.rb

@@ -14,6 +14,9 @@ module Spree
     # seller who was payable all along would never see a refused earning tried
     # again, since nothing about them ever changes to prompt it.
     #
+    # Reversals are retried the same way: a provider that pulls money back can
+    # refuse too, and one cannot be pulled back before its earning was sent.
+    #
     # It takes the retryable rows — never sent, or refused outright. A transfer
     # whose outcome the provider could not report is left alone: asking again
     # is precisely how the same money moves twice, and only a person can say
@@ -24,30 +27,47 @@ module Spree
       # @param seller_id [Integer]
       def perform(seller_id)
         seller = Spree::Seller.find_by(id: seller_id)
-        return if seller.nil? || !seller.payouts_enabled?
+        return if seller.nil?
 
         Spree::Current.store = seller.store
+        send_earnings(seller) if seller.payouts_enabled?
+
+        # Never through `transfer!`: a reversal's amount is negative, and the
+        # amount sent is its absolute value, so it would pay the seller the
+        # money it exists to take back. Through the provider that made the
+        # earning, which is not necessarily the store's current one. And for
+        # every seller, payable or not — a seller suspended after a wave of
+        # refunds is exactly the one whose money must come back.
+        seller.seller_transfers.reversals_awaiting_provider.includes(:reversed_from, :order).find_each do |reversal|
+          execute(reversal) { reversal.payout_provider_instance.reverse!(reversal) }
+        end
+      end
+
+      private
+
+      # Before the reversals, so a reversal waiting on its earning finds it sent.
+      def send_earnings(seller)
         provider = seller.store.payout_provider_instance
 
-        # Earnings only — see the scope. A reversal is retryable the same way
-        # when its own provider call is refused, but sending one through
-        # `transfer!` would pay the seller the amount it exists to take back:
-        # the row is negative and the amount sent is its absolute value.
         seller.seller_transfers.awaiting_provider.find_each do |transfer|
-          provider.transfer!(transfer)
-        rescue Spree::Core::AmbiguousGatewayError => e
-          # The money may already have moved, so this row must not be offered
-          # again: left retryable, the next run would send it a second time,
-          # and an idempotency key stops that only while the provider still
-          # holds its record.
-          transfer.update!(status: 'unresolved')
-          Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
-        rescue StandardError => e
-          # A refusal — the money did not move. One seller's stuck earning must
-          # not stop the rest, and the row stays retryable for the next run.
-          Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
+          execute(transfer) { provider.transfer!(transfer) }
         end
       end
+
+      def execute(transfer)
+        yield
+      rescue Spree::Core::AmbiguousGatewayError => e
+        # The money may already have moved, so this row must not be offered
+        # again: left retryable, the next run would move it a second time,
+        # and an idempotency key stops that only while the provider still
+        # holds its record.
+        transfer.update!(status: 'unresolved')
+        Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
+      rescue StandardError => e
+        # A refusal — the money did not move. One stuck row must not stop the
+        # rest, and it stays retryable for the next run.
+        Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
+      end
     end
   end
 end

data/app/maintenance_tasks/spree/maintenance_tasks/upgrade/store_regional_settings.rb

@@ -0,0 +1,63 @@
+module Spree
+  module MaintenanceTasks
+    module Upgrade
+      # 5.6 → 6.0 conversion of the store's time zone into an IANA identifier
+      # ("Eastern Time (US & Canada)" becomes "America/New_York") and of its
+      # admin language into a listed locale code (`en_US` becomes `en-US`), the
+      # only forms the API accepts and browsers read.
+      #
+      # A time zone that names no zone falls back to the store default, which is
+      # what the store already ran on: Ruby could not read it either. An admin
+      # language Spree does not list is cleared, so the dashboard shows each
+      # staff member their own language.
+      class StoreRegionalSettings < Spree::MaintenanceTask
+        supports_dry_run
+
+        def collection
+          Spree::Store.with_deleted.order(:id)
+        end
+
+        # Locks the store's row, so a settings save made meanwhile is read
+        # rather than overwritten, and counts each change once it is written.
+        #
+        # @param store [Spree::Store]
+        # @return [void]
+        def process(store)
+          store.with_lock do
+            changes = time_zone_change(store).merge(admin_locale_change(store))
+            next if changes.empty?
+
+            if dry_run?
+              changes.each_value { |outcome, _value| tally(:"would_#{outcome}") }
+              next
+            end
+
+            changes.each { |name, (_outcome, value)| store.set_preference(name, value) }
+            store.update_columns(preferences: store.preferences, updated_at: Time.current)
+            changes.each_value { |outcome, _value| tally(outcome) }
+          end
+        end
+
+        private
+
+        def time_zone_change(store)
+          stored = store.preferred_timezone
+          return {} if Spree::TimeZones.valid?(stored)
+
+          converted = Spree::TimeZones.normalize(stored)
+          return { timezone: [:time_zone_converted, converted] } if Spree::TimeZones.valid?(converted)
+
+          { timezone: [:time_zone_reset_to_default, store.preference_default(:timezone)] }
+        end
+
+        def admin_locale_change(store)
+          stored = store.preferred_admin_locale
+          return {} if stored.blank? || Spree::Locales::ALL.include?(stored)
+
+          listed = Spree::Locales.listed(stored)
+          { admin_locale: listed ? [:admin_locale_converted, listed] : [:admin_locale_cleared, nil] }
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/spree/translatable_resource.rb

@@ -5,6 +5,9 @@ module Spree
     included do
       extend Mobility
       default_scope { i18n }
+
+      # Before the translations are autosaved, so it has to run first.
+      after_update :discard_blank_new_translations, prepend: true
     end
 
     class_methods do
@@ -178,6 +181,22 @@ module Spree
 
     private
 
+    # Clearing a translation's last value deletes its row, and Mobility then
+    # rebuilds a blank one for that locale while it finalizes dirty tracking.
+    # Saved, that blank row is either junk or, where translation rows are soft
+    # deleted (stores), a duplicate of the deleted row.
+    def discard_blank_new_translations
+      return unless association(:translations).loaded?
+
+      columns = self.class.translatable_fields.map(&:to_s)
+      translations.each do |translation|
+        next unless translation.new_record?
+        next if columns.any? { |column| translation[column].present? }
+
+        translation.mark_for_destruction
+      end
+    end
+
     # @raise [ActiveRecord::RecordInvalid] if any locale isn't supported by the store
     def validate_translation_locales!(locales)
       supported = translatable_store&.supported_locales_list || []

data/app/models/spree/invitation.rb

@@ -116,6 +116,15 @@ module Spree
       publish_event('invitation.resent')
     end
 
+    # The staff account holding the invited address, if one exists. Matched
+    # the way the account's email uniqueness is, case-insensitively, so an
+    # address typed in another case still finds the one account it can belong
+    # to. Resolved by record rather than by comparing strings in Ruby, whose
+    # case folding is wider than the database's.
+    def invitee_account
+      Spree.admin_user_class.where('LOWER(email) = LOWER(?)', email).first
+    end
+
     private
 
     def publish_invitation_created_event
@@ -161,7 +170,7 @@ module Spree
       return if resource.blank?
 
       # Check role_users directly for better performance and to avoid potential source_type issues
-      user_to_check = invitee || Spree.admin_user_class.find_by(email: email)
+      user_to_check = invitee || invitee_account
       return if user_to_check.blank?
 
       if resource.role_users.exists?(user: user_to_check)
@@ -172,7 +181,7 @@ module Spree
     def set_invitee_from_email
       return if invitee.present?
 
-      self.invitee = Spree.admin_user_class.find_by(email: email)
+      self.invitee = invitee_account
     end
   end
 end

data/app/models/spree/order_routing/strategy/rules.rb

@@ -10,7 +10,7 @@ module Spree
       # See docs/plans/6.0-order-routing.md.
       class Rules < Base
         def for_allocation
-          locations = eligible_locations
+          locations = coordinator.candidate_stock_locations
           return [] if locations.empty?
 
           ordered = Spree::OrderRouting::Strategy::Reducer
@@ -18,9 +18,11 @@ module Spree
             .rank_all(locations)
           return [] if ordered.empty?
 
-          packages = build_packages(ordered)
-          packages = prioritize_packages(packages)
-          estimate_rates(packages)
+          # Packed in rank order through the Coordinator, so an order allocates
+          # under the same delivery profile and channel coverage as its cart,
+          # and the Prioritizer's first-package-wins-on-hand logic honors the
+          # routing decision between origins that can reach the destination.
+          coordinator.estimate_packages(coordinator.allocated_packages(ordered))
         end
 
         # Stock decrement / restock today happens via Spree::Fulfillment's state
@@ -39,50 +41,8 @@ module Spree
           order.channel.order_routing_rules.active.ordered
         end
 
-        def eligible_locations
-          order.store.stock_locations.active
-            .joins(:stock_levels)
-            .where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids })
-            .distinct
-            .to_a
-        end
-
-        def requested_variant_ids
-          inventory_units.map(&:variant_id).uniq
-        end
-
-        def inventory_units
-          @inventory_units ||= Spree::Stock::InventoryUnitBuilder.new(order).units
-        end
-
-        # Pack each ranked location independently. Packages are emitted in
-        # rank order so the Prioritizer's first-package-wins-on-hand logic
-        # honors the routing decision.
-        def build_packages(locations)
-          stock_levels = Spree::Stock::Packer.stock_levels_by_location(locations, requested_variant_ids)
-
-          locations.flat_map do |location|
-            Spree::Stock::Packer.new(location, inventory_units, Spree.stock_splitters, owner: order,
-                                     stock_levels: stock_levels.fetch(location.id, {})).packages
-          end
-        end
-
-        # Prioritizer's Adjuster distributes each inventory_unit across
-        # packages: the first package with on-hand stock fulfills the unit,
-        # and downstream packages have that unit removed. Packages whose
-        # items all get stripped are pruned. Rank only decides between origins
-        # that can reach the destination — the Prioritizer demotes the rest.
-        def prioritize_packages(packages)
-          Spree::Stock::Prioritizer.new(packages, estimator: estimator).prioritized_packages
-        end
-
-        def estimate_rates(packages)
-          packages.each { |pkg| pkg.delivery_rates = estimator.delivery_rates(pkg) }
-          packages
-        end
-
-        def estimator
-          @estimator ||= Spree::Stock::Estimator.new(order)
+        def coordinator
+          @coordinator ||= Spree::Stock::Coordinator.new(order)
         end
       end
     end

data/app/models/spree/seller_transfer.rb

@@ -89,6 +89,16 @@ module Spree
     # amount is negative, and sending one as a transfer pays the seller the
     # money it exists to take back.
     scope :awaiting_provider, -> { earnings.retryable.where(payout_id: nil) }
+    # Reversals still owing the provider a call: refused, or waiting for their
+    # earning to reach the provider first. Kept apart from `awaiting_provider`
+    # so a caller has to choose `reverse!` for these by name.
+    #
+    # A reversal of an earning nobody can account for waits with it: there is
+    # nothing to take back from until a person settles what happened.
+    scope :reversals_awaiting_provider, lambda {
+      reversals_only.retryable.where(payout_id: nil).
+        where.not(reversed_from_id: Spree::SellerTransfer.with_status('unresolved').select(:id))
+    }
     # Earned and confirmed, but not yet swept into a settlement — what the next
     # payout will pick up.
     scope :unsettled, -> { completed.where(payout_id: nil) }
@@ -138,6 +148,47 @@ module Spree
       [amount - reversals.sum(:amount).abs, 0].max
     end
 
+    # The provider that moved this row's money, not whichever one the store
+    # uses now. A marketplace that changes provider still has money sitting
+    # with the old one, and asking the new one to reverse a transfer it never
+    # made leaves the original standing.
+    #
+    # No silent fallback when that provider is no longer installed: handing
+    # the row to a different one would mark it done while the money stayed
+    # where it was. An operator has to know.
+    #
+    # @return [Spree::PayoutProvider::Base]
+    # @raise [Spree::Core::GatewayError] when the provider is not registered
+    def payout_provider_instance
+      configured = Spree::ApiTyped.registered_class(Spree.payout_providers, provider)
+      raise Spree::Core::GatewayError, "Payout provider #{provider} is not registered" if configured.nil?
+
+      configured.new
+    end
+
+    # The settlement a reversal of part of this earning records.
+    #
+    # A clawback has to settle where its earning settled. Payouts are swept by
+    # settlement currency, so a reversal left in the sale's currency would
+    # never join the batch that pays the earning it cancels — the seller would
+    # be paid in full for goods that came back.
+    #
+    # Prorated from this earning's settled figure rather than converted at
+    # today's rate, so the money comes back at the rate it went out at.
+    #
+    # @param part [BigDecimal] how much of this earning is reversed, positive
+    # @return [Hash] negative `settled_amount` and `settled_currency`
+    def reversal_settlement(part)
+      return {} if settled_amount.blank? || amount.zero?
+
+      share = settled_amount * (part / amount)
+
+      {
+        settled_amount: -Spree::Money::Rounding.quantize(share, Spree::Money::Rounding.precision(settlement_currency)),
+        settled_currency: settled_currency
+      }
+    end
+
     # @return [Boolean]
     def earning?
       kind == 'earning'

data/app/models/spree/stock/coordinator.rb

@@ -22,13 +22,45 @@ module Spree
       end
 
       def packages
-        packages = build_packages
-        packages = prioritize_packages(packages)
-        packages = estimate_packages(packages)
+        estimate_packages(allocated_packages)
       end
 
-      def build_packages(packages = [])
-        stock_locations = stock_locations_with_requested_variants.to_a
+      # Where each unit comes from, without quoting a rate, so a caller that
+      # only needs the origins — a checkout hold — never costs a carrier request.
+      #
+      # @param stock_locations [Array<Spree::StockLocation>] candidate origins, preferred first
+      # @return [Array<Spree::Stock::Package>]
+      def allocated_packages(stock_locations = candidate_stock_locations)
+        prioritize_packages(build_packages(stock_locations: stock_locations))
+      end
+
+      # Whether any delivery method can carry the package to the order's
+      # address, by the rule allocation ranked origins with, so no rate is requested.
+      #
+      # @param package [Spree::Stock::Package]
+      # @return [Boolean]
+      def deliverable?(package)
+        estimator.deliverable?(package)
+      end
+
+      # @param packages [Array<Spree::Stock::Package>]
+      # @return [Array<Spree::Stock::Package>] the same packages, with their delivery rates
+      def estimate_packages(packages)
+        packages.each do |package|
+          package.delivery_rates = estimator.delivery_rates(package)
+        end
+        packages
+      end
+
+      # Active locations stocking any requested variant, in database order.
+      #
+      # @return [Array<Spree::StockLocation>]
+      def candidate_stock_locations
+        order.store.stock_locations.active.joins(:stock_levels)
+             .where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids }).distinct.to_a
+      end
+
+      def build_packages(packages = [], stock_locations: candidate_stock_locations)
         stock_levels = Packer.stock_levels_by_location(stock_locations, requested_variant_ids)
 
         stock_locations.each do |stock_location|
@@ -44,11 +76,6 @@ module Spree
 
       private
 
-      def stock_locations_with_requested_variants
-        order.store.stock_locations.active.joins(:stock_levels).
-          where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids }).distinct
-      end
-
       # An item may only be allocated from locations its delivery profile
       # covers — a profile narrowed to the cold-storage warehouse never packs
       # from anywhere else — intersected with the channel's served set when
@@ -104,13 +131,6 @@ module Spree
         prioritizer.prioritized_packages
       end
 
-      def estimate_packages(packages)
-        packages.each do |package|
-          package.delivery_rates = estimator.delivery_rates(package)
-        end
-        packages
-      end
-
       # Shared between prioritization (which origins can deliver at all) and
       # the rate refresh, so both answer with the same eligibility rules.
       def estimator

data/app/models/spree/stock/packer.rb

@@ -44,25 +44,35 @@ module Spree
         package = build_package
 
         # Group by variant_id as grouping by variant fires cached query.
-        units_by_variant_id = inventory_units.index_by(&:variant_id)
+        units_by_variant_id = inventory_units.group_by(&:variant_id)
         # The package's variants and their levels here, each in one query
         # rather than one per variant. Lowest id first, as StockLocation#stock_level reads.
         variants = variants_for(units_by_variant_id)
         stock_levels = @stock_levels || stock_location.stock_levels.where(variant_id: units_by_variant_id.keys).order(:id).
                        group_by(&:variant_id).transform_values(&:first)
 
-        units_by_variant_id.each do |variant_id, inventory_unit|
+        units_by_variant_id.each do |variant_id, units|
           variant = variants[variant_id] || Spree::Variant.find(variant_id)
-          unit = inventory_unit.dup # Can be used by others, do not use directly
+          # Can be used by others, do not use directly
+          units = units.map(&:dup)
           if variant.should_track_inventory?
             stock_level = stock_levels[variant_id]
             next if stock_level.nil?
 
-            on_hand, backordered = stock_location.fill_status(variant, unit.quantity, stock_level: stock_level)
-            package.add(FulfillmentItem.split(unit, backordered), :backordered) if backordered.positive?
-            package.add(FulfillmentItem.split(unit, on_hand), :on_hand) if on_hand.positive?
+            on_hand, backordered = stock_location.fill_status(variant, units.sum(&:quantity), stock_level: stock_level)
+            # Two lines of one variant draw on one shelf, so it is split
+            # between them in order rather than offered to each in full.
+            units.each do |unit|
+              unit_on_hand = [on_hand, unit.quantity].min
+              unit_backordered = [backordered, unit.quantity - unit_on_hand].min
+              on_hand -= unit_on_hand
+              backordered -= unit_backordered
+
+              package.add(FulfillmentItem.split(unit, unit_backordered), :backordered) if unit_backordered.positive?
+              package.add(FulfillmentItem.split(unit, unit_on_hand), :on_hand) if unit_on_hand.positive?
+            end
           else
-            package.add unit
+            units.each { |unit| package.add unit }
           end
         end
 
@@ -84,8 +94,8 @@ module Spree
       # The units' own variants when they carry them, so a cart's variants are
       # read once however many locations are packed.
       def variants_for(units_by_variant_id)
-        variants = units_by_variant_id.each_with_object({}) do |(variant_id, unit), loaded|
-          loaded[variant_id] = unit.variant if unit.association(:variant).loaded?
+        variants = units_by_variant_id.each_with_object({}) do |(variant_id, units), loaded|
+          loaded[variant_id] = units.first.variant if units.first.association(:variant).loaded?
         end
         missing_ids = units_by_variant_id.keys - variants.keys
         missing_ids.empty? ? variants : variants.merge(Spree::Variant.where(id: missing_ids).index_by(&:id))

data/app/models/spree/stock/prioritizer.rb

@@ -18,6 +18,7 @@ module Spree
 
       def prioritized_packages
         sort_packages
+        withdraw_covered_items
         adjust_packages
         prune_packages
         packages
@@ -44,11 +45,10 @@ module Spree
       end
 
       # Origins that can deliver go first, so the Adjuster fills each unit from
-      # one of them and the origins that cannot are left empty and pruned. A
-      # profile with per-region origin groups would otherwise allocate to
-      # whichever warehouse came first, and when that warehouse's group has no
-      # method for the destination the item is dropped as undeliverable even
-      # though another warehouse could have shipped it.
+      # one of them. A profile with per-region origin groups would otherwise
+      # allocate to whichever warehouse came first, and when that warehouse's
+      # group has no method for the destination the item is dropped as
+      # undeliverable even though another warehouse could have shipped it.
       #
       # The caller's order survives within each group, so routing rank and the
       # store's location order still decide between origins that can both
@@ -56,25 +56,40 @@ module Spree
       def sort_packages
         return if estimator.nil?
 
-        ranked = packages.each_with_index.sort_by do |package, index|
-          [estimator.deliverable?(package) ? 0 : 1, index]
+        deliverable, @undeliverable_packages = packages.partition { |package| estimator.deliverable?(package) }
+        packages.replace(deliverable + @undeliverable_packages)
+      end
+
+      # Ordering alone loses to the Adjuster, which takes stock on hand anywhere
+      # over a backorder; a unit the capable origins cannot cover stays, so it is
+      # still reported as undeliverable rather than lost.
+      def withdraw_covered_items
+        return if @undeliverable_packages.blank? || @undeliverable_packages.size == packages.size
+
+        supplied = supplied_quantities(packages - @undeliverable_packages)
+
+        @undeliverable_packages.each do |package|
+          package.contents.each do |item|
+            package.remove_item(item) if supplied[hash_item(item)] >= item.inventory_unit.required_quantity
+          end
         end
+      end
 
-        packages.replace(ranked.map(&:first))
+      def supplied_quantities(packages)
+        packages.flat_map(&:contents).each_with_object(Hash.new(0)) do |item, supplied|
+          supplied[hash_item(item)] += item.quantity
+        end
       end
 
       def prune_packages
         packages.reject!(&:empty?)
       end
 
+      # A proposed unit has no fulfillment, so its line item keeps two lines of
+      # one variant apart; a pair, as XORed ids collide whenever they match.
       def hash_item(item)
-        shipment = item.inventory_unit.fulfillment
-        variant  = item.inventory_unit.variant
-        if shipment.present?
-          variant.hash ^ shipment.hash
-        else
-          variant.hash
-        end
+        unit = item.inventory_unit
+        [unit.variant, unit.fulfillment || unit.line_item_id]
       end
     end
   end

data/app/models/spree/store.rb

@@ -42,6 +42,11 @@ module Spree
       acts_as_paranoid
       # deleted translation values still need to be accessible - remove deleted_at scope
       default_scope { unscope(where: :deleted_at) }
+
+      # Mobility deletes a row once its last value is cleared. The soft delete
+      # stamps only `deleted_at`, and the row stays readable, so the cleared
+      # values have to be written too or the old translation keeps showing.
+      before_destroy { update_columns(changes_to_save.transform_values(&:last)) if has_changes_to_save? }
     end
 
     #
@@ -50,8 +55,9 @@ module Spree
     UNIT_SYSTEMS = %w[metric imperial].freeze
 
     # general preferences
-    preference :admin_locale, :string, format: :locale
-    preference :timezone, :string, format: :timezone, default: Time.zone.name
+    preference :admin_locale, :string, format: :locale, parse_on_set: ->(value) { Spree::Locales.listed(value) || value.presence }
+    preference :timezone, :string, format: :timezone, default: Spree::TimeZones.normalize(Time.zone.name),
+                                   parse_on_set: ->(value) { Spree::TimeZones.normalize(value) }
     preference :weight_unit, :string, default: 'lb', choices: -> { Spree::Variant::WEIGHT_UNITS }
     preference :unit_system, :string, default: 'imperial', choices: -> { UNIT_SYSTEMS }
     # Anonymous identifier of this installation, kept on the default store
@@ -403,6 +409,8 @@ module Spree
                         message: :invalid_document_number_affix }
     validates :preferred_capture_method, inclusion: { in: Spree::CaptureMethod::CAPTURE_METHODS }
     validate :preferred_storefront_url_is_an_origin
+    validate :preferred_admin_locale_is_listed
+    validate :preferred_timezone_is_a_time_zone
     validate :order_number_sequence_start_unchanged_after_first_number, on: :update
     validates :mail_from_address, email: { allow_blank: false }
     validates :customer_support_email, email: { allow_blank: true }
@@ -836,6 +844,31 @@ module Spree
       errors.add(:preferred_storefront_url, :invalid)
     end
 
+    def preferred_admin_locale_is_listed
+      locale = preferred_admin_locale
+      return if locale.blank? || Spree::Locales::ALL.include?(locale)
+      return if awaiting_upgrade?(:admin_locale) { Spree::Locales.listed(locale) }
+
+      errors.add(:preferred_admin_locale, :inclusion)
+    end
+
+    def preferred_timezone_is_a_time_zone
+      return if Spree::TimeZones.valid?(preferred_timezone)
+      return if awaiting_upgrade?(:timezone) { Spree::TimeZones.valid?(Spree::TimeZones.normalize(preferred_timezone)) }
+
+      errors.add(:preferred_timezone, :invalid)
+    end
+
+    # A value saved before 6.0 that the store settings upgrade step converts
+    # must not block saving the store's other settings until the step runs.
+    # The block says whether the step can convert it.
+    def awaiting_upgrade?(name)
+      return false unless persisted?
+      return false unless public_send(:"preferred_#{name}") == (attribute_was('preferences') || {})[name]
+
+      yield.present?
+    end
+
     # The starting value only shapes a counter that does not exist yet — once
     # the first number is issued the counter owns the value, so accepting a
     # change here would persist a setting that can never apply again. The

data/app/services/spree/carts/update.rb

@@ -252,12 +252,13 @@ module Spree
 
       # Three-way dispatch on the cart→checkout transition:
       # entering checkout → Reserve, mid-checkout mutation → Extend, reverting to cart → Release.
+      # A new destination reserves again, because it can move the units to another origin.
       # A failed Reserve raises so the enclosing transaction rolls back and the
       # outer rescue surfaces the error to the API caller.
       def sync_stock_reservations(was_in_checkout:)
         if !cart.in_checkout?
           Spree::StockReservations::Release.call(cart: cart) if was_in_checkout
-        elsif was_in_checkout
+        elsif was_in_checkout && !@destination_changed && !@new_delivery_destination
           Spree::StockReservations::Extend.call(cart: cart)
         else
           result = Spree::StockReservations::Reserve.call(cart: cart)

data/app/services/spree/stock_reservations/reserve.rb

@@ -14,13 +14,17 @@ module Spree
 
         ApplicationRecord.transaction do
           targets = build_targets(cart)
-          break if targets.empty?
 
           # Pessimistic lock + fresh read of count_on_hand. The lock serializes
           # concurrent checkouts and we use the locked rows below so we never
-          # check stock against a stale association cache.
+          # check stock against a stale association cache. The shelves held
+          # now are locked with the new ones, in id order, so two checkouts
+          # moving holds past each other cannot deadlock.
+          stock_level_ids = targets.map { |_, si, _| si.id } |
+                            Spree::StockReservation.for_order(cart).pluck(:stock_level_id)
           locked_stock_levels = Spree::StockLevel
-            .where(id: targets.map { |_, si| si.id })
+            .where(id: stock_level_ids)
+            .order(:id)
             .lock
             .index_by(&:id)
 
@@ -29,22 +33,13 @@ module Spree
 
           this_order_used = Hash.new(0)
 
-          targets.each do |line_item, stock_level|
+          reservations = targets.map do |line_item, stock_level, quantity|
             stock_level = locked_stock_levels.fetch(stock_level.id)
             available = stock_level.available_count - held.fetch(stock_level.id, 0) - this_order_used[stock_level.id]
 
-            if available < line_item.quantity
-              raise InsufficientStockError.new(
-                line_item,
-                I18n.t(
-                  'spree.insufficient_stock_for_reservation',
-                  item: line_item.variant.name,
-                  available: [available, 0].max
-                )
-              )
-            end
+            raise_insufficient_stock(line_item, available) if available < quantity
 
-            this_order_used[stock_level.id] += line_item.quantity
+            this_order_used[stock_level.id] += quantity
 
             reservation = existing[[stock_level.id, line_item.id]] ||
                           Spree::StockReservation.new(stock_level: stock_level, line_item: line_item)
@@ -55,10 +50,15 @@ module Spree
               reservation.order = cart
               reservation.cart = nil
             end
-            reservation.quantity = line_item.quantity
+            reservation.quantity = quantity
             reservation.expires_at = expires_at
             reservation.save!
+            reservation
           end
+
+          # Left in place, a hold the allocation moved away from blocks other buyers until it expires.
+          moved = Spree::StockReservation.for_order(cart).where.not(id: reservations.map(&:id))
+          Spree::StockReservation.withdraw(moved)
         end
 
         success(cart)
@@ -68,23 +68,71 @@ module Spree
 
       private
 
+      # Held where the allocation packs each unit, so the hold protects the stock the order will ship.
       def build_targets(cart)
-        cart.line_items.includes(variant: [:product, { stock_levels: :stock_location }]).filter_map do |line_item|
+        cart.line_items.reset
+        coordinator = Spree::Stock::Coordinator.new(cart)
+        packages = coordinator.allocated_packages
+        check_allocated_in_full(cart, packages_items(packages))
+
+        # Once the address is known, a unit only an origin unable to reach it
+        # would pack cannot ship, so it is left to the delivery check rather
+        # than held where it blocks buyers that origin does serve.
+        packages = packages.select { |package| coordinator.deliverable?(package) } if cart.ship_address.present?
+        items = packages_items(packages)
+        stock_levels = Spree::Stock::Packer.stock_levels_by_location(packages.map(&:stock_location).uniq,
+                                                                     cart.line_items.map(&:variant_id).uniq)
+
+        # Summed because a splitter can pack one line into several packages from one location.
+        quantities = Hash.new(0)
+        items.each do |stock_location, item|
+          next unless item.on_hand?
+
+          line_item = item.inventory_unit.line_item
           variant = line_item.variant
-          next unless variant&.should_track_inventory?
-
-          stock_level = select_stock_level(variant)
+          stock_level = stock_levels.dig(stock_location.id, variant.id)
           # Backorderable and pre-cart variants oversell past count_on_hand,
           # so a reservation capped at on-hand stock would wrongly reject them;
           # their cap is enforced by Stock::Quantifier#can_supply? instead.
+          next unless variant.should_track_inventory?
           next if stock_level.nil? || stock_level.backorderable? || variant.preorder?
 
-          [line_item, stock_level]
+          quantities[[line_item, stock_level]] += item.quantity
+        end
+
+        quantities.map { |(line_item, stock_level), quantity| [line_item, stock_level, quantity] }
+      end
+
+      def packages_items(packages)
+        packages.flat_map { |package| package.contents.map { |item| [package.stock_location, item] } }
+      end
+
+      # A line placed nowhere is left to the delivery check, which can say why;
+      # one placed in part has shelves that fall short, and is refused.
+      def check_allocated_in_full(cart, items)
+        allocated = items.each_with_object(Hash.new(0)) do |(_, item), quantities|
+          quantities[item.inventory_unit.line_item_id] += item.quantity
+        end
+
+        cart.line_items.each do |line_item|
+          variant = line_item.variant
+          next unless variant&.should_track_inventory?
+          next if variant.preorder?
+
+          placed = allocated[line_item.id]
+          raise_insufficient_stock(line_item, placed) if placed.positive? && placed < line_item.quantity
         end
       end
 
-      def select_stock_level(variant)
-        variant.stock_levels.detect { |si| si.stock_location&.active? && si.available? }
+      def raise_insufficient_stock(line_item, available)
+        raise InsufficientStockError.new(
+          line_item,
+          I18n.t(
+            'spree.insufficient_stock_for_reservation',
+            item: line_item.variant.name,
+            available: [available, 0].max
+          )
+        )
       end
 
       def held_by_others(stock_level_ids, owner)
@@ -104,8 +152,8 @@ module Spree
       def existing_reservations_for(targets)
         return {} if targets.empty?
 
-        stock_level_ids = targets.map { |_, si| si.id }
-        line_item_ids = targets.map { |li, _| li.id }
+        stock_level_ids = targets.map { |_, si, _| si.id }
+        line_item_ids = targets.map { |li, _, _| li.id }
 
         Spree::StockReservation
           .where(stock_level_id: stock_level_ids, line_item_id: line_item_ids)

data/app/workflows/spree/seller_transfers/reverse.rb

@@ -202,34 +202,15 @@ module Spree
               kind: 'refund_reversal',
               provider: @earning.provider,
               status: 'pending'
-            }.merge(settlement_of(bounded))
+            }.merge(@earning.reversal_settlement(bounded))
           )
         end
       end
 
-      # A clawback has to settle where its earning settled. Payouts are swept by
-      # settlement currency, so a reversal left in the sale's currency would
-      # never join the batch that pays the earning it cancels — the seller would
-      # be paid in full for goods that came back, and the row would sit in a
-      # currency their account cannot pay.
-      #
-      # Prorated from the earning's own settled figure rather than converted at
-      # today's rate, so the money comes back at the rate it went out at.
-      def settlement_of(bounded)
-        return {} if @earning.settled_amount.blank? || @earning.amount.zero?
-
-        share = @earning.settled_amount * (bounded / @earning.amount)
-
-        {
-          settled_amount: -Spree::Money::Rounding.quantize(
-            share, Spree::Money::Rounding.precision(@earning.settlement_currency)
-          ),
-          settled_currency: @earning.settled_currency
-        }
-      end
-
+      # Asked of the provider that made the earning — see
+      # {Spree::SellerTransfer#payout_provider_instance}.
       def execute_reversal
-        provider.reverse!(reversal)
+        @earning.payout_provider_instance.reverse!(reversal)
       rescue Spree::Core::AmbiguousGatewayError => e
         # Whether the clawback happened is the provider's to say. Recorded as
         # such rather than as a refusal, so an operator reconciling knows which
@@ -238,31 +219,11 @@ module Spree
         Rails.error.report(e, handled: true, context: { seller_transfer_id: reversal.id }, source: 'spree.core')
         failure(reversal, e.message)
       rescue StandardError => e
+        # Left retryable: `ExecutePendingJob` asks the provider again.
         reversal.update!(status: 'processing')
         Rails.error.report(e, handled: true, context: { seller_transfer_id: reversal.id }, source: 'spree.core')
         failure(reversal, e.message)
       end
-
-      # The provider that made the earning, not whichever one the store uses
-      # now. A marketplace that changes provider still has money sitting with
-      # the old one, and asking the new one to reverse a transfer it never
-      # made leaves the original standing — the seller keeps a refunded sale.
-      def provider
-        @provider ||= begin
-          configured = Spree.payout_providers.find { |candidate| candidate.to_s == @earning.provider }
-
-          # No silent fallback to whatever the store uses now. A provider that
-          # is no longer installed still holds the transfer this reverses, and
-          # handing the job to a different one would mark the row reversed
-          # while the money stayed where it was. An operator has to know.
-          if configured.nil?
-            raise Spree::Core::GatewayError,
-                  "Payout provider #{@earning.provider} is not registered, so its transfer cannot be reversed"
-          end
-
-          configured.new
-        end
-      end
     end
   end
 end

data/db/migrate/20261029100001_add_lockout_columns_to_spree_admin_users.rb

@@ -0,0 +1,8 @@
+# Spree::AccountLockout reads these columns. Installs upgraded from a Devise
+# admin model without :lockable reach 6.0 with neither of them.
+class AddLockoutColumnsToSpreeAdminUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_column :spree_admin_users, :failed_attempts, :integer unless column_exists?(:spree_admin_users, :failed_attempts)
+    add_column :spree_admin_users, :locked_at, :datetime unless column_exists?(:spree_admin_users, :locked_at)
+  end
+end

data/lib/spree/checkout/default_requirements.rb

@@ -10,6 +10,12 @@ module Spree
     #
     # @see Requirements
     class DefaultRequirements
+      # Everything the discontinuation and stock checks read, so a set of
+      # lines is checked at once.
+      STOCK_CHECK_ASSOCIATIONS = {
+        variant: [{ product: %i[store product_publications] }, { stock_levels: %i[stock_location active_stock_reservations] }]
+      }.freeze
+
       # @param cart [Spree::Cart]
       def initialize(cart)
         @cart = cart
@@ -33,6 +39,7 @@ module Spree
           r << req('address', 'email', I18n.t('spree.checkout_requirements.email_required')) unless @cart.email.present?
           r << req('address', 'ship_address', I18n.t('spree.checkout_requirements.ship_address_required')) if @cart.shipping_address_required? && @cart.ship_address.blank?
           r << req('delivery', 'delivery_method', I18n.t('spree.checkout_requirements.delivery_method_required')) if delivery_step_required? && !delivery_method_selected?
+          r.concat(undeliverable_errors)
           r << req('payment', 'payment', I18n.t('spree.checkout_requirements.payment_required')) if payment_required? && !payment_satisfied?
           r << req('address', 'po_number', I18n.t('spree.checkout_requirements.po_number_required')) if po_number_missing?
           r << order_minimum_requirement if below_order_minimum?
@@ -102,16 +109,37 @@ module Spree
         end
       end
 
+      # A rebuild drops a proposal no method can quote with only a transient
+      # warning, so part of a line can be in no fulfillment. Advisory, so the
+      # buyer reads it while they can still change the address or the cart.
+      def undeliverable_errors
+        return [] unless delivery_step_required? && @cart.fulfillments.any?
+
+        undelivered_line_items.map do |line_item|
+          req('delivery', 'line_items', I18n.t('spree.cart_line_item.delivery_unavailable', li_name: line_item.name),
+              code: 'delivery_unavailable')
+        end
+      end
+
+      # A line short of stock is packed short too; the stock check already
+      # names it. Only lines short of a fulfillment pay for that check, so a
+      # cart read stays at one query.
+      def undelivered_line_items
+        allocated = Spree::FulfillmentItem.where(fulfillment_id: @cart.fulfillments.select(:id))
+                                          .group(:line_item_id).sum(:quantity)
+        short = @cart.line_items.select { |line_item| allocated.fetch(line_item.id, 0) < line_item.quantity }
+        return [] if short.empty?
+
+        ActiveRecord::Associations::Preloader.new(records: short, associations: STOCK_CHECK_ASSOCIATIONS).call
+        short.reject { |line_item| discontinued?(line_item) || !line_item.sufficient_stock? }
+      end
+
       def discontinued?(line_item)
         line_item.variant.nil? || line_item.variant.discontinued? || line_item.variant.product.discontinued?
       end
 
       def completion_line_items
-        # Everything the discontinuation and stock checks read, for every line
-        # at once.
-        @completion_line_items ||= @cart.line_items.includes(
-          variant: [{ product: %i[store product_publications] }, { stock_levels: %i[stock_location active_stock_reservations] }]
-        ).to_a
+        @completion_line_items ||= @cart.line_items.includes(STOCK_CHECK_ASSOCIATIONS).to_a
       end
 
       def delivery_step_required?

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
-  VERSION = '6.0.0'.freeze
+  VERSION = '6.0.1'.freeze
 
   def self.version
     VERSION

data/lib/spree/core.rb

@@ -666,6 +666,7 @@ require 'spree/i18n'
 require 'spree/iso_data'
 require 'spree/localized_number'
 require 'spree/measurement'
+require 'spree/time_zones'
 require 'spree/translations'
 require 'spree/money'
 require 'spree/service_module'

data/lib/spree/time_zones.rb

@@ -0,0 +1,34 @@
+module Spree
+  # Time zones are stored and exchanged as IANA identifiers (`Europe/Berlin`),
+  # the names browsers and every non-Ruby client understand. Rails' display
+  # names ("Eastern Time (US & Canada)") are converted to them on the way in.
+  module TimeZones
+    # The zones clients are offered: the IANA zones Rails gives a display name
+    # to, with plain `UTC` standing in for `Etc/UTC`. Any other valid IANA
+    # identifier is accepted too. The list comes with the Rails version rather
+    # than the machine's time zone database, so generated types match wherever
+    # the same Rails version runs.
+    SUGGESTED = (ActiveSupport::TimeZone::MAPPING.values - ['Etc/UTC'] + ['UTC']).uniq.sort.freeze
+
+    # @param identifier [String, nil]
+    # @return [Boolean] whether the value is an IANA time zone identifier
+    def self.valid?(identifier)
+      return false if identifier.blank?
+
+      TZInfo::Timezone.get(identifier.to_s)
+      true
+    rescue TZInfo::InvalidTimezoneIdentifier
+      false
+    end
+
+    # @param value [String, nil] an IANA identifier or a Rails time zone name
+    # @return [String, nil] the IANA identifier, or the value unchanged when it
+    #   names no zone the installed time zone database knows
+    def self.normalize(value)
+      return value if value.blank? || valid?(value)
+
+      identifier = ActiveSupport::TimeZone::MAPPING[value.to_s]
+      valid?(identifier) ? identifier : value
+    end
+  end
+end

data/lib/spree/upgrades/5_6_to_6_0/manifest.yml

@@ -597,6 +597,19 @@ steps:
       is dropped in 6.1. Idempotent — only rows without a capture_method are
       written.
 
+  - id: store_regional_settings
+    name: "Convert store time zones and admin languages to standard codes"
+    task_class: "Spree::MaintenanceTasks::Upgrade::StoreRegionalSettings"
+    notes: |
+      A store's time zone is now always an IANA name such as America/New_York,
+      and its admin language a locale code Spree lists, the forms the API
+      accepts and browsers understand. Rails time zone names such as
+      "Eastern Time (US & Canada)" and locale spellings such as en_US are
+      converted. A time zone that names no zone is reset to the store default,
+      which is what the store already ran on; an admin language Spree does not
+      list is cleared, so staff see their own language. Idempotent — stores
+      already on standard codes are skipped.
+
   - id: product_types_backfill
     name: "Backfill product type store ownership"
     task: "spree:product_types:backfill"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_core
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.0.1
 platform: ruby
 authors:
 - Sean Schofield
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-27 00:00:00.000000000 Z
+date: 2026-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n-tasks
@@ -785,6 +785,7 @@ files:
 - app/maintenance_tasks/spree/maintenance_tasks/upgrade/promotion_option_value_rules.rb
 - app/maintenance_tasks/spree/maintenance_tasks/upgrade/rake_step.rb
 - app/maintenance_tasks/spree/maintenance_tasks/upgrade/returns.rb
+- app/maintenance_tasks/spree/maintenance_tasks/upgrade/store_regional_settings.rb
 - app/maintenance_tasks/spree/maintenance_tasks/upgrade/users_to_customers.rb
 - app/maintenance_tasks/spree/maintenance_tasks/upgrade_step.rb
 - app/models/concerns/spree/account_deactivation.rb
@@ -2027,6 +2028,7 @@ files:
 - db/migrate/20261017100001_add_tax_exemption_reason_to_spree_tax_exemption_certificates.rb
 - db/migrate/20261022000001_store_credit_actor_polymorphic.rb
 - db/migrate/20261023100001_add_deactivated_at_to_spree_admin_users.rb
+- db/migrate/20261029100001_add_lockout_columns_to_spree_admin_users.rb
 - db/sample_data/channels.rb
 - db/sample_data/collections.rb
 - db/sample_data/custom_field_definitions.rb
@@ -2312,6 +2314,7 @@ files:
 - lib/spree/testing_support/store.rb
 - lib/spree/testing_support/tax_identifier_validators.rb
 - lib/spree/testing_support/url_helpers.rb
+- lib/spree/time_zones.rb
 - lib/spree/translations.rb
 - lib/spree/upgrade.rb
 - lib/spree/upgrades/5_4_to_5_5/manifest.yml
@@ -2397,9 +2400,9 @@ licenses:
 - BSD-3-Clause
 metadata:
   bug_tracker_uri: https://github.com/spree/spree/issues
-  changelog_uri: https://github.com/spree/spree/releases/tag/v6.0.0
+  changelog_uri: https://github.com/spree/spree/releases/tag/v6.0.1
   documentation_uri: https://docs.spreecommerce.org/
-  source_code_uri: https://github.com/spree/spree/tree/v6.0.0
+  source_code_uri: https://github.com/spree/spree/tree/v6.0.1
 post_install_message:
 rdoc_options: []
 require_paths: