typed_eav 0.6.0 → 0.7.0

data/app/models/typed_eav/field/base.rb

@@ -11,6 +11,8 @@ module TypedEAV
     # bases (`Field::ValidatedString`, `Field::RangeBounded`,
     # `Field::Optionable`) per ADR-0004; `validate_array_size` stays here
     # because its callers span unrelated families.
+    # rubocop:disable Metrics/ClassLength -- Base retains the public field
+    # lifecycle API; this change only adds the shared default-validation adapter.
     class Base < ApplicationRecord
       self.table_name = "typed_eav_fields"
 
@@ -42,6 +44,7 @@ module TypedEAV
       # ── Validations ──
 
       RESERVED_NAMES = %w[id type class created_at updated_at].freeze
+      DefaultValidationTarget = Struct.new(:errors).freeze
 
       validates :name, presence: true, uniqueness: { scope: %i[entity_type scope parent_scope] }
       validates :name, exclusion: { in: RESERVED_NAMES, message: "is reserved" }
@@ -77,6 +80,13 @@ module TypedEAV
       # and `throw(:abort)`s, mirroring AR's `dependent: :restrict_with_error`.
       before_destroy :dispatch_field_dependent
 
+      # Explicit large-population deletion. The default `destroy` and
+      # `destroy!` lifecycle remains unchanged; callers opt into resumable
+      # keyset batches through this method.
+      def destroy_with_values_in_batches!(batch_size: 1_000)
+        TypedEAV::FieldDeletion.destroy!(self, batch_size: batch_size)
+      end
+
       # Phase 03 event dispatch. SINGLE callback (no `on:` filter) that
       # branches across the four change_types in `_dispatch_field_change`.
       # Three reasons for one-callback-with-branch over the three-callback-
@@ -128,6 +138,14 @@ module TypedEAV
         )
       }
 
+      # Exact mutation partition. Unlike `for_entity`, this relation does not
+      # widen either axis with fallback rows. It intentionally starts from the
+      # STI base class in `reorder_within_partition` so every field type shares
+      # one ordering partition.
+      scope :for_partition, lambda { |entity_type, scope: nil, parent_scope: nil|
+        where(entity_type: entity_type, scope: scope, parent_scope: parent_scope)
+      }
+
       scope :sorted, -> { order(sort_order: :asc, name: :asc) }
       scope :required_fields, -> { where(required: true) }
 
@@ -306,6 +324,8 @@ module TypedEAV
       # ── Backfill ──
 
       # Backfills existing entities with this field's configured default value.
+      # `relation:` optionally narrows the exact host model in SQL; the
+      # default remains the complete entity class relation.
       # Iterates entities of `entity_type` in batches of 1000 via
       # `find_in_batches`, filtering each batch member by the field's
       # (scope, parent_scope) partition. Each WHOLE batch runs inside one
@@ -317,10 +337,9 @@ module TypedEAV
       #    per batch, this is ~1000 transactions, not 1M.
       #
       # Skip rule (per-record, applied INSIDE the batch loop): skip when the
-      # entity already has a non-nil typed value for this field. A Value row
-      # whose typed column is nil is still a candidate for backfill — the
-      # skip rule is "non-nil typed column," not "Value row exists" (matches
-      # CONTEXT.md).
+      # entity already has a logically present typed value for this field. A
+      # Value row whose declared cells are all nil is still a candidate for
+      # backfill; the rule is all-cell logical missingness, not row existence.
       #
       # Partition match: when field.scope is non-nil, the entity must respond
       # to typed_eav_scope and the value must match field.scope (as String).
@@ -348,16 +367,22 @@ module TypedEAV
       #   BackfillJob.perform_later(field.id)
       #
       # (Documented inline as RDoc; not built-in to keep the gem dep-free.)
-      def backfill_default!
+      # rubocop:disable Metrics/AbcSize -- backfill orchestration keeps the
+      # relation guard, batching, transaction, and partition work together.
+      def backfill_default!(relation: nil)
+        entity_class = entity_type.constantize
+        column = self.class.value_column
+        entity_relation = relation || entity_class.all
+        unless entity_relation.is_a?(ActiveRecord::Relation) && entity_relation.klass == entity_class
+          raise ArgumentError, "relation must be an ActiveRecord::Relation for #{entity_class.name}"
+        end
+
         # Short-circuit: nothing to backfill if no default configured. We
         # explicitly do NOT write nil rows — backfill is for propagating a
         # configured default, not for materializing empty Value rows.
         return if default_value.nil?
 
