diff --git a/Example/OpenSwiftUIUITests/Render/GeometryEffect/IgnoredByLayoutEffectUITests.swift b/Example/OpenSwiftUIUITests/Render/GeometryEffect/IgnoredByLayoutEffectUITests.swift
index 0fc9e38d0..9ab345177 100644
--- a/Example/OpenSwiftUIUITests/Render/GeometryEffect/IgnoredByLayoutEffectUITests.swift
+++ b/Example/OpenSwiftUIUITests/Render/GeometryEffect/IgnoredByLayoutEffectUITests.swift
@@ -8,7 +8,7 @@ import SnapshotTesting
 @MainActor
 @Suite(.snapshots(record: .never, diffTool: diffTool))
 struct IgnoredByLayoutEffectUITests {
-    @Test(.disabled("Animation is not implmemented yet"))
+    @Test
     func offsetIgnoredByLayout() {
         struct ContentView: View {
             var body: some View {
diff --git a/Sources/OpenSwiftUI/Animation/Animatable/AnimatableModifier.swift b/Sources/OpenSwiftUI/Animation/Animatable/AnimatableModifier.swift
new file mode 100644
index 000000000..d23a43231
--- /dev/null
+++ b/Sources/OpenSwiftUI/Animation/Animatable/AnimatableModifier.swift
@@ -0,0 +1,50 @@
+//
+//  AnimatableModifier.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+@_spi(ForOpenSwiftUIOnly)
+import OpenSwiftUICore
+
+/// A modifier that can create another modifier with animation.
+@available(OpenSwiftUI_v1_0, *)
+@available(*, deprecated, message: "use Animatable directly")
+public protocol AnimatableModifier: Animatable, ViewModifier {}
+
+@available(OpenSwiftUI_v1_0, *)
+@available(*, deprecated, message: "use Animatable directly")
+extension AnimatableModifier {
+    nonisolated public static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        let animatableViewModifier = makeAnimatable(
+            value: modifier,
+            inputs: inputs.base
+        )
+        return makeView(
+            modifier: _GraphValue(animatableViewModifier),
+            inputs: inputs,
+            body: body
+        )
+    }
+
+    nonisolated public static func _makeViewList(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewListInputs,
+        body: @escaping (_Graph, _ViewListInputs) -> _ViewListOutputs
+    ) -> _ViewListOutputs {
+        let animatableViewModifier = makeAnimatable(
+            value: modifier,
+            inputs: inputs.base
+        )
+        return makeViewList(
+            modifier: _GraphValue(animatableViewModifier),
+            inputs: inputs,
+            body: body
+        )
+    }
+}
diff --git a/Sources/OpenSwiftUI/Animation/Animatable/AnimatableView.swift b/Sources/OpenSwiftUI/Animation/Animatable/AnimatableView.swift
new file mode 100644
index 000000000..42243a45f
--- /dev/null
+++ b/Sources/OpenSwiftUI/Animation/Animatable/AnimatableView.swift
@@ -0,0 +1,33 @@
+//
+//  AnimatableView.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+@_spi(ForOpenSwiftUIOnly)
+import OpenSwiftUICore
+
+@available(OpenSwiftUI_v1_0, *)
+@available(*, deprecated, message: "use Animatable directly")
+public protocol _AnimatableView: Animatable, View {}
+
+@available(OpenSwiftUI_v1_0, *)
+@available(*, deprecated, message: "use Animatable directly")
+extension _AnimatableView {
+    nonisolated public static func _makeView(
+        view: _GraphValue<Self>,
+        inputs: _ViewInputs
+    ) -> _ViewOutputs {
+        let animatableView = makeAnimatable(value: view, inputs: inputs.base)
+        return makeView(view: _GraphValue(animatableView), inputs: inputs)
+    }
+
+    nonisolated public static func _makeViewList(
+        view: _GraphValue<Self>,
+        inputs: _ViewListInputs
+    ) -> _ViewListOutputs {
+        let animatableView = makeAnimatable(value: view, inputs: inputs.base)
+        return makeViewList(view: _GraphValue(animatableView), inputs: inputs)
+    }
+}
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/Animatable.swift b/Sources/OpenSwiftUICore/Animation/Animatable/Animatable.swift
similarity index 96%
rename from Sources/OpenSwiftUICore/View/Animation/Animation/Animatable.swift
rename to Sources/OpenSwiftUICore/Animation/Animatable/Animatable.swift
index 2332167b1..b1779cd00 100644
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/Animatable.swift
+++ b/Sources/OpenSwiftUICore/Animation/Animatable/Animatable.swift
@@ -2,12 +2,13 @@
 //  Animatable.swift
 //  OpenSwiftUICore
 //
+//  Audited for 6.4.41
 //  Status: Complete
 
 public import Foundation
 package import OpenGraphShims
 
-// MARK: - Animatable [6.4.41]
+// MARK: - Animatable
 
 /// A type that describes how to animate a property of a view.
 public protocol Animatable {
@@ -22,7 +23,7 @@ public protocol Animatable {
     static func _makeAnimatable(value: inout _GraphValue<Self>, inputs: _GraphInputs)
 }
 
-// MARK: - Animateble + Extension [6.4.41]
+// MARK: - Animateble + Extension
 
 extension Animatable where Self: VectorArithmetic {
     public var animatableData: Self {
@@ -77,7 +78,7 @@ extension Animatable {
     }
 }
 
-// MARK: - EmptyAnimatableData [6.4.41]
+// MARK: - EmptyAnimatableData
 
 /// An empty type for animatable data.
 ///
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/AnimatableArray.swift b/Sources/OpenSwiftUICore/Animation/Animatable/AnimatableArray.swift
similarity index 98%
rename from Sources/OpenSwiftUICore/View/Animation/Animation/AnimatableArray.swift
rename to Sources/OpenSwiftUICore/Animation/Animatable/AnimatableArray.swift
index dd3b2a04a..ed827e402 100644
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/AnimatableArray.swift
+++ b/Sources/OpenSwiftUICore/Animation/Animatable/AnimatableArray.swift
@@ -2,7 +2,7 @@
 //  AnimatableArray.swift
 //  OpenSwiftUICore
 //
-//  Audited for iOS 18.0
+//  Audited for 6.0.87
 //  Status: Complete
 
 package struct AnimatableArray<Element>: VectorArithmetic where Element: VectorArithmetic {
diff --git a/Sources/OpenSwiftUICore/Animation/Animatable/AnimatableAttribute.swift b/Sources/OpenSwiftUICore/Animation/Animatable/AnimatableAttribute.swift
new file mode 100644
index 000000000..8d2f6c280
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Animation/Animatable/AnimatableAttribute.swift
@@ -0,0 +1,685 @@
+//
+//  AnimatableAttribute.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Blocked by Trace
+//  ID: 35ADF281214A25133F1A6DF28858952D (SwiftUICore)
+
+package import Foundation
+package import OpenGraphShims
+
+// MARK: - AnimatableAttribute
+
+package struct AnimatableAttribute<Value>: StatefulRule, AsyncAttribute, ObservedAttribute, CustomStringConvertible where Value: Animatable {
+    @Attribute var source: Value
+    @Attribute var environment: EnvironmentValues
+    var helper: AnimatableAttributeHelper<Value>
+
+    package init(
+        source: Attribute<Value>,
+        phase: Attribute<_GraphInputs.Phase>,
+        time: Attribute<Time>,
+        transaction: Attribute<Transaction>,
+        environment: Attribute<EnvironmentValues>
+    ) {
+        _source = source
+        _environment = environment
+        helper = .init(phase: phase, time: time, transaction: transaction)
+    }
+
+    package mutating func updateValue() {
+        var sourceValue = $source.changedValue()
+        helper.update(
+            value: &sourceValue,
+            defaultAnimation: nil,
+            environment: $environment
+        )
+        guard sourceValue.changed || !hasValue else {
+            return
+        }
+        value = sourceValue.value
+    }
+
+    package var description: String { "Animatable<\(Value.self)>" }
+
+    package mutating func destroy() {
+        helper.removeListeners()
+    }
+}
+
+// MARK: - AnimatableFrameAttribute
+
+package struct AnimatableFrameAttribute: StatefulRule, AsyncAttribute, ObservedAttribute {
+    @Attribute
+    private var position: ViewOrigin
+
+    @Attribute
+    private var size: ViewSize
+
+    @Attribute
+    private var pixelLength: CGFloat
+
+    @Attribute
+    private var environment: EnvironmentValues
+
+    private var helper: AnimatableAttributeHelper<ViewFrame>
+
+    let animationsDisabled: Bool
+
+    package init(
+        position: Attribute<ViewOrigin>,
+        size: Attribute<ViewSize>,
+        pixelLength: Attribute<CGFloat>,
+        environment: Attribute<EnvironmentValues>,
+        phase: Attribute<_GraphInputs.Phase>,
+        time: Attribute<Time>,
+        transaction: Attribute<Transaction>,
+        animationsDisabled: Bool
+    ) {
+        _position = position
+        _size = size
+        _pixelLength = pixelLength
+        _environment = environment
+        helper = .init(phase: phase, time: time, transaction: transaction)
+        self.animationsDisabled = animationsDisabled
+    }
+
+    package typealias Value = ViewFrame
+
+    package mutating func updateValue() {
+        let (position, positionChanged) = $position.changedValue()
+        let (size, sizeChanged) = $size.changedValue()
+        let (pixelLength, pixelLengthChanged) = $pixelLength.changedValue()
+        let anyChanged = positionChanged || sizeChanged || pixelLengthChanged
+        var rect = CGRect(origin: position, size: size.value)
+        rect.roundCoordinatesToNearestOrUp(toMultipleOf: pixelLength)
+        let viewFrame = ViewFrame(
+            origin: rect.origin,
+            size: ViewSize(value: rect.size, proposal: size._proposal)
+        )
+        var sourceValue = (
+            value: viewFrame,
+            changed: anyChanged
+        )
+        if !animationsDisabled {
+            helper.update(
+                value: &sourceValue,
+                defaultAnimation: nil,
+                environment: $environment
+            )
+        }
+        guard sourceValue.changed || !hasValue else {
+            return
+        }
+        value = sourceValue.value
+    }
+
+    package mutating func destroy() {
+        helper.removeListeners()
+    }
+}
+
+// MARK: - AnimatableFrameAttributeVFD
+
+package struct AnimatableFrameAttributeVFD: StatefulRule, AsyncAttribute, ObservedAttribute {
+    @Attribute
+    private var position: ViewOrigin
+
+    @Attribute
+    private var size: ViewSize
+
+    @Attribute
+    private var pixelLength: CGFloat
+
+    @Attribute
+    private var environment: EnvironmentValues
+
+    private var helper: AnimatableAttributeHelper<ViewFrame>
+
+    private var velocityFilter: FrameVelocityFilter
+
+    let animationsDisabled: Bool
+
+    package init(
+        position: Attribute<ViewOrigin>,
+        size: Attribute<ViewSize>,
+        pixelLength: Attribute<CGFloat>,
+        environment: Attribute<EnvironmentValues>,
+        phase: Attribute<_GraphInputs.Phase>,
+        time: Attribute<Time>,
+        transaction: Attribute<Transaction>,
+        animationsDisabled: Bool
+    ) {
+        _position = position
+        _size = size
+        _pixelLength = pixelLength
+        _environment = environment
+        helper = .init(phase: phase, time: time, transaction: transaction)
+        velocityFilter = FrameVelocityFilter()
+        self.animationsDisabled = animationsDisabled
+    }
+
+    package typealias Value = ViewFrame
+
+    package mutating func updateValue() {
+        let (position, positionChanged) = $position.changedValue()
+        let (size, sizeChanged) = $size.changedValue()
+        let (pixelLength, pixelLengthChanged) = $pixelLength.changedValue()
+        let anyChanged = positionChanged || sizeChanged || pixelLengthChanged
+        var rect = CGRect(origin: position, size: size.value)
+        rect.roundCoordinatesToNearestOrUp(toMultipleOf: pixelLength)
+        let viewFrame = ViewFrame(
+            origin: rect.origin,
+            size: ViewSize(value: rect.size, proposal: size._proposal)
+        )
+        var sourceValue = (
+            value: viewFrame,
+            changed: anyChanged
+        )
+        if !animationsDisabled {
+            helper.update(
+                value: &sourceValue,
+                defaultAnimation: nil,
+                environment: $environment
+            )
+        }
+        guard sourceValue.changed || !hasValue else {
+            return
+        }
+        value = sourceValue.value
+    }
+
+    package mutating func destroy() {
+        helper.removeListeners()
+    }
+}
+
+// MARK: - AnimatableAttributeHelper
+
+package struct AnimatableAttributeHelper<Value> where Value: Animatable {
+    @Attribute
+    package var phase: _GraphInputs.Phase
+
+    @Attribute
+    package var time: Time
+
+    @Attribute
+    package var transaction: Transaction
+
+    private var previousModelData: Value.AnimatableData? = nil
+
+    private var animatorState: AnimatorState<Value.AnimatableData>? = nil
+
+    private var resetSeed: UInt32 = 0
+
+    package init(
+        phase: Attribute<_GraphInputs.Phase>,
+        time: Attribute<Time>,
+        transaction: Attribute<Transaction>
+    ) {
+        _phase = phase
+        _time = time
+        _transaction = transaction
+    }
+
+    package var isAnimating: Bool {
+        animatorState != nil
+    }
+
+    @inline(__always)
+    private mutating func updateAnimatorStateIfNeeded(
+        value: (value: Value, changed: Bool),
+        animationTime: inout Time,
+        environment: Attribute<EnvironmentValues>,
+        sampleCollector: (Value.AnimatableData, Time) -> Void
+    ) {
+        guard value.changed else {
+            return
+        }
+        let modelData = value.value.animatableData
+        defer { previousModelData = modelData }
+        guard let previousModelData, modelData != previousModelData else {
+            return
+        }
+        let transaction: Transaction = Graph.withoutUpdate { self.transaction }
+        guard let animation = transaction.effectiveAnimation else {
+            return
+        }
+        var interval = modelData
+        interval -= previousModelData
+        animationTime = time
+
+        let state: AnimatorState<Value.AnimatableData>
+        if let animatorState {
+            state = animatorState
+            animatorState.combine(
+                newAnimation: animation,
+                newInterval: interval,
+                at: animationTime,
+                in: transaction,
+                environment: environment
+            )
+            // TODO: CustomEventTrace
+        } else {
+            state = AnimatorState(
+                animation: animation,
+                interval: interval,
+                at: animationTime,
+                in: transaction
+            )
+            // TODO: CustomEventTrace
+            animatorState = state
+        }
+        state.addListeners(transaction: transaction)
+    }
+
+    @inline(__always)
+    private mutating func updateValueIfNeeded(
+        value: inout (value: Value, changed: Bool),
+        animationTime: Time,
+        environment: Attribute<EnvironmentValues>,
+        sampleCollector: (Value.AnimatableData, Time) -> Void
+    ) {
+        guard let animatorState else {
+            return
+        }
+        var animatableData = value.value.animatableData
+        let isAnimationOver = animatorState.update(
+            &animatableData,
+            at: animationTime,
+            environment: environment
+        )
+        // let attribute = AnyAttribute.current // For tracing
+        if isAnimationOver {
+            // TODO: [Trace] CustomEventTrace + OGGraphAddTraceEvent
+            // TODO: Signpost
+            removeListeners()
+            self.animatorState = nil
+        } else {
+            // TODO: [Trace] CustomEventTrace + OGGraphAddTraceEvent
+            sampleCollector(animatableData, time)
+            animatorState.nextUpdate()
+        }
+        value.value.animatableData = animatableData
+        value.changed = true
+    }
+
+    package mutating func update(
+        value: inout (value: Value, changed: Bool),
+        defaultAnimation: Animation?,
+        environment: Attribute<EnvironmentValues>,
+        sampleCollector: (Value.AnimatableData, Time) -> Void
+    ) {
+        var animationTime = -Time.infinity
+        if let animatorState {
+            let (time, timeChanged) = $time.changedValue()
+            if timeChanged {
+                animationTime = time
+            }
+        }
+        let reseted = checkReset()
+        if reseted {
+            value.changed = true
+        }
+        updateAnimatorStateIfNeeded(
+            value: value,
+            animationTime: &animationTime,
+            environment: environment,
+            sampleCollector: sampleCollector
+        )
+        updateValueIfNeeded(
+            value: &value,
+            animationTime: animationTime,
+            environment: environment,
+            sampleCollector: sampleCollector
+        )
+    }
+
+    package mutating func update(
+        value: inout (value: Value, changed: Bool),
+        defaultAnimation: Animation?,
+        environment: Attribute<EnvironmentValues>
+    ) {
+        update(
+            value: &value,
+            defaultAnimation: defaultAnimation,
+            environment: environment
+        ) { _, _ in
+            _openSwiftUIEmptyStub()
+        }
+    }
+
+    package mutating func checkReset() -> Bool {
+        guard phase.resetSeed != resetSeed else {
+            return false
+        }
+        reset()
+        return true
+    }
+
+    package mutating func reset() {
+        removeListeners()
+        animatorState = nil
+        previousModelData = nil
+        resetSeed = phase.resetSeed
+    }
+
+    package mutating func removeListeners() {
+        animatorState?.removeListeners()
+    }
+}
+
+// MARK: - AnimatorState
+
+final package class AnimatorState<V> where V: VectorArithmetic {
+    private var animation: Animation
+
+    private var state: AnimationState<V> = .init()
+
+    private var interval: V = .zero
+
+    private var beginTime: Time
+
+    private var quantizedFrameInterval: Double
+
+    private var nextTime: Time = .zero
+
+    private var previousAnimationValue: V = .zero
+
+    private var reason: UInt32? = nil
+
+    private enum Phase {
+        case pending
+        case first
+        case second
+        case running
+    }
+
+    private var phase: Phase = .pending
+
+    private var listeners: [AnimationListener] = []
+
+    private var logicalListeners: [AnimationListener] = []
+
+    private var isLogicallyComplete: Bool = false
+
+    private struct Fork {
+        var animation: Animation
+        var state: AnimationState<V>
+        var interval: V
+        var listeners: [AnimationListener]
+
+        func update(time: Double, environment: Attribute<EnvironmentValues>?) -> Bool {
+            var context = AnimationContext(state: state, environment: environment, isLogicallyComplete: false)
+            let animtedValue = animation.animate(value: interval, time: time, context: &context)
+            return animtedValue == nil || context.isLogicallyComplete
+        }
+    }
+
+    private var forks: [Fork] = []
+
+    init(
+        animation: Animation,
+        interval: V,
+        at time: Time,
+        in transaction: Transaction
+    ) {
+        self.animation = animation
+        self.interval = interval
+        self.beginTime = time
+        self.nextTime = time
+        if let animationFrameInterval = transaction.animationFrameInterval {
+            self.quantizedFrameInterval = if animationFrameInterval <= .zero {
+                .zero
+            } else {
+                exp2(floor(log2(animationFrameInterval * 240.0) + 0.01)) / 240.0
+            }
+            if quantizedFrameInterval < 1.0 / 60.0 {
+                self.reason = transaction.animationReason
+            } else {
+                self.reason = nil
+            }
+        } else {
+            self.quantizedFrameInterval = .zero
+            self.reason = nil
+        }
+    }
+
+    package func updateListeners(
+        isLogicallyComplete: Bool,
+        time: TimeInterval,
+        environment: Attribute<EnvironmentValues>?
+    ) {
+        if !self.isLogicallyComplete, isLogicallyComplete {
+            self.isLogicallyComplete = true
+            logicalListeners.forEach { $0.animationWasRemoved() }
+            logicalListeners = []
+        }
+        if !forks.isEmpty {
+            var set = IndexSet()
+            for index in forks.indices {
+                guard forks[index].update(time: time, environment: environment) else {
+                    continue
+                }
+                forks[index].listeners.forEach { $0.animationWasRemoved() }
+                set.insert(index)
+            }
+            forks.remove(atOffsets: set)
+        }
+    }
+
+    package func removeListeners() {
+        listeners.forEach { $0.animationWasRemoved() }
+        listeners = []
+        listeners.forEach { $0.animationWasRemoved() }
+        logicalListeners = []
+    }
+
+    package func forkListeners(
+        animation: Animation,
+        state: AnimationState<V>,
+        interval: V
+    ) {
+        guard !isLogicallyComplete, !logicalListeners.isEmpty else {
+            return
+        }
+        let fork = Fork(
+            animation: animation,
+            state: state,
+            interval: interval,
+            listeners: logicalListeners
+        )
+        forks.append(fork)
+    }
+
+    package func combine(
+        newAnimation: Animation,
+        newInterval: V,
+        at time: Time,
+        in transaction: Transaction,
+        environment: Attribute<EnvironmentValues>?
+    ) {
+        if phase == .pending, !Semantics.MergeCoincidentAnimations.isEnabled {
+            animation = newAnimation
+            interval = newInterval
+        } else {
+            let elapsed = time - beginTime
+            var context = AnimationContext(
+                state: state,
+                environment: environment,
+                isLogicallyComplete: isLogicallyComplete
+            )
+            forkListeners(animation: animation, state: state, interval: interval)
+            isLogicallyComplete = false
+            if newAnimation.shouldMerge(
+                previous: animation,
+                value: interval,
+                time: elapsed,
+                context: &context
+            ) {
+                state = context.state
+                animation = newAnimation
+            } else {
+                combineAnimation(
+                    into: &animation,
+                    state: &state,
+                    value: interval,
+                    elapsed: elapsed,
+                    newAnimation: newAnimation,
+                    newValue: newInterval
+                )
+            }
+            interval += newInterval
+            nextTime = time
+        }
+        if let animationFrameInterval = transaction.animationFrameInterval {
+            let newQuantizedFrameInterval: Double = if animationFrameInterval <= .zero {
+                .zero
+            } else {
+                exp2(floor(log2(animationFrameInterval * 240.0) + 0.01)) / 240.0
+            }
+            quantizedFrameInterval = min(
+                newQuantizedFrameInterval,
+                quantizedFrameInterval
+            )
+            if quantizedFrameInterval < 1.0 / 60.0 {
+                self.reason = transaction.animationReason
+            } else {
+                self.reason = nil
+            }
+        }
+    }
+
+    package func update(
+        _ value: inout V,
+        at time: Time,
+        environment: Attribute<EnvironmentValues>?
+    ) -> Bool {
+        guard time > nextTime + quantizedFrameInterval * -0.5 else {
+            value += previousAnimationValue
+            value -= interval
+            return false
+        }
+        switch phase {
+        case .pending:
+            beginTime = time
+            phase = .first
+        case .first:
+            phase = .second
+            guard CoreGlue.shared.hasTestHost() else {
+                nextTime += time - beginTime
+                beginTime = time
+                value += previousAnimationValue
+                value -= interval
+                return false
+            }
+        case .second:
+            let doubleInterval = max(quantizedFrameInterval, 1.0 / 60.0) + quantizedFrameInterval
+            if doubleInterval < time - beginTime {
+                if !CoreGlue.shared.hasTestHost() {
+                    beginTime = time - doubleInterval
+                }
+            }
+            phase = .running
+        case .running:
+            break
+        }
+        let elapsed = time - beginTime
+        var context = AnimationContext(
+            state: state,
+            environment: environment,
+            isLogicallyComplete: isLogicallyComplete
+        )
+        guard let newValue = animation.animate(
+            value: interval,
+            time: elapsed,
+            context: &context
+        ) else {
+            return true
+        }
+        updateListeners(
+            isLogicallyComplete: context.isLogicallyComplete,
+            time: elapsed,
+            environment: environment
+        )
+        value += newValue
+        value -= interval
+        previousAnimationValue = newValue
+        nextTime = time
+        if quantizedFrameInterval > .zero {
+            nextTime = Time(seconds: (floor(time.seconds / quantizedFrameInterval) + 1.0) * quantizedFrameInterval)
+        }
+        return false
+    }
+
+    package func nextUpdate() {
+        CoreGlue.shared.nextUpdate(
+            nextTime: nextTime,
+            interval: quantizedFrameInterval,
+            reason: reason
+        )
+    }
+
+    package func addListeners(transaction: Transaction) {
+        if let listener = transaction.animationListener {
+            listeners.append(listener)
+            listener.animationWasAdded()
+        }
+        if let logicalListener = transaction.animationLogicalListener {
+            logicalListener.animationWasAdded()
+            if isLogicallyComplete {
+                logicalListener.animationWasRemoved()
+            } else {
+                logicalListeners.append(logicalListener)
+            }
+        }
+    }
+}
+
+// MARK: - FrameVelocityFilter
+
+private struct FrameVelocityFilter {
+    var currentVelocity: Double?
+    var previous: ((Time, CGRect.AnimatableData))?
+
+    mutating func addSample(_ rect: CGRect.AnimatableData, time: Time) {
+        guard let (previousTime, previousRect) = previous,
+              previousTime <= time else {
+            previous = (time, rect)
+            return
+        }
+        let deltaX = rect.first.first - previousRect.first.first
+        let deltaY = rect.first.second - previousRect.first.second
+        let deltaWidth = rect.second.first - previousRect.second.first
+        let deltaHeight = rect.second.second - previousRect.second.second
+
+        let timeFactor = 1.0 / (time - previousTime)
+
+        let velocityX = timeFactor * deltaX
+        let velocityY = timeFactor * deltaY
+        let velocityWidth = timeFactor * deltaWidth
+        let velocityHeight = timeFactor * deltaHeight
+
+        let velocityRect = CGRect(x: velocityX, y: velocityY, width: velocityWidth, height: velocityHeight)
+        let newVelocity = max(abs(velocityRect.minX), abs(velocityRect.maxX), abs(velocityRect.minY), abs(velocityRect.maxY))
+        if let existingVelocity = currentVelocity {
+            currentVelocity = mix(existingVelocity, newVelocity, by: 0.35)
+        } else {
+            currentVelocity = newVelocity
+        }
+        previous = (time, rect)
+    }
+}
+
+// FIXME
+func combineAnimation<A>(
+    into: inout Animation,
+    state: inout AnimationState<A>,
+    value: A,
+    elapsed: Double,
+    newAnimation: Animation,
+    newValue: A
+) -> () where A: VectorArithmetic {
+    _openSwiftUIUnimplementedFailure()
+}
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/AnimatablePair.swift b/Sources/OpenSwiftUICore/Animation/Animatable/AnimatablePair.swift
similarity index 98%
rename from Sources/OpenSwiftUICore/View/Animation/Animation/AnimatablePair.swift
rename to Sources/OpenSwiftUICore/Animation/Animatable/AnimatablePair.swift
index 4a3deb4e8..0c11848d4 100644
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/AnimatablePair.swift
+++ b/Sources/OpenSwiftUICore/Animation/Animatable/AnimatablePair.swift
@@ -2,7 +2,7 @@
 //  AnimatablePair.swift
 //  OpenSwiftUICore
 //
-//  Audited for iOS 18.0
+//  Audited for 6.0.87
 //  Status: Complete
 
 /// A pair of animatable values, which is itself animatable.
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/AnyAnimatableData.swift b/Sources/OpenSwiftUICore/Animation/Animatable/AnyAnimatableData.swift
similarity index 99%
rename from Sources/OpenSwiftUICore/View/Animation/Animation/AnyAnimatableData.swift
rename to Sources/OpenSwiftUICore/Animation/Animatable/AnyAnimatableData.swift
index 79eba7216..6270b3e60 100644
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/AnyAnimatableData.swift
+++ b/Sources/OpenSwiftUICore/Animation/Animatable/AnyAnimatableData.swift
@@ -2,7 +2,7 @@
 //  AnyAnimatableData.swift
 //  OpenSwiftUICore
 //
-//  Audited for iOS 18.0
+//  Audited for 6.0.87
 //  Status: Complete
 //  ID: 7ABB4C511D8E2C0F1768F58E8C14509E (SwiftUICore)
 
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/VectorArithmetic.swift b/Sources/OpenSwiftUICore/Animation/Animatable/VectorArithmetic.swift
similarity index 99%
rename from Sources/OpenSwiftUICore/View/Animation/Animation/VectorArithmetic.swift
rename to Sources/OpenSwiftUICore/Animation/Animatable/VectorArithmetic.swift
index 71cfb78bc..b965a1f5e 100644
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/VectorArithmetic.swift
+++ b/Sources/OpenSwiftUICore/Animation/Animatable/VectorArithmetic.swift
@@ -2,7 +2,7 @@
 //  VectorArithmetic.swift
 //  OpenSwiftUICore
 //
-//  Audited for iOS 18.0
+//  Audited for 6.0.87
 //  Status: Complete
 
 public import Foundation
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/VectorMath.swift b/Sources/OpenSwiftUICore/Animation/Animatable/VectorMath.swift
similarity index 97%
rename from Sources/OpenSwiftUICore/View/Animation/Animation/VectorMath.swift
rename to Sources/OpenSwiftUICore/Animation/Animatable/VectorMath.swift
index 5266dd2ea..68c549c88 100644
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/VectorMath.swift
+++ b/Sources/OpenSwiftUICore/Animation/Animatable/VectorMath.swift
@@ -2,9 +2,10 @@
 //  VectorMath.swift
 //  OpenSwiftUICore
 //
+//  Audited for 6.4.41
 //  Status: Complete
 
-// MARK: - VectorMath [6.4.41]
+// MARK: - VectorMath
 
 /// Adds the "vector space" numeric operations for any type that
 /// conforms to Animatable.
diff --git a/Sources/OpenSwiftUICore/Animation/Animatable/View+Animatable.swift b/Sources/OpenSwiftUICore/Animation/Animatable/View+Animatable.swift
new file mode 100644
index 000000000..a4164bcc6
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Animation/Animatable/View+Animatable.swift
@@ -0,0 +1,24 @@
+//
+//  View+Animatable.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+extension View where Self: Animatable {
+    nonisolated public static func _makeView(
+        view: _GraphValue<Self>,
+        inputs: _ViewInputs
+    ) -> _ViewOutputs {
+        let animatableView = makeAnimatable(value: view, inputs: inputs.base)
+        return makeView(view: _GraphValue(animatableView), inputs: inputs)
+    }
+
+    nonisolated public static func _makeViewList(
+        view: _GraphValue<Self>,
+        inputs: _ViewListInputs
+    ) -> _ViewListOutputs {
+        let animatableView = makeAnimatable(value: view, inputs: inputs.base)
+        return makeViewList(view: _GraphValue(animatableView), inputs: inputs)
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Animation/Animatable/ViewModifier+Animatable.swift b/Sources/OpenSwiftUICore/Animation/Animatable/ViewModifier+Animatable.swift
new file mode 100644
index 000000000..b9a7201ab
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Animation/Animatable/ViewModifier+Animatable.swift
@@ -0,0 +1,40 @@
+//
+//  ViewModifier+Animatable.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+extension ViewModifier where Self: Animatable {
+    nonisolated public static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        let animatableViewModifier = makeAnimatable(
+            value: modifier,
+            inputs: inputs.base
+        )
+        return makeView(
+            modifier: _GraphValue(animatableViewModifier),
+            inputs: inputs,
+            body: body
+        )
+    }
+
+    nonisolated public static func _makeViewList(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewListInputs,
+        body: @escaping (_Graph, _ViewListInputs) -> _ViewListOutputs
+    ) -> _ViewListOutputs {
+        let animatableViewModifier = makeAnimatable(
+            value: modifier,
+            inputs: inputs.base
+        )
+        return makeViewList(
+            modifier: _GraphValue(animatableViewModifier),
+            inputs: inputs,
+            body: body
+        )
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Animation/Animation/Animation.swift b/Sources/OpenSwiftUICore/Animation/Animation/Animation.swift
new file mode 100644
index 000000000..40c82f32b
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Animation/Animation/Animation.swift
@@ -0,0 +1,29 @@
+public import Foundation
+
+@frozen
+public struct Animation: Equatable {
+//    var box: AnimationBoxBase
+    public static func == (lhs: Animation, rhs: Animation) -> Bool {
+        // TODO
+        true
+    }
+
+    public static var `default` = Animation()
+
+    func animate<V>(
+        value: V,
+        time: Double,
+        context: inout AnimationContext<V>
+    ) -> V? where V: VectorArithmetic {
+        _openSwiftUIUnimplementedFailure()
+    }
+
+    public func shouldMerge<V>(
+        previous: Animation,
+        value: V,
+        time: TimeInterval,
+        context: inout AnimationContext<V>
+    ) -> Bool where V: VectorArithmetic {
+        _openSwiftUIUnimplementedFailure()
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Animation/Animation/AnimationContext.swift b/Sources/OpenSwiftUICore/Animation/Animation/AnimationContext.swift
new file mode 100644
index 000000000..8030b7d6d
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Animation/Animation/AnimationContext.swift
@@ -0,0 +1,252 @@
+//
+//  AnimationContext.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+package import OpenGraphShims
+
+/// Contextual values that a custom animation can use to manage state and
+/// access a view's environment.
+///
+/// The system provides an `AnimationContext` to a ``CustomAnimation`` instance
+/// so that the animation can store and retrieve values in an instance of
+/// ``AnimationState``. To access these values, use the context's
+/// ``AnimationContext/state`` property.
+///
+/// For more convenient access to state, create an ``AnimationStateKey`` and
+/// extend `AnimationContext` to include a computed property that gets and
+/// sets the ``AnimationState`` value. Then use this property instead of
+/// ``AnimationContext/state`` to retrieve the state of a custom animation. For
+/// example, the following code creates an animation state key named
+/// `PausableState`. Then the code extends `AnimationContext` to include the
+/// `pausableState` property:
+///
+///     private struct PausableState<Value: VectorArithmetic>: AnimationStateKey {
+///         var paused = false
+///         var pauseTime: TimeInterval = 0.0
+///
+///         static var defaultValue: Self { .init() }
+///     }
+///
+///     extension AnimationContext {
+///         fileprivate var pausableState: PausableState<Value> {
+///             get { state[PausableState<Value>.self] }
+///             set { state[PausableState<Value>.self] = newValue }
+///         }
+///     }
+///
+/// To access the pausable state, the custom animation `PausableAnimation` uses
+/// the `pausableState` property instead of the ``AnimationContext/state``
+/// property:
+///
+///     struct PausableAnimation: CustomAnimation {
+///         let base: Animation
+///
+///         func animate<V>(value: V, time: TimeInterval, context: inout AnimationContext<V>) -> V? where V : VectorArithmetic {
+///             let paused = context.environment.animationPaused
+///
+///             let pausableState = context.pausableState
+///             var pauseTime = pausableState.pauseTime
+///             if pausableState.paused != paused {
+///                 pauseTime = time - pauseTime
+///                 context.pausableState = PausableState(paused: paused, pauseTime: pauseTime)
+///             }
+///
+///             let effectiveTime = paused ? pauseTime : time - pauseTime
+///             let result = base.animate(value: value, time: effectiveTime, context: &context)
+///             return result
+///         }
+///     }
+///
+/// The animation can also retrieve environment values of the view that created
+/// the animation. To retrieve a view's environment value, use the context's
+/// ``AnimationContext/environment`` property. For instance, the following code
+/// creates a custom ``EnvironmentValues`` property named `animationPaused`, and the
+/// view `PausableAnimationView` uses the property to store the paused state:
+///
+///     extension EnvironmentValues {
+///         @Entry var animationPaused: Bool = false
+///     }
+///
+///     struct PausableAnimationView: View {
+///         @State private var paused = false
+///
+///         var body: some View {
+///             VStack {
+///                 ...
+///             }
+///             .environment(\.animationPaused, paused)
+///         }
+///     }
+///
+/// Then the custom animation `PausableAnimation` retrieves the paused state
+/// from the view's environment using the ``AnimationContext/environment``
+/// property:
+///
+///     struct PausableAnimation: CustomAnimation {
+///         func animate<V>(value: V, time: TimeInterval, context: inout AnimationContext<V>) -> V? where V : VectorArithmetic {
+///             let paused = context.environment.animationPaused
+///             ...
+///         }
+///     }
+@available(OpenSwiftUI_v5_0, *)
+public struct AnimationContext<Value> where Value: VectorArithmetic {
+    /// The current state of a custom animation.
+    ///
+    /// An instance of ``CustomAnimation`` uses this property to read and
+    /// write state values as the animation runs.
+    ///
+    /// An alternative to using the `state` property in a custom animation is
+    /// to create an ``AnimationStateKey`` type and extend ``AnimationContext``
+    /// with a custom property that returns the state as a custom type. For
+    /// example, the following code creates a state key named `PausableState`.
+    /// It's convenient to store state values in the key type, so the
+    /// `PausableState` structure includes properties for the stored state
+    /// values `paused` and `pauseTime`.
+    ///
+    ///     private struct PausableState<Value: VectorArithmetic>: AnimationStateKey {
+    ///         var paused = false
+    ///         var pauseTime: TimeInterval = 0.0
+    ///
+    ///         static var defaultValue: Self { .init() }
+    ///     }
+    ///
+    /// To provide access the pausable state, the following code extends
+    /// `AnimationContext` to include the `pausableState` property. This
+    /// property returns an instance of the custom `PausableState` structure
+    /// stored in ``AnimationContext/state``, and it can also store a new
+    /// `PausableState` instance in `state`.
+    ///
+    ///     extension AnimationContext {
+    ///         fileprivate var pausableState: PausableState<Value> {
+    ///             get { state[PausableState<Value>.self] }
+    ///             set { state[PausableState<Value>.self] = newValue }
+    ///         }
+    ///     }
+    ///
+    /// Now a custom animation can use the `pausableState` property instead of
+    /// the ``AnimationContext/state`` property as a convenient way to read and
+    /// write state values as the animation runs.
+    ///
+    ///     struct PausableAnimation: CustomAnimation {
+    ///         func animate<V>(value: V, time: TimeInterval, context: inout AnimationContext<V>) -> V? where V : VectorArithmetic {
+    ///             let pausableState = context.pausableState
+    ///             var pauseTime = pausableState.pauseTime
+    ///             ...
+    ///         }
+    ///     }
+    ///
+    public var state: AnimationState<Value>
+
+    private var _environment: WeakAttribute<EnvironmentValues>?
+
+    /// Set this to `true` to indicate that an animation is logically complete.
+    ///
+    /// This controls when AnimationCompletionCriteria.logicallyComplete
+    /// completion callbacks are fired. This should be set to `true` at most
+    /// once in the life of an animation, changing back to `false` later will be
+    /// ignored. If this is never set to `true`, the behavior is equivalent to
+    /// if this had been set to `true` just as the animation finished (by
+    /// returning `nil`).
+    public var isLogicallyComplete: Bool
+
+    /// The current environment of the view that created the custom animation.
+    ///
+    /// An instance of ``CustomAnimation`` uses this property to read
+    /// environment values from the view that created the animation. To learn
+    /// more about environment values including how to define custom
+    /// environment values, see ``EnvironmentValues``.
+    public var environment: EnvironmentValues {
+        _environment?.value ?? EnvironmentValues()
+    }
+
+    package init(
+        state: AnimationState<Value>,
+        environment: WeakAttribute<EnvironmentValues>?,
+        isLogicallyComplete: Bool
+    ) {
+        self.state = state
+        self._environment = environment
+        self.isLogicallyComplete = isLogicallyComplete
+    }
+
+    package init(
+        state: AnimationState<Value>,
+        environment: WeakAttribute<EnvironmentValues>?
+    ) {
+        self.state = state
+        self._environment = environment
+        self.isLogicallyComplete = false
+    }
+
+    package init(
+        environment: WeakAttribute<EnvironmentValues>?,
+        isLogicallyComplete: Bool
+    ) {
+        self.state = .init()
+        self._environment = environment
+        self.isLogicallyComplete = isLogicallyComplete
+    }
+
+    package init(environment: WeakAttribute<EnvironmentValues>?) {
+        self.state = .init()
+        self._environment = environment
+        self.isLogicallyComplete = false
+    }
+
+    package init(
+        state: AnimationState<Value> = .init(),
+        environment: Attribute<EnvironmentValues>?,
+        isLogicallyComplete: Bool = false
+    ) {
+        self.state = state
+        self._environment = WeakAttribute(environment)
+        self.isLogicallyComplete = isLogicallyComplete
+    }
+
+    package init(
+        state: AnimationState<Value>,
+        environment: Attribute<EnvironmentValues>?
+    ) {
+        self.state = state
+        self._environment = WeakAttribute(environment)
+        self.isLogicallyComplete = false
+    }
+
+    package init(
+        environment: Attribute<EnvironmentValues>?,
+        isLogicallyComplete: Bool
+    ) {
+        self.state = .init()
+        self._environment = WeakAttribute(environment)
+        self.isLogicallyComplete = isLogicallyComplete
+    }
+
+    package init(environment: Attribute<EnvironmentValues>?) {
+        self.state = .init()
+        self._environment = WeakAttribute(environment)
+        self.isLogicallyComplete = false
+    }
+
+    /// Creates a new context from another one with a state that you provide.
+    ///
+    /// Use this method to create a new context that contains the state that
+    /// you provide and view environment values from the original context.
+    ///
+    /// - Parameter state: The initial state for the new context.
+    /// - Returns: A new context that contains the specified state.
+    public func withState<T>(
+        _ state: AnimationState<T>
+    ) -> AnimationContext<T> where T: VectorArithmetic {
+        AnimationContext<T>(
+            state: state,
+            environment: _environment,
+            isLogicallyComplete: isLogicallyComplete
+        )
+    }
+}
+
+@available(*, unavailable)
+extension AnimationContext: Sendable {}
diff --git a/Sources/OpenSwiftUICore/Animation/Animation/AnimationListener.swift b/Sources/OpenSwiftUICore/Animation/Animation/AnimationListener.swift
new file mode 100644
index 000000000..3846e28ff
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Animation/Animation/AnimationListener.swift
@@ -0,0 +1,227 @@
+//
+//  AnimationListener.swift
+//  OpenSwiftUICore
+//
+//  Audited: 6.5.4
+//  Status: Complete
+//  ID: 390609F81ACEBEAF00AD8179BD31E870 (SwiftUICore)
+
+import Dispatch
+
+// MARK: - AnimationListener
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+open class AnimationListener: @unchecked Sendable {
+    public init() {
+        _openSwiftUIEmptyStub()
+    }
+
+    open func animationWasAdded() {
+        _openSwiftUIEmptyStub()
+    }
+
+    open func animationWasRemoved() {
+        _openSwiftUIEmptyStub()
+    }
+
+    open func finalizeTransaction() {
+        _openSwiftUIEmptyStub()
+    }
+}
+
+// MARK: - ListenerPair
+
+private final class ListenerPair: AnimationListener, @unchecked Sendable {
+    let first: AnimationListener
+    let second: AnimationListener
+
+    init(first: AnimationListener, second: AnimationListener) {
+        self.first = first
+        self.second = second
+        super.init()
+    }
+
+    override func animationWasAdded() {
+        first.animationWasAdded()
+        second.animationWasAdded()
+    }
+
+    override func animationWasRemoved() {
+        first.animationWasAdded()
+        second.animationWasRemoved()
+    }
+}
+
+// MARK: - AllFinishedListener
+
+private final class AllFinishedListener: AnimationListener, @unchecked Sendable {
+    let allFinished: (Transaction.AnimationCompletionInfo) -> Void
+    var count: Int
+    var maxCount: Int
+    var dispatched: Bool
+
+    init(allFinished: @escaping (Transaction.AnimationCompletionInfo) -> Void) {
+        self.allFinished = allFinished
+        self.count = 0
+        self.maxCount = 0
+        self.dispatched = false
+        super.init()
+    }
+
+    override func animationWasAdded() {
+        count += 1
+        maxCount += 1
+    }
+
+    override func animationWasRemoved() {
+        count -= 1
+        dispatchIfNeeded()
+    }
+
+    override func finalizeTransaction() {
+        dispatchIfNeeded()
+    }
+
+    @inline(__always)
+    func dispatchIfNeeded() {
+        guard count == 0, !dispatched else {
+            return
+        }
+        dispatched = true
+        allFinished(.init(completedCount: maxCount))
+    }
+
+    deinit {
+        dispatchIfNeeded()
+    }
+}
+
+// MARK: - Transaction + AnimationListener
+
+extension Transaction {
+    private static var pendingListeners = AtomicBox(wrappedValue: PendingListeners())
+
+    private struct PendingListeners {
+        var pending: [WeakListener] = []
+        var next: DispatchTime?
+
+        struct WeakListener {
+            weak var listener: AnimationListener?
+            var time: DispatchTime
+        }
+    }
+
+    private static func addPendingListener(_ listener: AnimationListener) {
+        pendingListeners.access { pendingListeners in
+            let time = DispatchTime.now() + 0.01
+            pendingListeners.pending.append(.init(listener: listener, time: time))
+            if pendingListeners.next == nil {
+                pendingListeners.next = time
+                DispatchQueue.main.asyncAfter(deadline: time) {
+                    dispatchPending()
+                }
+            }
+        }
+    }
+
+    private static func dispatchPending() {
+        let pendingListeners = pendingListeners.access { pendingListeners in
+            guard let next = pendingListeners.next else {
+                let pending = pendingListeners.pending
+                pendingListeners.pending = []
+                return pending
+            }
+            pendingListeners.next = nil
+            let pending = pendingListeners.pending
+            let filtered = pending.filter { $0.time > next }
+            pendingListeners.pending = filtered
+            guard !filtered.isEmpty else {
+                return pending
+            }
+            DispatchQueue.main.asyncAfter(deadline: next) {
+                dispatchPending()
+            }
+            return pending.filter { $0.time <= next }
+        }
+        guard !pendingListeners.isEmpty else {
+            return
+        }
+        Update.ensure {
+            for pendingListener in pendingListeners {
+                guard let listener = pendingListener.listener else {
+                    continue
+                }
+                listener.finalizeTransaction()
+            }
+        }
+    }
+
+    private struct AnimationListenerKey: TransactionKey {
+        static var defaultValue: AnimationListener? { nil }
+    }
+
+    package var animationListener: AnimationListener? {
+        self[AnimationListenerKey.self]
+    }
+
+    package mutating func addAnimationListener(_ listener: AnimationListener) {
+        Self.addPendingListener(listener)
+        if let existing = self[AnimationListenerKey.self] {
+            self[AnimationListenerKey.self] = ListenerPair(first: existing, second: listener)
+        } else {
+            self[AnimationListenerKey.self] = listener
+        }
+    }
+
+    package mutating func addAnimationListener(allFinished: @escaping () -> Void) {
+        addAnimationListener(AllFinishedListener(allFinished: { _ in allFinished() }))
+    }
+
+    package mutating func addAnimationListener(allFinished: @escaping (Transaction.AnimationCompletionInfo) -> Void) {
+        addAnimationListener(AllFinishedListener(allFinished: allFinished))
+    }
+
+    private struct AnimationLogicalListenerKey: TransactionKey {
+        static var defaultValue: AnimationListener? { nil }
+    }
+
+    package var animationLogicalListener: AnimationListener? {
+        self[AnimationLogicalListenerKey.self]
+    }
+
+    package mutating func addAnimationLogicalListener(_ listener: AnimationListener) {
+        Self.addPendingListener(listener)
+        if let existing = self[AnimationLogicalListenerKey.self] {
+            self[AnimationLogicalListenerKey.self] = ListenerPair(first: existing, second: listener)
+        } else {
+            self[AnimationLogicalListenerKey.self] = listener
+        }
+    }
+
+    package mutating func addAnimationLogicalListener(allFinished: @escaping () -> Void) {
+        addAnimationListener(AllFinishedListener(allFinished: { _ in allFinished() }))
+    }
+
+    package mutating func addAnimationLogicalListener(allFinished: @escaping (Transaction.AnimationCompletionInfo) -> Void) {
+        addAnimationListener(AllFinishedListener(allFinished: allFinished))
+    }
+
+    package struct AnimationCompletionInfo {
+        package var completedCount: Int
+
+        package init(completedCount: Int) {
+            self.completedCount = completedCount
+        }
+    }
+
+    package var combinedAnimationListener: AnimationListener? {
+        let animationListener = animationListener
+        let animationLogicalListener = animationLogicalListener
+        if let animationListener, let animationLogicalListener {
+            return ListenerPair(first: animationListener, second: animationLogicalListener)
+        } else {
+            return animationListener ?? animationLogicalListener
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Animation/Animation/AnimationState.swift b/Sources/OpenSwiftUICore/Animation/Animation/AnimationState.swift
new file mode 100644
index 000000000..3d2825266
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Animation/Animation/AnimationState.swift
@@ -0,0 +1,276 @@
+//
+//  AnimationState.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+/// A container that stores the state for a custom animation.
+///
+/// An ``AnimationContext`` uses this type to store state for a
+/// ``CustomAnimation``. To retrieve the stored state of a context, you can
+/// use the ``AnimationContext/state`` property. However, a more convenient
+/// way to access the animation state is to define an ``AnimationStateKey``
+/// and extend ``AnimationContext`` with a computed property that gets
+/// and sets the animation state, as shown in the following code:
+///
+///     private struct PausableState<Value: VectorArithmetic>: AnimationStateKey {
+///         static var defaultValue: Self { .init() }
+///     }
+///
+///     extension AnimationContext {
+///         fileprivate var pausableState: PausableState<Value> {
+///             get { state[PausableState<Value>.self] }
+///             set { state[PausableState<Value>.self] = newValue }
+///         }
+///     }
+///
+/// When creating an ``AnimationStateKey``, it's convenient to define the
+/// state values that your custom animation needs. For example, the following
+/// code adds the properties `paused` and `pauseTime` to the `PausableState`
+/// animation state key:
+///
+///     private struct PausableState<Value: VectorArithmetic>: AnimationStateKey {
+///         var paused = false
+///         var pauseTime: TimeInterval = 0.0
+///
+///         static var defaultValue: Self { .init() }
+///     }
+///
+/// To access the pausable state in a `PausableAnimation`, the follow code
+/// calls `pausableState` instead of using the context's
+/// ``AnimationContext/state`` property. And because the animation state key
+/// `PausableState` defines properties for state values, the custom animation
+/// can read and write those values.
+///
+///     struct PausableAnimation: CustomAnimation {
+///         let base: Animation
+///
+///         func animate<V>(value: V, time: TimeInterval, context: inout AnimationContext<V>) -> V? where V : VectorArithmetic {
+///             let paused = context.environment.animationPaused
+///
+///             let pausableState = context.pausableState
+///             var pauseTime = pausableState.pauseTime
+///             if pausableState.paused != paused {
+///                 pauseTime = time - pauseTime
+///                 context.pausableState = PausableState(paused: paused, pauseTime: pauseTime)
+///             }
+///
+///             let effectiveTime = paused ? pauseTime : time - pauseTime
+///             let result = base.animate(value: value, time: effectiveTime, context: &context)
+///             return result
+///         }
+///     }
+///
+/// ### Storing state for secondary animations
+///
+/// A custom animation can also use `AnimationState` to store the state of a
+/// secondary animation. For example, the following code creates an
+/// ``AnimationStateKey`` that includes the property `secondaryState`, which a
+/// custom animation can use to store other state:
+///
+///     private struct TargetState<Value: VectorArithmetic>: AnimationStateKey {
+///         var timeDelta = 0.0
+///         var valueDelta = Value.zero
+///         var secondaryState: AnimationState<Value>? = .init()
+///
+///         static var defaultValue: Self { .init() }
+///     }
+///
+///     extension AnimationContext {
+///         fileprivate var targetState: TargetState<Value> {
+///             get { state[TargetState<Value>.self] }
+///             set { state[TargetState<Value>.self] = newValue }
+///         }
+///     }
+///
+/// The custom animation `TargetAnimation` uses `TargetState` to store state
+/// data in `secondaryState` for another animation that runs as part of the
+/// target animation.
+///
+///     struct TargetAnimation: CustomAnimation {
+///         var base: Animation
+///         var secondary: Animation
+///
+///         func animate<V: VectorArithmetic>(value: V, time: Double, context: inout AnimationContext<V>) -> V? {
+///             var targetValue = value
+///             if let secondaryState = context.targetState.secondaryState {
+///                 var secondaryContext = context
+///                 secondaryContext.state = secondaryState
+///                 let secondaryValue = value - context.targetState.valueDelta
+///                 let result = secondary.animate(
+///                     value: secondaryValue, time: time - context.targetState.timeDelta,
+///                     context: &secondaryContext)
+///                 if let result = result {
+///                     context.targetState.secondaryState = secondaryContext.state
+///                     targetValue = result + context.targetState.valueDelta
+///                 } else {
+///                     context.targetState.secondaryState = nil
+///                 }
+///             }
+///             let result = base.animate(value: targetValue, time: time, context: &context)
+///             if let result = result {
+///                 targetValue = result
+///             } else if context.targetState.secondaryState == nil {
+///                 return nil
+///             }
+///             return targetValue
+///     }
+///
+///         func shouldMerge<V: VectorArithmetic>(previous: Animation, value: V, time: Double, context: inout AnimationContext<V>) -> Bool {
+///             guard let previous = previous.base as? Self else { return false }
+///             var secondaryContext = context
+///             if let secondaryState = context.targetState.secondaryState {
+///                 secondaryContext.state = secondaryState
+///                 context.targetState.valueDelta = secondary.animate(
+///                     value: value, time: time - context.targetState.timeDelta,
+///                     context: &secondaryContext) ?? value
+///             } else {
+///                 context.targetState.valueDelta = value
+///             }
+///             // Reset the target each time a merge occurs.
+///             context.targetState.secondaryState = .init()
+///             context.targetState.timeDelta = time
+///             return base.shouldMerge(
+///                 previous: previous.base, value: value, time: time,
+///                 context: &context)
+///         }
+///     }
+@available(OpenSwiftUI_v5_0, *)
+public struct AnimationState<Value> where Value: VectorArithmetic {
+    var storage: [ObjectIdentifier: Any]
+
+    /// Create an empty state container.
+    ///
+    /// You don't typically create an instance of ``AnimationState`` directly.
+    /// Instead, the ``AnimationContext`` provides the animation state to an
+    /// instance of ``CustomAnimation``.
+    public init() {
+        self.storage = [:]
+    }
+
+    /// Accesses the state for a custom key.
+    ///
+    /// Create a custom animation state value by defining a key that conforms
+    /// to the ``AnimationStateKey`` protocol and provide the
+    /// ``AnimationStateKey/defaultValue`` for the key. Also include properties
+    /// to read and write state values that your ``CustomAnimation`` uses. For
+    /// example, the following code defines a key named `PausableState` that
+    /// has two state values, `paused` and `pauseTime`:
+    ///
+    ///     private struct PausableState<Value: VectorArithmetic>: AnimationStateKey {
+    ///         var paused = false
+    ///         var pauseTime: TimeInterval = 0.0
+    ///
+    ///         static var defaultValue: Self { .init() }
+    ///     }
+    ///
+    /// Use that key with the subscript operator of the ``AnimationState``
+    /// structure to get and set a value for the key. For more convenient
+    /// access to the key value, extend ``AnimationContext`` with a computed
+    /// property that gets and sets the key's value.
+    ///
+    ///     extension AnimationContext {
+    ///         fileprivate var pausableState: PausableState<Value> {
+    ///             get { state[PausableState<Value>.self] }
+    ///             set { state[PausableState<Value>.self] = newValue }
+    ///         }
+    ///     }
+    ///
+    /// To access the state values in a ``CustomAnimation``, call the custom
+    /// computed property, then read and write the state values that the
+    /// custom ``AnimationStateKey`` provides.
+    ///
+    ///     struct PausableAnimation: CustomAnimation {
+    ///         let base: Animation
+    ///
+    ///         func animate<V>(value: V, time: TimeInterval, context: inout AnimationContext<V>) -> V? where V : VectorArithmetic {
+    ///             let paused = context.environment.animationPaused
+    ///
+    ///             let pausableState = context.pausableState
+    ///             var pauseTime = pausableState.pauseTime
+    ///             if pausableState.paused != paused {
+    ///                 pauseTime = time - pauseTime
+    ///                 context.pausableState = PausableState(paused: paused, pauseTime: pauseTime)
+    ///             }
+    ///
+    ///             let effectiveTime = paused ? pauseTime : time - pauseTime
+    ///             let result = base.animate(value: value, time: effectiveTime, context: &context)
+    ///             return result
+    ///         }
+    ///     }
+    public subscript<K>(key: K.Type) -> K.Value where K: AnimationStateKey {
+        get {
+            if let value = storage[ObjectIdentifier(key)] {
+                return value as! K.Value
+            } else {
+                return key.defaultValue
+            }
+        }
+        set {
+            storage[ObjectIdentifier(key)] = newValue
+        }
+    }
+}
+
+@available(*, unavailable)
+extension AnimationState: Sendable {}
+
+/// A key for accessing animation state values.
+///
+/// To access animation state from an ``AnimationContext`` in a custom
+/// animation, create an `AnimationStateKey`. For example, the following
+/// code creates an animation state key named `PausableState` and sets the
+/// value for the required ``defaultValue`` property. The code also defines
+/// properties for state values that the custom animation needs when
+/// calculating animation values. Keeping the state values in the animation
+/// state key makes it more convenient to read and write those values in the
+/// implementation of a ``CustomAnimation``.
+///
+///     private struct PausableState<Value: VectorArithmetic>: AnimationStateKey {
+///         var paused = false
+///         var pauseTime: TimeInterval = 0.0
+///
+///         static var defaultValue: Self { .init() }
+///     }
+///
+/// To make accessing the value of the animation state key more convenient,
+/// define a property for it by extending ``AnimationContext``:
+///
+///     extension AnimationContext {
+///         fileprivate var pausableState: PausableState<Value> {
+///             get { state[PausableState<Value>.self] }
+///             set { state[PausableState<Value>.self] = newValue }
+///         }
+///     }
+///
+/// Then, you can read and write your state in an instance of `CustomAnimation`
+/// using the ``AnimationContext``:
+///
+///     struct PausableAnimation: CustomAnimation {
+///         let base: Animation
+///
+///         func animate<V>(value: V, time: TimeInterval, context: inout AnimationContext<V>) -> V? where V : VectorArithmetic {
+///             let paused = context.environment.animationPaused
+///
+///             let pausableState = context.pausableState
+///             var pauseTime = pausableState.pauseTime
+///             if pausableState.paused != paused {
+///                 pauseTime = time - pauseTime
+///                 context.pausableState = PausableState(paused: paused, pauseTime: pauseTime)
+///             }
+///
+///             let effectiveTime = paused ? pauseTime : time - pauseTime
+///             let result = base.animate(value: value, time: effectiveTime, context: &context)
+///             return result
+///         }
+///     }
+@available(OpenSwiftUI_v5_0, *)
+public protocol AnimationStateKey {
+    /// The associated type representing the type of the animation state key's
+    /// value.
+    associatedtype Value
+
+    /// The default value for the animation state key.
+    static var defaultValue: Self.Value { get }
+}
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/TransactionAnimation.swift b/Sources/OpenSwiftUICore/Animation/Animation/TransactionAnimation.swift
similarity index 89%
rename from Sources/OpenSwiftUICore/View/Animation/Animation/TransactionAnimation.swift
rename to Sources/OpenSwiftUICore/Animation/Animation/TransactionAnimation.swift
index acedaf4b8..674d6ea4f 100644
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/TransactionAnimation.swift
+++ b/Sources/OpenSwiftUICore/Animation/Animation/TransactionAnimation.swift
@@ -2,7 +2,7 @@
 //  TransactionAnimation.swift
 //  OpenSwiftUICore
 //
-//  Audited for iOS 18.0
+//  Audited for iOS 6.0.87
 //  Status: Complete
 //  ID: 39EC6D46662E6D7A6963F5C611934B0A (SwiftUI)
 //  ID: D98E9A1069CEEADA58829ED440E36F30 (SwiftUICore)
@@ -32,13 +32,23 @@ extension Transaction {
         set { self[AnimationFrameIntervalKey.self] = newValue }
     }
 
+    package var animationFrameInterval: Double? {
+        get { _animationFrameInterval }
+        set { _animationFrameInterval = newValue }
+    }
+
     package var _animationReason: UInt32? {
         get { self[AnimationReasonKey.self] }
         set { self[AnimationReasonKey.self] = newValue }
     }
 
+    package var animationReason: UInt32? {
+        get { _animationReason }
+        set { _animationReason = newValue }
+    }
+
     package var isAnimated: Bool {
-        guard let animation,
+        guard animation != nil,
               !disablesAnimations else {
             return false
         }
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/VelocityTrackingAnimation.swift b/Sources/OpenSwiftUICore/Animation/Animation/VelocityTrackingAnimation.swift
similarity index 100%
rename from Sources/OpenSwiftUICore/View/Animation/Animation/VelocityTrackingAnimation.swift
rename to Sources/OpenSwiftUICore/Animation/Animation/VelocityTrackingAnimation.swift
diff --git a/Sources/OpenSwiftUICore/View/Animation/Transaction/Transaction.swift b/Sources/OpenSwiftUICore/Animation/Transaction/Transaction.swift
similarity index 100%
rename from Sources/OpenSwiftUICore/View/Animation/Transaction/Transaction.swift
rename to Sources/OpenSwiftUICore/Animation/Transaction/Transaction.swift
diff --git a/Sources/OpenSwiftUICore/View/Animation/Transaction/TransactionID.swift b/Sources/OpenSwiftUICore/Animation/Transaction/TransactionID.swift
similarity index 100%
rename from Sources/OpenSwiftUICore/View/Animation/Transaction/TransactionID.swift
rename to Sources/OpenSwiftUICore/Animation/Transaction/TransactionID.swift
diff --git a/Sources/OpenSwiftUICore/View/Animation/Transaction/TransactionModifier.swift b/Sources/OpenSwiftUICore/Animation/Transaction/TransactionModifier.swift
similarity index 100%
rename from Sources/OpenSwiftUICore/View/Animation/Transaction/TransactionModifier.swift
rename to Sources/OpenSwiftUICore/Animation/Transaction/TransactionModifier.swift
diff --git a/Sources/OpenSwiftUICore/View/Animation/Transition/TransitionTraitKey.swift b/Sources/OpenSwiftUICore/Animation/Transition/TransitionTraitKey.swift
similarity index 100%
rename from Sources/OpenSwiftUICore/View/Animation/Transition/TransitionTraitKey.swift
rename to Sources/OpenSwiftUICore/Animation/Transition/TransitionTraitKey.swift
diff --git a/Sources/OpenSwiftUICore/Modifier/ViewModifier.swift b/Sources/OpenSwiftUICore/Modifier/ViewModifier.swift
index c713c9c1d..f975fd299 100644
--- a/Sources/OpenSwiftUICore/Modifier/ViewModifier.swift
+++ b/Sources/OpenSwiftUICore/Modifier/ViewModifier.swift
@@ -150,7 +150,7 @@ extension MultiViewModifier {
 // MARK: - ViewModifier + _GraphInputsModifier
 
 extension ViewModifier where Self: _GraphInputsModifier, Body == Never {
-    public static func _makeView(
+    nonisolated public static func _makeView(
         modifier: _GraphValue<Self>,
         inputs: _ViewInputs,
         body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
@@ -160,7 +160,7 @@ extension ViewModifier where Self: _GraphInputsModifier, Body == Never {
         return body(_Graph(), inputs)
     }
     
-    public static func _makeViewList(
+    nonisolated public static func _makeViewList(
         modifier: _GraphValue<Self>,
         inputs: _ViewListInputs,
         body: @escaping (_Graph, _ViewListInputs) -> _ViewListOutputs
@@ -170,7 +170,7 @@ extension ViewModifier where Self: _GraphInputsModifier, Body == Never {
         return body(_Graph(), inputs)
     }
 
-    public static func _viewListCount(
+    nonisolated public static func _viewListCount(
         inputs: _ViewListCountInputs,
         body: (_ViewListCountInputs) -> Int?
     ) -> Int? {
diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyleModifier.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyleModifier.swift
index 2805b576e..b0b431570 100644
--- a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyleModifier.swift
+++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ForegroundStyleModifier.swift
@@ -176,19 +176,17 @@ extension View {
 
 @available(OpenSwiftUI_v3_0, *)
 @frozen
-@MainActor
-@preconcurrency
 public struct _ForegroundStyleModifier<Style>: PrimitiveViewModifier, ViewInputsModifier where Style: ShapeStyle {
-    nonisolated package static var graphInputsSemantics: Semantics? { .v4 }
-    
+    package static var graphInputsSemantics: Semantics? { .v4 }
+
     public var style: Style
     
     @inlinable
-    nonisolated public init(style: Style) {
+    public init(style: Style) {
         self.style = style
     }
     
-    public nonisolated static func _makeViewInputs(modifier: _GraphValue<_ForegroundStyleModifier<Style>>, inputs: inout _ViewInputs) {
+    nonisolated public static func _makeViewInputs(modifier: _GraphValue<_ForegroundStyleModifier<Style>>, inputs: inout _ViewInputs) {
         _openSwiftUIUnimplementedFailure()
     }
     
diff --git a/Sources/OpenSwiftUICore/Util/Extension/MutableCollection+Extension.swift b/Sources/OpenSwiftUICore/Util/Extension/MutableCollection+Extension.swift
new file mode 100644
index 000000000..7b91aaf4b
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Util/Extension/MutableCollection+Extension.swift
@@ -0,0 +1,215 @@
+//
+//  MutableCollection+Extension.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Implmeneted by Copilot
+
+public import Foundation
+
+@available(OpenSwiftUI_v1_0, *)
+extension RangeReplaceableCollection where Self: MutableCollection {
+    public mutating func remove(atOffsets offsets: IndexSet) {
+        guard !offsets.isEmpty else { return }
+        let partitionIndex = halfStablePartitionByOffset { offset in
+            offsets.contains(offset)
+        }
+        removeSubrange(partitionIndex...)
+    }
+}
+
+extension RangeReplaceableCollection {
+    package mutating func _remove(atOffsets offsets: IndexSet) {
+        guard !offsets.isEmpty else { return }
+        
+        let ranges = offsets.rangeView.reversed()
+        
+        for range in ranges {
+            let startOffset = range.lowerBound
+            let endOffset = range.upperBound
+            
+            guard startOffset >= 0 && startOffset < count else { continue }
+            guard endOffset > startOffset && endOffset <= count else { continue }
+            
+            let startIndex = index(self.startIndex, offsetBy: startOffset)
+            let endIndex = index(self.startIndex, offsetBy: endOffset)
+            
+            removeSubrange(startIndex..<endIndex)
+        }
+    }
+}
+
+extension Collection {
+    package func firstIndexByOffset(where predicate: (Int) throws -> Bool) rethrows -> (Index, Int)? {
+        var offset = 0
+        var currentIndex = startIndex
+        
+        while currentIndex != endIndex {
+            if try predicate(offset) {
+                return (currentIndex, offset)
+            }
+            formIndex(after: &currentIndex)
+            offset += 1
+        }
+        
+        return nil
+    }
+}
+
+extension MutableCollection {
+    package mutating func halfStablePartitionByOffset(isSuffixElementAtOffset: (Int) throws -> Bool) rethrows -> Index {
+        guard !isEmpty else { return startIndex }
+        
+        var writeIndex = startIndex
+        var offset = 0
+        
+        for readIndex in indices {
+            let shouldKeep = try !isSuffixElementAtOffset(offset)
+            if shouldKeep {
+                if writeIndex != readIndex {
+                    swapAt(writeIndex, readIndex)
+                }
+                formIndex(after: &writeIndex)
+            }
+            offset += 1
+        }
+        
+        return writeIndex
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension MutableCollection where Self: RangeReplaceableCollection {
+    public mutating func move(fromOffsets source: IndexSet, toOffset destination: Int) {
+        guard !source.isEmpty else { return }
+        guard destination >= 0 && destination <= count else { return }
+        
+        let sourceIndices = source.compactMap { offset -> Index? in
+            guard offset >= 0 && offset < count else { return nil }
+            return index(startIndex, offsetBy: offset)
+        }
+        
+        guard !sourceIndices.isEmpty else { return }
+        
+        let sourceElements = sourceIndices.map { self[$0] }
+        
+        var adjustedDestination = destination
+        for offset in source.sorted() {
+            if offset < destination {
+                adjustedDestination -= 1
+            }
+        }
+        
+        for offset in source.sorted(by: >) {
+            guard offset >= 0 && offset < count else { continue }
+            let indexToRemove = index(startIndex, offsetBy: offset)
+            remove(at: indexToRemove)
+        }
+        
+        if adjustedDestination >= 0 && adjustedDestination <= count {
+            let insertionIndex = index(startIndex, offsetBy: adjustedDestination)
+            insert(contentsOf: sourceElements, at: insertionIndex)
+        }
+    }
+
+    @discardableResult
+    package mutating func stablePartitionByOffset(
+        in range: Range<Index>,
+        startOffset: Int,
+        isSuffixElementAtOffset: (Int) throws -> Bool
+    ) rethrows -> Index {
+        guard range.lowerBound != range.upperBound else { return range.lowerBound }
+        
+        var writeIndex = range.lowerBound
+        var currentIndex = range.lowerBound
+        var offset = startOffset
+        
+        while currentIndex != range.upperBound {
+            let shouldKeep = try !isSuffixElementAtOffset(offset)
+            if shouldKeep {
+                if writeIndex != currentIndex {
+                    swapAt(writeIndex, currentIndex)
+                }
+                formIndex(after: &writeIndex)
+            }
+            formIndex(after: &currentIndex)
+            offset += 1
+        }
+        
+        return writeIndex
+    }
+
+    package mutating func stablePartitionByOffset(
+        in range: Range<Index>,
+        startOffset: Int,
+        count n: Int,
+        isSuffixElementAtOffset: (Int) throws -> Bool
+    ) rethrows -> Index {
+        guard n > 0 else { return range.lowerBound }
+        guard range.lowerBound != range.upperBound else { return range.lowerBound }
+        
+        let endIndex = index(range.lowerBound, offsetBy: Swift.min(n, distance(from: range.lowerBound, to: range.upperBound)))
+        let subRange = range.lowerBound..<endIndex
+        
+        return try stablePartitionByOffset(
+            in: subRange,
+            startOffset: startOffset,
+            isSuffixElementAtOffset: isSuffixElementAtOffset
+        )
+    }
+
+    @discardableResult
+    package mutating func rotate(
+        in range: Range<Index>,
+        shiftingToStart middle: Index
+    ) -> Index {
+        guard range.lowerBound != range.upperBound else { return range.lowerBound }
+        guard middle != range.lowerBound && middle != range.upperBound else { return middle }
+        
+        let firstHalf = range.lowerBound..<middle
+        let secondHalf = middle..<range.upperBound
+        
+        guard !firstHalf.isEmpty && !secondHalf.isEmpty else { return middle }
+        
+        var result = middle
+        var currentRange = range
+        var currentMiddle = middle
+        
+        while currentRange.lowerBound != currentRange.upperBound && currentMiddle != currentRange.lowerBound {
+            let (newMiddle, newEnd) = _swapNonemptySubrangePrefixes(
+                currentRange.lowerBound..<currentMiddle,
+                currentMiddle..<currentRange.upperBound
+            )
+            
+            if distance(from: currentRange.lowerBound, to: newMiddle) < distance(from: newMiddle, to: newEnd) {
+                currentRange = newMiddle..<currentRange.upperBound
+                currentMiddle = newEnd
+            } else {
+                currentRange = currentRange.lowerBound..<newMiddle
+                result = currentRange.lowerBound
+            }
+        }
+        
+        return result
+    }
+
+    package mutating func _swapNonemptySubrangePrefixes(
+        _ lhs: Range<Index>,
+        _ rhs: Range<Index>
+    ) -> (Index, Index) {
+        let lhsCount = distance(from: lhs.lowerBound, to: lhs.upperBound)
+        let rhsCount = distance(from: rhs.lowerBound, to: rhs.upperBound)
+        let swapCount = Swift.min(lhsCount, rhsCount)
+
+        var lhsIndex = lhs.lowerBound
+        var rhsIndex = rhs.lowerBound
+        
+        for _ in 0..<swapCount {
+            swapAt(lhsIndex, rhsIndex)
+            formIndex(after: &lhsIndex)
+            formIndex(after: &rhsIndex)
+        }
+        
+        return (lhsIndex, rhsIndex)
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Util/_RemoveGlobalActor.swift b/Sources/OpenSwiftUICore/Util/_RemoveGlobalActor.swift
index b0eb6ce62..ed6ff2e67 100644
--- a/Sources/OpenSwiftUICore/Util/_RemoveGlobalActor.swift
+++ b/Sources/OpenSwiftUICore/Util/_RemoveGlobalActor.swift
@@ -10,7 +10,7 @@
 public actor _ImpossibleActor: Sendable {
     public static var shared = _ImpossibleActor()
     
-    public nonisolated var unownedExecutor: UnownedSerialExecutor {
+    nonisolated public var unownedExecutor: UnownedSerialExecutor {
         _ImpossibleExecutor().asUnownedSerialExecutor()
     }
 }
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/Animation.swift b/Sources/OpenSwiftUICore/View/Animation/Animation/Animation.swift
deleted file mode 100644
index 3ffde2453..000000000
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/Animation.swift
+++ /dev/null
@@ -1,10 +0,0 @@
-@frozen
-public struct Animation: Equatable {
-//    var box: AnimationBoxBase
-    public static func == (lhs: Animation, rhs: Animation) -> Bool {
-        // TODO
-        true
-    }
-
-    public static var `default` = Animation()
-}
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/CustomAnimation.swift b/Sources/OpenSwiftUICore/View/Animation/Animation/CustomAnimation.swift
deleted file mode 100644
index be7ee56bf..000000000
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/CustomAnimation.swift
+++ /dev/null
@@ -1,233 +0,0 @@
-//
-//  CustomAnimation.swift
-//  OpenSwiftUICore
-//
-//  Status: WIP
-//  ID: 35ADF281214A25133F1A6DF28858952D (SwiftUICore?)
-
-package import Foundation
-package import OpenGraphShims
-
-// MARK: - FrameVelocityFilter [6.4.41]
-
-private struct FrameVelocityFilter {
-    var currentVelocity: Double?
-    var previous: ((Time, CGRect.AnimatableData))?
-
-    mutating func addSample(_ rect: CGRect.AnimatableData, time: Time) {
-        guard let (previousTime, previousRect) = previous,
-              previousTime <= time else {
-            previous = (time, rect)
-            return
-        }
-        let deltaX = rect.first.first - previousRect.first.first
-        let deltaY = rect.first.second - previousRect.first.second
-        let deltaWidth = rect.second.first - previousRect.second.first
-        let deltaHeight = rect.second.second - previousRect.second.second
-
-        let timeFactor = 1.0 / (time - previousTime)
-
-        let velocityX = timeFactor * deltaX
-        let velocityY = timeFactor * deltaY
-        let velocityWidth = timeFactor * deltaWidth
-        let velocityHeight = timeFactor * deltaHeight
-
-        let velocityRect = CGRect(x: velocityX, y: velocityY, width: velocityWidth, height: velocityHeight)
-        let newVelocity = max(abs(velocityRect.minX), abs(velocityRect.maxX), abs(velocityRect.minY), abs(velocityRect.maxY))
-        if let existingVelocity = currentVelocity {
-            currentVelocity = mix(existingVelocity, newVelocity, by: 0.35)
-        } else {
-            currentVelocity = newVelocity
-        }
-        previous = (time, rect)
-    }
-}
-
-// MARK: - AnimatableAttribute [6.4.41] [TODO]
-
-package struct AnimatableAttribute<Value>: StatefulRule, AsyncAttribute, ObservedAttribute, CustomStringConvertible where Value: Animatable {
-    @Attribute var source: Value
-    @Attribute var environment: EnvironmentValues
-    var helper: AnimatableAttributeHelper<Value>
-
-    package init(
-        source: Attribute<Value>,
-        phase: Attribute<_GraphInputs.Phase>,
-        time: Attribute<Time>,
-        transaction: Attribute<Transaction>,
-        environment: Attribute<EnvironmentValues>
-    ) {
-        _source = source
-        _environment = environment
-        helper = .init(phase: phase, time: time, transaction: transaction)
-    }
-
-    package mutating func updateValue() {
-        // TODO
-        // Blocked by helper
-    }
-
-    package var description: String { "Animatable<\(Value.self)>" }
-
-    package mutating func destroy() {
-        // helper.animatorState?.removeListeners()
-    }
-}
-
-// MARK: - AnimatableFrameAttribute [6.4.41] [TODO]
-
-package struct AnimatableFrameAttribute: StatefulRule, AsyncAttribute, ObservedAttribute {
-    @Attribute
-    private var position: ViewOrigin
-
-    @Attribute
-    private var size: ViewSize
-
-    @Attribute
-    private var pixelLength: CGFloat
-
-    @Attribute
-    private var environment: EnvironmentValues
-
-    private var helper: AnimatableAttributeHelper<ViewFrame>
-
-    let animationsDisabled: Bool
-
-    package init(
-        position: Attribute<ViewOrigin>,
-        size: Attribute<ViewSize>,
-        pixelLength: Attribute<CGFloat>,
-        environment: Attribute<EnvironmentValues>,
-        phase: Attribute<_GraphInputs.Phase>,
-        time: Attribute<Time>,
-        transaction: Attribute<Transaction>,
-        animationsDisabled: Bool
-    ) {
-        _position = position
-        _size = size
-        _pixelLength = pixelLength
-        _environment = environment
-        helper = .init(phase: phase, time: time, transaction: transaction)
-        self.animationsDisabled = animationsDisabled
-    }
-
-    package typealias Value = ViewFrame
-
-    package mutating func updateValue() {
-        let (position, positionChanged) = $position.changedValue()
-        let (size, sizeChanged) = $size.changedValue()
-        let (pixelLength, pixelLengthChanged) = $pixelLength.changedValue()
-        let changed = positionChanged || sizeChanged || pixelLengthChanged
-        var rect = CGRect(origin: position, size: size.value)
-        rect.roundCoordinatesToNearestOrUp(toMultipleOf: pixelLength)
-        let viewFrame = ViewFrame(
-            origin: rect.origin,
-            size: ViewSize(value: rect.size, proposal: size._proposal)
-        )
-        if !animationsDisabled {
-            // TODO: helper
-        }
-        if changed || !hasValue {
-            value = viewFrame
-        }
-    }
-
-    package mutating func destroy() {
-        // helper.animatorState?.removeListeners()
-    }
-}
-
-// MARK: - AnimatableFrameAttributeVFD [6.4.41] [TODO]
-
-package struct AnimatableFrameAttributeVFD: StatefulRule, AsyncAttribute, ObservedAttribute {
-    @Attribute
-    private var position: ViewOrigin
-
-    @Attribute
-    private var size: ViewSize
-
-    @Attribute
-    private var pixelLength: CGFloat
-
-    @Attribute
-    private var environment: EnvironmentValues
-
-    private var helper: AnimatableAttributeHelper<ViewFrame>
-
-    private var velocityFilter: FrameVelocityFilter
-
-    let animationsDisabled: Bool
-
-    package init(
-        position: Attribute<ViewOrigin>,
-        size: Attribute<ViewSize>,
-        pixelLength: Attribute<CGFloat>,
-        environment: Attribute<EnvironmentValues>,
-        phase: Attribute<_GraphInputs.Phase>,
-        time: Attribute<Time>,
-        transaction: Attribute<Transaction>,
-        animationsDisabled: Bool
-    ) {
-        _position = position
-        _size = size
-        _pixelLength = pixelLength
-        _environment = environment
-        helper = .init(phase: phase, time: time, transaction: transaction)
-        velocityFilter = FrameVelocityFilter()
-        self.animationsDisabled = animationsDisabled
-    }
-
-    package typealias Value = ViewFrame
-
-    package mutating func updateValue() {
-        let (position, positionChanged) = $position.changedValue()
-        let (size, sizeChanged) = $size.changedValue()
-        let (pixelLength, pixelLengthChanged) = $pixelLength.changedValue()
-        let changed = positionChanged || sizeChanged || pixelLengthChanged
-        var rect = CGRect(origin: position, size: size.value)
-        rect.roundCoordinatesToNearestOrUp(toMultipleOf: pixelLength)
-        let viewFrame = ViewFrame(
-            origin: rect.origin,
-            size: ViewSize(value: rect.size, proposal: size._proposal)
-        )
-        if !animationsDisabled {
-            // TODO
-        }
-        if changed || !hasValue {
-            value = viewFrame
-        }
-    }
-
-    package mutating func destroy() {
-        // helper.animatorState?.removeListeners()
-    }
-}
-
-// MARK: - AnimatableAttributeHelper [FIXME]
-
-package struct AnimatableAttributeHelper<Value> where Value: Animatable {
-    @Attribute
-    private var phase: _GraphInputs.Phase
-
-    @Attribute
-    private var time: Time
-
-    @Attribute
-    private var transaction: Transaction
-
-    private var previousModelData: Value.AnimatableData?
-
-    // private var animatorState: AnimatorState<Value.AnimatableData>?
-
-    private var resetSeed: UInt32 = 0
-
-    init(
-        phase: Attribute<_GraphInputs.Phase>,
-        time: Attribute<Time>,
-        transaction: Attribute<Transaction>
-    ) {
-        _phase = phase
-        _time = time
-        _transaction = transaction
-    }
-}
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/TODO/AnimatableModifier.swift b/Sources/OpenSwiftUICore/View/Animation/Animation/TODO/AnimatableModifier.swift
deleted file mode 100644
index dae673eb4..000000000
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/TODO/AnimatableModifier.swift
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-//  AnimatableModifier.swift
-//  OpenSwiftUI
-//
-//  Audited for iOS 15.5
-//  Status: Blocked by Graph
-
-@available(*, deprecated, message: "use Animatable directly")
-public protocol AnimatableModifier: Animatable, ViewModifier {}
-
-@available(*, deprecated, message: "use Animatable directly")
-extension AnimatableModifier {
-    public static func _makeView(modifier _: _GraphValue<Self>, inputs _: _ViewInputs, body _: @escaping (_Graph, _ViewInputs) -> _ViewOutputs) -> _ViewOutputs {
-        .init()
-    }
-
-    public static func _makeViewList(modifier _: _GraphValue<Self>, inputs _: _ViewListInputs, body _: @escaping (_Graph, _ViewListInputs) -> _ViewListOutputs) -> _ViewListOutputs {
-        _openSwiftUIUnimplementedFailure()
-    }
-}
-
-extension ViewModifier where Self: Animatable {
-    public static func _makeView(modifier _: _GraphValue<Self>, inputs _: _ViewInputs, body _: @escaping (_Graph, _ViewInputs) -> _ViewOutputs) -> _ViewOutputs {
-        .init()
-    }
-
-    public static func _makeViewList(modifier _: _GraphValue<Self>, inputs _: _ViewListInputs, body _: @escaping (_Graph, _ViewListInputs) -> _ViewListOutputs) -> _ViewListOutputs {
-        _openSwiftUIUnimplementedFailure()
-    }
-}
diff --git a/Sources/OpenSwiftUICore/View/Animation/Animation/TODO/_AnimatableView.swift b/Sources/OpenSwiftUICore/View/Animation/Animation/TODO/_AnimatableView.swift
deleted file mode 100644
index c87969cd7..000000000
--- a/Sources/OpenSwiftUICore/View/Animation/Animation/TODO/_AnimatableView.swift
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-//  _AnimatableView.swift
-//  OpenSwiftUI
-//
-//  Audited for iOS 15.5
-//  Status: Blocked by Graph
-
-@available(*, deprecated, message: "use Animatable directly")
-public protocol _AnimatableView: Animatable, View {}
-
-@available(*, deprecated, message: "use Animatable directly")
-extension _AnimatableView {
-    public static func _makeView(view _: _GraphValue<Self>, inputs _: _ViewInputs) -> _ViewOutputs {
-        .init()
-    }
-
-    public static func _makeViewList(view _: _GraphValue<Self>, inputs _: _ViewListInputs) -> _ViewListOutputs {
-        _openSwiftUIUnimplementedFailure()
-    }
-}
-
-extension View where Self: Animatable {
-    public static func _makeView(view _: _GraphValue<Self>, inputs _: _ViewInputs) -> _ViewOutputs {
-        .init()
-    }
-
-    public static func _makeViewList(view _: _GraphValue<Self>, inputs _: _ViewListInputs) -> _ViewListOutputs {
-        _openSwiftUIUnimplementedFailure()
-    }
-}
diff --git a/Tests/OpenSwiftUICoreTests/Util/Extension/MutableCollectionExtensionTests.swift b/Tests/OpenSwiftUICoreTests/Util/Extension/MutableCollectionExtensionTests.swift
new file mode 100644
index 000000000..f245d6a47
--- /dev/null
+++ b/Tests/OpenSwiftUICoreTests/Util/Extension/MutableCollectionExtensionTests.swift
@@ -0,0 +1,349 @@
+//
+//  MutableCollectionExtensionTests.swift
+//  OpenSwiftUICoreTests
+
+import Foundation
+import OpenSwiftUICore
+import Testing
+
+// MARK: - MutableCollectionExtensionTests [Implmeneted by Copilot]
+
+struct MutableCollectionExtensionTests {
+    // MARK: - remove(atOffsets:)
+
+    @Test
+    func removeAtOffsetsEmpty() {
+        var array = [1, 2, 3, 4, 5]
+        array.remove(atOffsets: IndexSet())
+        #expect(array == [1, 2, 3, 4, 5])
+    }
+
+    @Test
+    func removeAtOffsetsSingle() {
+        var array = [1, 2, 3, 4, 5]
+        array.remove(atOffsets: IndexSet([2]))
+        #expect(array == [1, 2, 4, 5])
+    }
+
+    @Test
+    func removeAtOffsetsMultiple() {
+        var array = [1, 2, 3, 4, 5]
+        array.remove(atOffsets: IndexSet([1, 3]))
+        #expect(array == [1, 3, 5])
+    }
+
+    @Test
+    func removeAtOffsetsConsecutive() {
+        var array = [1, 2, 3, 4, 5]
+        array.remove(atOffsets: IndexSet([1, 2, 3]))
+        #expect(array == [1, 5])
+    }
+
+    @Test
+    func removeAtOffsetsAll() {
+        var array = [1, 2, 3]
+        array.remove(atOffsets: IndexSet([0, 1, 2]))
+        #expect(array.isEmpty)
+    }
+
+    // MARK: - _remove(atOffsets:)
+
+    @Test
+    func _removeAtOffsetsEmpty() {
+        var array = [1, 2, 3, 4, 5]
+        array._remove(atOffsets: IndexSet())
+        #expect(array == [1, 2, 3, 4, 5])
+    }
+
+    @Test
+    func _removeAtOffsetsRange() {
+        var array = [1, 2, 3, 4, 5]
+        array._remove(atOffsets: IndexSet(1 ... 3))
+        #expect(array == [1, 5])
+    }
+
+    @Test
+    func _removeAtOffsetsMultipleRanges() {
+        var array = [1, 2, 3, 4, 5, 6, 7]
+        array._remove(atOffsets: IndexSet([1, 3, 5]))
+        #expect(array == [1, 3, 5, 7])
+    }
+
+    // MARK: - firstIndexByOffset(where:)
+
+    @Test
+    func firstIndexByOffsetFound() {
+        let array = [10, 20, 30, 40]
+        let result = array.firstIndexByOffset { $0 == 2 }
+
+        #expect(result?.1 == 2)
+        #expect(array[result!.0] == 30)
+    }
+
+    @Test
+    func firstIndexByOffsetNotFound() {
+        let array = [10, 20, 30]
+        let result = array.firstIndexByOffset { $0 == 5 }
+
+        #expect(result == nil)
+    }
+
+    @Test
+    func firstIndexByOffsetEmpty() {
+        let array: [Int] = []
+        let result = array.firstIndexByOffset { _ in true }
+
+        #expect(result == nil)
+    }
+
+    @Test
+    func firstIndexByOffsetFirst() {
+        let array = [10, 20, 30]
+        let result = array.firstIndexByOffset { $0 == 0 }
+
+        #expect(result?.1 == 0)
+        #expect(array[result!.0] == 10)
+    }
+
+    // MARK: - halfStablePartitionByOffset
+
+    @Test
+    func halfStablePartitionByOffsetEmpty() {
+        var array: [Int] = []
+        let result = array.halfStablePartitionByOffset { _ in false }
+
+        #expect(result == array.startIndex)
+    }
+
+    @Test
+    func halfStablePartitionByOffsetKeepAll() {
+        var array = [1, 2, 3, 4, 5]
+        let result = array.halfStablePartitionByOffset { _ in false }
+
+        #expect(array == [1, 2, 3, 4, 5])
+        #expect(result == array.endIndex)
+    }
+
+    @Test
+    func halfStablePartitionByOffsetRemoveAll() {
+        var array = [1, 2, 3, 4, 5]
+        let result = array.halfStablePartitionByOffset { _ in true }
+
+        #expect(result == array.startIndex)
+    }
+
+    @Test
+    func halfStablePartitionByOffsetMixed() {
+        var array = [1, 2, 3, 4, 5]
+        let result = array.halfStablePartitionByOffset { $0 % 2 == 0 }
+
+        #expect(Array(array[..<result]) == [2, 4])
+    }
+
+    // MARK: - move(fromOffsets:toOffset:)
+
+    @Test
+    func moveEmpty() {
+        var array = [1, 2, 3, 4, 5]
+        array.move(fromOffsets: IndexSet(), toOffset: 2)
+        #expect(array == [1, 2, 3, 4, 5])
+    }
+
+    @Test
+    func moveSingleForward() {
+        var array = [1, 2, 3, 4, 5]
+        array.move(fromOffsets: IndexSet([1]), toOffset: 4)
+        #expect(array == [1, 3, 4, 2, 5])
+    }
+
+    @Test
+    func moveSingleBackward() {
+        var array = [1, 2, 3, 4, 5]
+        array.move(fromOffsets: IndexSet([3]), toOffset: 1)
+        #expect(array == [1, 4, 2, 3, 5])
+    }
+
+    @Test
+    func moveMultiple() {
+        var array = [1, 2, 3, 4, 5]
+        array.move(fromOffsets: IndexSet([1, 3]), toOffset: 0)
+        #expect(array == [2, 4, 1, 3, 5])
+    }
+
+    @Test
+    func moveToEnd() {
+        var array = [1, 2, 3, 4, 5]
+        array.move(fromOffsets: IndexSet([0, 2]), toOffset: 5)
+        #expect(array == [2, 4, 5, 1, 3])
+    }
+
+    // MARK: - stablePartitionByOffset
+
+    @Test
+    func stablePartitionByOffsetFullRange() {
+        var array = [1, 2, 3, 4, 5]
+        let result = array.stablePartitionByOffset(
+            in: array.startIndex ..< array.endIndex,
+            startOffset: 0,
+            isSuffixElementAtOffset: { $0 % 2 == 1 }
+        )
+
+        #expect(Array(array[..<result]) == [1, 3, 5])
+        #expect(Array(array[result...]) == [4, 2])
+    }
+
+    @Test
+    func stablePartitionByOffsetSubrange() {
+        var array = [1, 2, 3, 4, 5]
+        let startIndex = array.index(after: array.startIndex)
+        let endIndex = array.index(before: array.endIndex)
+
+        let _ = array.stablePartitionByOffset(
+            in: startIndex ..< endIndex,
+            startOffset: 1,
+            isSuffixElementAtOffset: { $0 % 2 == 0 }
+        )
+
+        #expect(array[0] == 1)
+        #expect(array[4] == 5)
+    }
+
+    @Test
+    func stablePartitionByOffsetWithCount() {
+        var array = [1, 2, 3, 4, 5, 6]
+        let result = array.stablePartitionByOffset(
+            in: array.startIndex ..< array.endIndex,
+            startOffset: 0,
+            count: 4,
+            isSuffixElementAtOffset: { $0 % 2 == 1 }
+        )
+
+        #expect(Array(array[..<result]) == [1, 3])
+        #expect(array[4] == 5)
+        #expect(array[5] == 6)
+    }
+
+    // MARK: - rotate
+
+    @Test
+    func rotateEmpty() {
+        var array: [Int] = []
+        let result = array.rotate(
+            in: array.startIndex ..< array.endIndex,
+            shiftingToStart: array.startIndex
+        )
+        #expect(result == array.startIndex)
+    }
+
+    @Test
+    func rotateSingle() {
+        var array = [1]
+        let result = array.rotate(
+            in: array.startIndex ..< array.endIndex,
+            shiftingToStart: array.startIndex
+        )
+        #expect(result == array.startIndex)
+        #expect(array == [1])
+    }
+
+    // MARK: - _swapNonemptySubrangePrefixes
+
+    @Test
+    func swapNonemptySubrangePrefixesEqual() {
+        var array = [1, 2, 3, 4, 5, 6]
+        let lhs = array.startIndex ..< array.index(array.startIndex, offsetBy: 3)
+        let rhs = array.index(array.startIndex, offsetBy: 3) ..< array.endIndex
+
+        let (newLhs, newRhs) = array._swapNonemptySubrangePrefixes(lhs, rhs)
+
+        #expect(array == [4, 5, 6, 1, 2, 3])
+        #expect(newLhs == array.index(array.startIndex, offsetBy: 3))
+        #expect(newRhs == array.endIndex)
+    }
+
+    @Test
+    func swapNonemptySubrangePrefixesUnequal() {
+        var array = [1, 2, 3, 4, 5]
+        let lhs = array.startIndex ..< array.index(array.startIndex, offsetBy: 2)
+        let rhs = array.index(array.startIndex, offsetBy: 2) ..< array.endIndex
+
+        let (newLhs, newRhs) = array._swapNonemptySubrangePrefixes(lhs, rhs)
+
+        #expect(array == [3, 4, 1, 2, 5])
+        #expect(newLhs == array.index(array.startIndex, offsetBy: 2))
+        #expect(newRhs == array.index(array.startIndex, offsetBy: 4))
+    }
+
+    @Test
+    func swapNonemptySubrangePrefixesSingle() {
+        var array = [1, 2]
+        let lhs = array.startIndex ..< array.index(after: array.startIndex)
+        let rhs = array.index(after: array.startIndex) ..< array.endIndex
+
+        let (newLhs, newRhs) = array._swapNonemptySubrangePrefixes(lhs, rhs)
+
+        #expect(array == [2, 1])
+        #expect(newLhs == array.index(after: array.startIndex))
+        #expect(newRhs == array.endIndex)
+    }
+
+    // MARK: - Edge Cases
+
+    @Test
+    func removeAtOffsetsInvalidIndices() {
+        var array = [1, 2, 3]
+        array.remove(atOffsets: IndexSet([5, 10]))
+        #expect(array == [1, 2, 3])
+    }
+
+    @Test
+    func moveInvalidDestination() {
+        var array = [1, 2, 3]
+        array.move(fromOffsets: IndexSet([0]), toOffset: 10)
+        #expect(array == [1, 2, 3])
+    }
+
+    @Test
+    func moveInvalidSource() {
+        var array = [1, 2, 3]
+        array.move(fromOffsets: IndexSet([5]), toOffset: 1)
+        #expect(array == [1, 2, 3])
+    }
+
+    // MARK: - String Collection Tests
+
+    @Test
+    func stringCollectionRemove() {
+        let string = "hello"
+        var chars = Array(string)
+        chars.remove(atOffsets: IndexSet([1, 3]))
+        #expect(String(chars) == "hlo")
+    }
+
+    @Test
+    func stringCollectionMove() {
+        let string = "hello"
+        var chars = Array(string)
+        chars.move(fromOffsets: IndexSet([0]), toOffset: 4)
+        #expect(String(chars) == "ellho")
+    }
+
+    // MARK: - Performance Edge Cases
+
+    @Test
+    func largeCollectionRemove() {
+        var array = Array(0 ..< 1000)
+        let offsets = IndexSet(stride(from: 0, to: 1000, by: 2))
+        array.remove(atOffsets: offsets)
+        #expect(array.count == 500)
+        #expect(array.allSatisfy { $0 % 2 == 1 })
+    }
+
+    @Test
+    func largeCollectionMove() {
+        var array = Array(0 ..< 100)
+        let sourceOffsets = IndexSet([0, 10, 20, 30])
+        array.move(fromOffsets: sourceOffsets, toOffset: 50)
+        #expect(array.count == 100)
+    }
+}