-        entity_class = entity_type.constantize
-        column = self.class.value_column
-
-        entity_class.find_in_batches(batch_size: 1000) do |batch|
+        entity_relation.find_in_batches(batch_size: 1000) do |batch|
           # One transaction per batch (NOT per record). If the transaction
           # raises mid-batch, the WHOLE batch rolls back and the exception
           # surfaces; prior batches stay committed. Caller re-runs idempotently
@@ -378,6 +403,7 @@ module TypedEAV
           end
         end
       end
+      # rubocop:enable Metrics/AbcSize
 
       # ── Schema export / import ──
 
@@ -439,8 +465,35 @@ module TypedEAV
         raw = default_value_meta["v"]
         return if raw.nil?
 
-        _, invalid = cast(raw)
-        errors.add(:default_value, "is not valid for this field type") if invalid
+        casted, invalid = cast(raw)
+        if invalid
+          errors.add(:default_value, "is not valid for this field type")
+          return
+        end
+
+        # An unsaved optionable field may receive its options after this
+        # validation (for example through nested attributes). In that case
+        # there is no domain to validate against yet; once options are
+        # persisted or built on the association, the shared validator runs.
+        return if option_domain_undetermined?
+
+        validate_default_domain(casted)
+      end
+
+      def option_domain_undetermined?
+        return false unless optionable? && new_record?
+
+        association = association(:field_options)
+        !association.loaded? && association.target.empty?
+      end
+
+      def validate_default_domain(casted)
+        association = association(:field_options)
+        association.loaded! if optionable? && association.target.any?
+
+        target = DefaultValidationTarget.new(ActiveModel::Errors.new(self))
+        validate_typed_value(target, casted)
+        target.errors.each { |error| errors.add(:default_value, error.type, **error.options) }
       end
 
       # Enforces type restrictions set via `has_typed_eav types: [...]`.
@@ -527,11 +580,11 @@ module TypedEAV
       # locking + normalization scaffold.
       def reorder_within_partition
         self.class.transaction do
-          locked = self.class
-                       .for_entity(entity_type, scope: scope, parent_scope: parent_scope)
-                       .order(:id)
-                       .lock("FOR UPDATE")
-                       .to_a
+          locked = TypedEAV::Field::Base
+                   .for_partition(entity_type, scope: scope, parent_scope: parent_scope)
+                   .order(:id)
+                   .lock("FOR UPDATE")
+                   .to_a
 
           # Sort the locked snapshot into display order (the lock was acquired
           # in :id order for deadlock safety; we reorder in memory for the
@@ -600,18 +653,15 @@ module TypedEAV
       #    `value:` explicitly bypasses the UNSET_VALUE sentinel path on
       #    Value#initialize (backfill knows the default; no need to re-
       #    resolve via the sentinel).
-      #  - row exists with nil typed column → update to default. This is the
-      #    case the skip rule deliberately allows backfill to fix (a Value
-      #    row created via explicit `value: nil` is still a backfill
-      #    candidate per CONTEXT.md).
-      #  - row exists with non-nil typed column → skip (idempotence).
-      def backfill_one(entity, column, existing)
+      #  - row exists with all declared typed cells nil → update to default.
+      #  - any declared typed cell non-nil → skip (idempotence).
+      def backfill_one(entity, _column, existing)
         if existing.nil?
           TypedEAV::Value.create!(entity: entity, field: self, value: default_value)
-        elsif existing[column].nil?
+        elsif logical_value_missing?(existing)
           existing.update!(value: default_value)
         end
-        # else: row exists with non-nil typed column → skip (skip rule).
+        # else: at least one declared typed cell is non-nil → skip.
       end
 
       # ── Phase 03 event dispatch ──
@@ -646,9 +696,8 @@ module TypedEAV
       # Rename detection is structural: any save where the :name column changed
       # counts as a rename, even if combined with other attribute changes
       # (sort_order, options, default_value, field_dependent). This false-
-      # positive bias is intentional — Phase 07's matview must regenerate
-      # column DDL on rename; missing a rename combined with other edits would
-      # corrupt the matview's column-name → field-name map.
+      # positive bias is intentional — a registered consumer must not miss a
+      # rename combined with other edits.
       #
       # `:name` is the only attribute name we hardcode in this callback, and
       # it's structural (the locked rename-detection mechanism per 03-CONTEXT.md),
@@ -667,5 +716,6 @@ module TypedEAV
         TypedEAV::EventDispatcher.dispatch_field_change(self, change_type)
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/app/models/typed_eav/field/currency.rb

@@ -126,6 +126,49 @@ module TypedEAV
 
         [{ amount: amount_bd, currency: currency_str }, false]
       end
+
+      # Currency query operators target one component of the composite value.
+      def cast_query_operand(operator, raw)
+        return cast_currency_query(raw) if operator.to_sym == :currency_eq
+
+        bounds = if operator.to_sym == :between
+                   if raw.is_a?(Range)
+                     [raw.begin, raw.end]
+                   elsif raw.is_a?(Array) && raw.length == 2
+                     raw
+                   else
+                     raise ArgumentError, ":between expects a Range or two-element Array"
+                   end
+                 end
+        return bounds.map { |bound| cast_amount_query(bound) }.then { |pair| pair.first..pair.last } if bounds
+
+        cast_amount_query(raw)
+      end
+
+      private
+
+      def cast_amount_query(raw)
+        return nil if raw.nil?
+
+        amount = BigDecimal(raw.to_s, exception: false)
+        raise ArgumentError, "Invalid #{self.class.name} query operand: #{raw.inspect}" unless amount
+
+        amount
+      end
+
+      def cast_currency_query(raw)
+        return nil if raw.nil?
+
+        currency = raw.to_s.upcase
+        unless currency.match?(/\A[A-Z]{3}\z/)
+          raise ArgumentError, "Invalid #{self.class.name} query operand: #{raw.inspect}"
+        end
+
+        currency
+      end
+
+      public
+
       # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       # Co-population validation + allowed_currencies inclusion.

data/app/models/typed_eav/field/file.rb

@@ -43,7 +43,7 @@ module TypedEAV
           raise NotImplementedError,
                 "TypedEAV::Field::File requires Active Storage. " \
                 "Add `gem 'activestorage'` to your Gemfile (already " \
-                "included via the `rails` meta-gem in Rails 7.1+) and " \
+                "included via the `rails` meta-gem in Rails 7.2+) and " \
                 "run `bin/rails active_storage:install`."
         end
 

data/app/models/typed_eav/field/image.rb

@@ -87,7 +87,7 @@ module TypedEAV
           raise NotImplementedError,
                 "TypedEAV::Field::Image requires Active Storage. " \
                 "Add `gem 'activestorage'` to your Gemfile (already " \
-                "included via the `rails` meta-gem in Rails 7.1+) and " \
+                "included via the `rails` meta-gem in Rails 7.2+) and " \
                 "run `bin/rails active_storage:install`."
         end
 

data/app/models/typed_eav/field/reference.rb

@@ -125,6 +125,17 @@ module TypedEAV
         [nil, true]
       end
 
+      # A class-mismatched record deliberately retains the historical empty
+      # relation behavior of :references instead of becoming a query error.
+      def cast_query_operand(operator, raw)
+        casted, invalid = cast(raw)
+        return invalid ? nil : casted if operator.to_sym == :references
+
+        raise ArgumentError, "Invalid #{self.class.name} query operand: #{raw.inspect}" if invalid
+
+        casted
+      end
+
       # Value-time validation: when target_scope is set on the field,
       # the target record's typed_eav_scope must match. When target_scope
       # is nil, no cross-scope check fires (the field author is declaring

data/app/models/typed_eav/section.rb

@@ -29,6 +29,12 @@ module TypedEAV
         parent_scope: [parent_scope, nil].uniq,
       )
     }
+
+    # Exact mutation partition. Visibility intentionally widens through
+    # `for_entity`; ordering mutations must only normalize this exact tuple.
+    scope :for_partition, lambda { |entity_type, scope: nil, parent_scope: nil|
+      where(entity_type: entity_type, scope: scope, parent_scope: parent_scope)
+    }
     scope :sorted, -> { order(sort_order: :asc, name: :asc) }
 
     # ── Display ordering ──
@@ -110,11 +116,11 @@ module TypedEAV
 
     def reorder_within_partition
       self.class.transaction do
-        locked = self.class
-                     .for_entity(entity_type, scope: scope, parent_scope: parent_scope)
-                     .order(:id)
-                     .lock("FOR UPDATE")
-                     .to_a
+        locked = TypedEAV::Section
+                 .for_partition(entity_type, scope: scope, parent_scope: parent_scope)
+                 .order(:id)
+                 .lock("FOR UPDATE")
+                 .to_a
 
         siblings = locked.sort_by { |r| [r.sort_order.nil? ? 1 : 0, r.sort_order || 0, r.name.to_s] }
 

data/app/models/typed_eav/value.rb

@@ -54,12 +54,19 @@ module TypedEAV
 
     # ── Validations ──
 
-    validates :field, uniqueness: { scope: %i[entity_type entity_id] }
+    # BulkUpsert rejects duplicate input keys globally and uses one database
+    # upsert for the unit. Skip only this persisted-row probe in that explicit
+    # context; all cast, entity, partition, and domain validators still run.
+    validates :field, uniqueness: { scope: %i[entity_type entity_id] }, unless: :bulk_upsert_validation?
     validate :validate_value
     validate :validate_entity_matches_field
     validate :validate_field_scope_matches_entity
     validate :validate_json_size
 
+    def bulk_upsert_validation?
+      validation_context == :bulk_upsert
+    end
+
     # ── Value access ──
     #
     # The magic here is that we delegate to the correct typed column
@@ -131,27 +138,37 @@ module TypedEAV
     # (NOT a DB column, NOT validated, NOT persisted). Stamped by
     # `Entity.bulk_set_typed_eav_values` on each affected Value object
     # BEFORE `record.save` inside the per-record `with_context` block. The
-    # Phase 04 versioning subscriber reads it preferentially over
+    # The transactional version writer reads it preferentially over
     # `context[:version_group_id]` so the UUID survives the outer-transaction
-    # `after_commit` boundary even after `with_context` has unwound (the
+    # source transaction boundary even after `with_context` has unwound (the
     # `with_context` block lexically pops on yield-return; by the time the
-    # outer transaction's after_commit chain fires, `TypedEAV.current_context`
+    # outer transaction completes, `TypedEAV.current_context`
     # would observe an empty Hash, but the per-Value snapshot persists in
     # the AR object's @pending_version_group_id ivar).
     #
     # Mirrors the existing in-memory ivar pattern at `value=` line 118
     # (`@cast_was_invalid`): a transient flag stamped during the write path
-    # and read by a downstream observer (validate_value / subscriber). No
+    # and read by the transactional version writer. No
     # accessor magic — plain attr_accessor; the ivar is allocated lazily on
     # first write.
     #
-    # Non-bulk callers do not stamp this ivar and the Phase 4 subscriber
+    # Non-bulk callers do not stamp this ivar and the transactional writer
     # falls back to `context[:version_group_id]` (which the existing
     # `with_context(version_group_id: uuid) { ... }` callers already set).
     # Backward compatible: every pre-Phase-6 caller path continues to work
     # unchanged.
     attr_accessor :pending_version_group_id
 
+    # Consume the correlation marker exactly once. The public reader/writer
+    # remain available for bulk callers, while the subscriber gets an
+    # atomic-in-process read-and-clear operation that cannot contaminate a
+    # later mutation of the same AR object.
+    def consume_pending_version_group_id
+      group_id = pending_version_group_id
+      self.pending_version_group_id = nil
+      group_id
+    end
+
     # Append-only audit log of mutations to this Value, ordered most-
     # recent-first. Returns a relation that can be chained (`.where`,
     # `.limit`, `.pluck`).
@@ -181,11 +198,10 @@ module TypedEAV
     end
 
     # Revert this Value's typed columns to the state recorded in
-    # `version.before_value`, then save!. The save fires the existing
-    # `after_commit :_dispatch_value_change_update` chain; EventDispatcher
-    # routes through TypedEAV::Versioning::Subscriber (slot 0); a NEW
-    # version row is written where after_value reflects the targeted
-    # version's before_value.
+    # `version.before_value`, then save!. The save fires the transactional
+    # version callback and the independent public after_commit dispatcher; a NEW
+    # version row is written where after_value reflects the targeted version's
+    # before_value.
     #
     # This is the locked CONTEXT contract (04-CONTEXT.md §`Value#revert_to`
     # semantics): revert is itself versioned. Append-only audit trail
@@ -231,9 +247,9 @@ module TypedEAV
     # rubocop:disable Metrics/AbcSize -- three guard clauses (each with a multi-line error message including ids) plus the column-iteration body genuinely belong together; splitting them would obscure the locked check ordering documented above. The ABC complexity is just over the 25 threshold and reflects the explicit error-message construction (not control-flow density).
     def revert_to(version)
       # Check 1: source Value must still exist. plan 04-02's subscriber writes
-      # value_id: nil for :destroy events (because the parent typed_eav_values
-      # row is gone by after_commit on :destroy time and FK ON DELETE SET NULL
-      # would FK-fail at INSERT otherwise). A destroy version cannot be
+      # value_id: nil for :destroy events. The destroy writer deliberately
+      # records nil while the parent exists, so the audit row is
+      # association-free before deletion and remains so afterward. A destroy version cannot be
       # reverted because we can't save! a destroyed AR record back into
       # existence. This check covers all destroy versions.
       if version.value_id.nil?
@@ -316,7 +332,7 @@ module TypedEAV
 
     after_initialize :apply_pending_value
 
-    # Phase 03 event dispatch. THREE explicit `after_commit ..., on: :X`
+    # Public event dispatch. THREE explicit `after_commit ..., on: :X`
     # declarations rather than the after_create_commit/after_update_commit/
     # after_destroy_commit alias trio: Rails 8.1 has a documented alias
     # collision where reusing the same method name across the alias forms
@@ -325,17 +341,20 @@ module TypedEAV
     # first). The explicit `on:` form sidesteps the bug entirely.
     #
     # Each callback forwards to a private `_dispatch_value_change_*` method
-    # that delegates to TypedEAV::EventDispatcher. Models stay thin — all
+    # that delegates to TypedEAV::EventDispatcher. Models stay thin — public
     # dispatch policy (internal-vs-user proc ordering, error rescue, context
     # injection) lives in EventDispatcher and is unit-testable without AR.
     after_commit :_dispatch_value_change_create,  on: :create
     after_commit :_dispatch_value_change_update,  on: :update
     after_commit :_dispatch_value_change_destroy, on: :destroy
 
+    # Version rows are written by boot-installed transactional callbacks so
+    # they are part of the same source transaction. These after_commit dispatchers
+    # remain for public callbacks and other non-durable observers.
+
     # Phase 05 image-attached dispatch. Declared AFTER the value-change
-    # callbacks so it runs LAST in the after_commit chain — Phase 04
-    # versioning (slot 0 inside _dispatch_value_change_*) and Phase 03
-    # on_value_change both fire before this. The hook is informational
+    # callbacks so it runs LAST in the after_commit chain — the transactional
+    # version callback and Phase 03 on_value_change both fire before this. The hook is informational
     # ("an image was attached"), not mutational; running last avoids
     # polluting earlier hooks' snapshots / context with attachment-
     # derived state.
@@ -348,13 +367,33 @@ module TypedEAV
     # (Field::File, every other built-in) explicitly do NOT fire this
     # hook — File-attached has no parallel hook by ROADMAP design.
     after_commit :_dispatch_image_attached, on: %i[create update]
+    after_rollback :clear_pending_version_group_id
+
+    # Active Record invokes these transaction-record hooks from an ensure
+    # path even when another callback raises. Finalize here rather than in a
+    # trailing after_commit callback so a skipped dispatch cannot leave a
+    # correlation marker attached to an object reused by the caller.
+    def committed!(should_run_callbacks: true)
+      super
+    ensure
+      clear_pending_version_group_id
+    end
+
+    def rolledback!(force_restore_state: false, should_run_callbacks: true)
+      super
+    ensure
+      clear_pending_version_group_id
+    end
 
     private
 
     def apply_pending_value
-      return unless @pending_value && field
+      return unless instance_variable_defined?(:@pending_value) && field
 
-      if @pending_value.equal?(UNSET_VALUE)
+      pending_value = @pending_value
+      remove_instance_variable(:@pending_value)
+
+      if pending_value.equal?(UNSET_VALUE)
         # Sentinel-pending branch: dispatch directly to apply_field_default.
         # We deliberately do NOT route through `self.value =` here because
         # value= would re-trigger the sentinel branch with field present,
@@ -363,9 +402,28 @@ module TypedEAV
         # easy to follow.
         apply_field_default
       else
-        self.value = @pending_value
+        self.value = pending_value
       end
-      @pending_value = nil
+    end
+
+    def clear_pending_version_group_id
+      self.pending_version_group_id = nil
+    end
+
+    def _write_version_create
+      TypedEAV::Versioning::Subscriber.call(self, :create, TypedEAV.current_context)
+    end
+
+    def _write_version_update
+      return unless field&.value_changed?(self)
+
+      TypedEAV::Versioning::Subscriber.call(self, :update, TypedEAV.current_context)
+    end
+
+    def _write_version_destroy
+      return unless field
+
+      TypedEAV::Versioning::Subscriber.call(self, :destroy, TypedEAV.current_context)
     end
 
     # Writes the field's configured default to the typed column(s) via the
@@ -390,7 +448,6 @@ module TypedEAV
 
       if @cast_was_invalid
         errors.add(:value, :invalid)
-        @cast_was_invalid = false
         return
       end
 
@@ -499,13 +556,13 @@ module TypedEAV
     # field_id NULLed by the Phase 02 ON DELETE SET NULL FK when a Field
     # with field_dependent: :nullify was destroyed). The event contract
     # is `(value, change_type, context)` and consumers expect
-    # `value.field` to be readable; an orphan would confuse Phase 04
-    # versioning and Phase 07 matview consumers, so we drop the event
+    # `value.field` to be readable; an orphan would confuse the transactional
+    # versioning and other internal consumers, so we drop the event
     # at the model boundary rather than push the nil-guard downstream.
     #
-    # Update filter (Phase 04 fix): only fire :update when ANY of the typed
+    # Update filter: only fire :update when ANY of the typed
     # columns the field uses changed (value_columns plural — added in
-    # plan 04-02). For all 17 single-cell field types as of Phase 04,
+    # transactional writer). For all single-cell field types,
     # value_columns returns [value_column], so this is behaviorally
     # identical to the singular form Phase 03 shipped. For Phase 05
     # Currency (two-cell), a change to either column correctly fires the
@@ -515,21 +572,23 @@ module TypedEAV
     #
     # A Value row's only meaningful change for downstream consumers is
     # its typed columns — field_id repointing or other bookkeeping shifts
-    # are out-of-spec for the event contract. Without this filter, Phase 04
+    # are out-of-spec for the event contract. Without this filter, the
     # versioning would pile up no-op version rows (every audit-trail
-    # commit) and Phase 07 matview would refresh on bookkeeping-only writes.
+    # commit) and internal consumers would refresh on bookkeeping-only writes.
 
     def _dispatch_value_change_create
       return unless field
 
       TypedEAV::EventDispatcher.dispatch_value_change(self, :create)
+    ensure
+      clear_pending_version_group_id
     end
 
     def _dispatch_value_change_update
       return unless field
       # Forward-compat with Phase 05 Currency (and any future multi-cell
       # field type): check if ANY of the typed columns the field uses
-      # changed in the just-committed save. Phase 04 plan 02 introduces
+      # changed in the just-committed save. The transactional writer
       # `value_columns` plural in lib/typed_eav/column_mapping.rb; for
       # all 17 current single-cell types, value_columns returns
       # [value_column], so this filter is behaviorally identical to the
@@ -538,17 +597,21 @@ module TypedEAV
       # either cell now correctly fires the :update event — without this
       # plural fix, a Currency change to only the string_value (currency
       # code) cell would silently be missed by the dispatch gate, and
-      # Phase 04 versioning would never see it (Scout §3 / Discrepancy D3
+      # transactional version writer would never see it
       # from plan 04-01).
       return unless field.value_changed?(self)
 
       TypedEAV::EventDispatcher.dispatch_value_change(self, :update)
+    ensure
+      clear_pending_version_group_id
     end
 
     def _dispatch_value_change_destroy
       return unless field
 
       TypedEAV::EventDispatcher.dispatch_value_change(self, :destroy)
+    ensure
+      clear_pending_version_group_id
     end
 
     # Phase 05 on_image_attached dispatch.

data/db/migrate/20260430000000_add_parent_scope_to_typed_eav_partitions.rb

@@ -44,7 +44,7 @@ class AddParentScopeToTypedEAVPartitions < ActiveRecord::Migration[7.1]
     #    standard semantics, so we don't need `NULLS NOT DISTINCT` (PG ≥ 15).
     #
     #    Option A (`nulls_not_distinct: true`) was rejected because the
-    #    gemspec floor is `rails >= 7.1` and there is no PG-server-version
+    #    gemspec floor is `rails >= 7.2` and there is no PG-server-version
     #    pin — consumer apps may run PG 12/13/14 where the option does
     #    not exist.
     #

data/db/migrate/20260712000000_enforce_parent_scope_invariant.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 class EnforceParentScopeInvariant < ActiveRecord::Migration[7.1]
+  # Strong Migrations requires check-constraint validation outside the default
+  # transaction so the catalog-only add and validation can proceed safely.
+  disable_ddl_transaction!
+
   CONSTRAINTS = {
     typed_eav_fields: :chk_te_fields_parent_scope_requires_scope,
     typed_eav_sections: :chk_te_sections_parent_scope_requires_scope,