diff --git a/.agents/interfaces/ios/Resettable.swiftinterface b/.agents/interfaces/ios/Resettable.swiftinterface
new file mode 100644
index 0000000..9d86916
--- /dev/null
+++ b/.agents/interfaces/ios/Resettable.swiftinterface
@@ -0,0 +1,296 @@
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)
+// swift-module-flags: -target arm64-apple-ios13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name Resettable -package-name swift_resettable
+// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3
+import KeyPathMapping
+import KeyPathsExtensions
+import Swift
+import SwiftMarkerProtocols
+import _Concurrency
+import _StringProcessing
+import _SwiftConcurrencyShims
+extension Resettable.Resettable where Base : Swift.Collection {
+  public var collection: Resettable.Resettable<Base>.WritableKeyPathContainer<Base> {
+    get
+  }
+}
+extension Resettable.Resettable.WritableKeyPathContainer where Value : Swift.Collection {
+  @discardableResult
+  public func swapAt<T>(_ idx1: Swift.Array<T>.Index, _ idx2: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+  @discardableResult
+  public func remove<T>(at idx: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+  @discardableResult
+  public func insert<T>(_ element: Swift.Array<T>.Element, at idx: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+  @discardableResult
+  public func append<T>(_ element: Swift.Array<T>.Element, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+}
+extension Resettable.Resettable {
+  public enum OperationBehavior {
+    case `default`
+    case amend
+    case insert
+    case inject
+    @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Resettable.Resettable<Base>.OperationBehavior, _ b: Resettable.Resettable<Base>.OperationBehavior) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+}
+@propertyWrapper @dynamicMemberLookup public class Resettable<Base> {
+  @available(*, deprecated, renamed: "Base")
+  public typealias Object = Base
+  convenience public init(wrappedValue: Base)
+  public init(_ base: Base)
+  @usableFromInline
+  internal var base: Base
+  @inlinable public var wrappedValue: Base {
+    _read { yield base }
+  }
+  @inlinable public var projectedValue: Resettable.Resettable<Base> {
+    get { self }
+  }
+  @discardableResult
+  public func undo() -> Resettable.Resettable<Base>
+  @discardableResult
+  public func redo() -> Resettable.Resettable<Base>
+  @discardableResult
+  @inlinable public func undo(_ count: Swift.Int) -> Resettable.Resettable<Base> {
+		for _ in 0..<count { undo() }
+		return self
+	}
+  @discardableResult
+  @inlinable public func redo(_ count: Swift.Int) -> Resettable.Resettable<Base> {
+		for _ in 0..<count { redo() }
+		return self
+	}
+  @discardableResult
+  public func undoAll() -> Resettable.Resettable<Base>
+  @discardableResult
+  public func redoAll() -> Resettable.Resettable<Base>
+  @discardableResult
+  public func _modify<Value>(operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ keyPath: Swift.WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base>
+  @discardableResult
+  public func _modify<Value>(operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ keyPath: Swift.WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift.Void, undo: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base>
+  @discardableResult
+  public func _modify(operation: Resettable.Resettable<Base>.OperationBehavior = .default, using action: @escaping (inout Base) -> Swift.Void, undo: @escaping (inout Base) -> Swift.Void) -> Resettable.Resettable<Base>
+  @inlinable public subscript<Value>(dynamicMember keyPath: Swift.WritableKeyPath<Base, Value>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<Value> {
+    get {
+		WritableKeyPathContainer(
+			resettable: self,
+			keyPath: keyPath
+		)
+	}
+  }
+  @inlinable public subscript<Value>(dynamicMember keyPath: Swift.KeyPath<Base, Value>) -> Resettable.Resettable<Base>.KeyPathContainer<Value> {
+    get {
+		KeyPathContainer(
+			resettable: self,
+			keyPath: keyPath
+		)
+	}
+  }
+  @objc deinit
+}
+extension Resettable.Resettable {
+  @dynamicMemberLookup public struct KeyPathContainer<Value> {
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.KeyPath<Base, Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.KeyPath<Base, Value>)
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.ReferenceWritableKeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<LocalValue> {
+      get {
+			WritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.KeyPathContainer<LocalValue> {
+      get {
+			KeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+  @dynamicMemberLookup public struct WritableKeyPathContainer<Value> {
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.WritableKeyPath<Base, Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.WritableKeyPath<Base, Value>)
+    @discardableResult
+    @inlinable public func callAsFunction(_ value: Value, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> {
+			return self.callAsFunction(operation) { $0 = value }
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base> {
+			return resettable._modify(
+				operation: operation,
+				keyPath,
+				using: action
+			)
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift.Void, undo: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base> {
+			return resettable._modify(
+				operation: operation,
+				keyPath,
+				using: action,
+				undo: undo
+			)
+		}
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.WritableKeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<LocalValue> {
+      get {
+			WritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.KeyPathContainer<LocalValue> {
+      get {
+			KeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+  @dynamicMemberLookup public struct IfLetKeyPathContainer<Wrapped> {
+    public typealias Value = Wrapped?
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.KeyPath<Base, Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>.Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.KeyPath<Base, Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>.Value>)
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.ReferenceWritableKeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalValue> {
+      get {
+			IfLetWritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalValue> {
+      get {
+			IfLetKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+  @dynamicMemberLookup public struct IfLetWritableKeyPathContainer<Wrapped> {
+    public typealias Value = Wrapped?
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.WritableKeyPath<Base, Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>.Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.WritableKeyPath<Base, Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>.Value>)
+    @discardableResult
+    @inlinable public func callAsFunction(_ value: Wrapped, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> {
+			guard resettable.wrappedValue[keyPath: keyPath] != nil else { return resettable }
+			return self.callAsFunction(operation) { $0 = value }
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift.Void) -> Resettable.Resettable<Base> {
+			guard let value = resettable.wrappedValue[keyPath: keyPath] else { return resettable }
+			return resettable._modify(
+				operation: operation,
+				keyPath.unwrapped(with: value),
+				using: action
+			)
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift.Void, undo: @escaping (inout Wrapped) -> Swift.Void) -> Resettable.Resettable<Base> {
+			guard let value = resettable.wrappedValue[keyPath: keyPath] else { return resettable }
+			return resettable._modify(
+				operation: operation,
+				keyPath.unwrapped(with: value),
+				using: action,
+				undo: undo
+			)
+		}
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.WritableKeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalValue> {
+      get {
+			IfLetWritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalValue> {
+      get {
+			IfLetKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+}
+extension Resettable.Resettable where Base : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Base.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable {
+  public func ifLet<Wrapped>(_ keyPath: Swift.WritableKeyPath<Base, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Base, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
+}
+extension Resettable.Resettable.WritableKeyPathContainer where Value : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Value.Wrapped> {
+    get
+  }
+  public func ifNil(_ value: Value, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base>
+}
+extension Resettable.Resettable.KeyPathContainer where Value : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetKeyPathContainer<Value.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable.IfLetWritableKeyPathContainer where Wrapped : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable.IfLetKeyPathContainer where Wrapped : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable.WritableKeyPathContainer {
+  public func ifLet<Wrapped>(_ keyPath: Swift.WritableKeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
+}
+extension Resettable.Resettable.KeyPathContainer {
+  public func ifLet<Wrapped>(_ keyPath: Swift.ReferenceWritableKeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
+}
+extension Resettable.Resettable.IfLetWritableKeyPathContainer {
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.WritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalWrapped>
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.KeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalWrapped>
+}
+extension Resettable.Resettable.IfLetKeyPathContainer {
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.ReferenceWritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalWrapped>
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.KeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalWrapped>
+}
+@usableFromInline
+@discardableResult
+internal func modification<T>(of object: T, with action: (inout T) -> Swift.Void) -> T
+extension Resettable.Resettable : Swift.Identifiable where Base : Swift.Identifiable {
+  @inlinable public var id: Base.ID {
+    get { wrappedValue.id }
+  }
+  public typealias ID = Base.ID
+}
+extension Resettable.Resettable.OperationBehavior : Swift.Equatable {}
+extension Resettable.Resettable.OperationBehavior : Swift.Hashable {}
diff --git a/.agents/interfaces/ios/_ResettableDebugging.swiftinterface b/.agents/interfaces/ios/_ResettableDebugging.swiftinterface
new file mode 100644
index 0000000..06c3a47
--- /dev/null
+++ b/.agents/interfaces/ios/_ResettableDebugging.swiftinterface
@@ -0,0 +1,29 @@
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)
+// swift-module-flags: -target arm64-apple-ios13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name _ResettableDebugging -package-name swift_resettable
+// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3
+import CustomDump
+@_exported import Resettable
+import Swift
+import _Concurrency
+import _StringProcessing
+import _SwiftConcurrencyShims
+extension Resettable.Resettable {
+  @available(*, deprecated, message: "Might be removed due to lack of Value type constraint, which makes the behavior unstable, consider re-implementing this feature locally if needed")
+  public struct ValuesDump {
+    @usableFromInline
+    internal init(items: [Resettable.Resettable<Base>.Object], currentIndex: Swift.Int)
+    public let items: [Resettable.Resettable<Base>.Object]
+    public let currentIndex: Swift.Int
+  }
+}
+extension Resettable.Resettable {
+  @available(*, deprecated, message: "Might be removed due to lack of Value type constraint, which makes the behavior unstable, consider re-implementing this feature locally if needed")
+  public func valuesDump() -> Resettable.Resettable<Base>.ValuesDump
+  @inlinable public func dump() -> Swift.String {
+		var buffer = ""
+		self.dump(to: &buffer)
+		return buffer
+	}
+  public func dump<TargetStream>(to stream: inout TargetStream) where TargetStream : Swift.TextOutputStream
+}
diff --git a/.agents/interfaces/macos/Resettable.swiftinterface b/.agents/interfaces/macos/Resettable.swiftinterface
index 3a489b8..d8ee715 100644
--- a/.agents/interfaces/macos/Resettable.swiftinterface
+++ b/.agents/interfaces/macos/Resettable.swiftinterface
@@ -1,7 +1,7 @@
 // swift-interface-format-version: 1.0
-// swift-compiler-version: Apple Swift version 6.4 (swiftlang-6.4.0.25.4 clang-2100.3.25.1)
-// swift-module-flags: -target arm64-apple-macos12.0 -enable-objc-interop -language-mode 6 -O -enable-experimental-feature DebugDescriptionMacro -module-name Resettable -package-name swift_resettable
-// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.4
+// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)
+// swift-module-flags: -target arm64-apple-macosx10.15 -enable-objc-interop -swift-version 6 -O -module-name Resettable -package-name swift_resettable
+// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3
 import KeyPathMapping
 import KeyPathsExtensions
 import Swift
@@ -9,30 +9,30 @@ import SwiftMarkerProtocols
 import _Concurrency
 import _StringProcessing
 import _SwiftConcurrencyShims
-extension Resettable::Resettable where Base : Swift::Collection {
-  public var collection: Resettable::Resettable<Base>.Resettable::WritableKeyPathContainer<Base> {
+extension Resettable.Resettable where Base : Swift.Collection {
+  public var collection: Resettable.Resettable<Base>.WritableKeyPathContainer<Base> {
     get
   }
 }
-extension Resettable::Resettable.Resettable::WritableKeyPathContainer where Value : Swift::Collection {
+extension Resettable.Resettable.WritableKeyPathContainer where Value : Swift.Collection {
   @discardableResult
-  public func swapAt<T>(_ idx1: Swift::Array<T>.Swift::Index, _ idx2: Swift::Array<T>.Swift::Index, operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default) -> Resettable::Resettable<Base> where Value == [T]
+  public func swapAt<T>(_ idx1: Swift.Array<T>.Index, _ idx2: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
   @discardableResult
-  public func remove<T>(at idx: Swift::Array<T>.Swift::Index, operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default) -> Resettable::Resettable<Base> where Value == [T]
+  public func remove<T>(at idx: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
   @discardableResult
-  public func insert<T>(_ element: Swift::Array<T>.Swift::Element, at idx: Swift::Array<T>.Swift::Index, operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default) -> Resettable::Resettable<Base> where Value == [T]
+  public func insert<T>(_ element: Swift.Array<T>.Element, at idx: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
   @discardableResult
-  public func append<T>(_ element: Swift::Array<T>.Swift::Element, operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default) -> Resettable::Resettable<Base> where Value == [T]
+  public func append<T>(_ element: Swift.Array<T>.Element, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
 }
-extension Resettable::Resettable {
+extension Resettable.Resettable {
   public enum OperationBehavior {
     case `default`
     case amend
     case insert
     case inject
-    @_semantics("derived_enum_equals") @_implements(Swift::Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Resettable::Resettable<Base>.Resettable::OperationBehavior, _ b: Resettable::Resettable<Base>.Resettable::OperationBehavior) -> Swift::Bool
-    public func hash(into hasher: inout Swift::Hasher)
-    public var hashValue: Swift::Int {
+    @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Resettable.Resettable<Base>.OperationBehavior, _ b: Resettable.Resettable<Base>.OperationBehavior) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
       get
     }
   }
@@ -47,34 +47,34 @@ extension Resettable::Resettable {
   @inlinable public var wrappedValue: Base {
     _read { yield base }
   }
-  @inlinable public var projectedValue: Resettable::Resettable<Base> {
+  @inlinable public var projectedValue: Resettable.Resettable<Base> {
     get { self }
   }
   @discardableResult
-  public func undo() -> Resettable::Resettable<Base>
+  public func undo() -> Resettable.Resettable<Base>
   @discardableResult
-  public func redo() -> Resettable::Resettable<Base>
+  public func redo() -> Resettable.Resettable<Base>
   @discardableResult
-  @inlinable public func undo(_ count: Swift::Int) -> Resettable::Resettable<Base> {
+  @inlinable public func undo(_ count: Swift.Int) -> Resettable.Resettable<Base> {
 		for _ in 0..<count { undo() }
 		return self
 	}
   @discardableResult
-  @inlinable public func redo(_ count: Swift::Int) -> Resettable::Resettable<Base> {
+  @inlinable public func redo(_ count: Swift.Int) -> Resettable.Resettable<Base> {
 		for _ in 0..<count { redo() }
 		return self
 	}
   @discardableResult
-  public func undoAll() -> Resettable::Resettable<Base>
+  public func undoAll() -> Resettable.Resettable<Base>
   @discardableResult
-  public func redoAll() -> Resettable::Resettable<Base>
+  public func redoAll() -> Resettable.Resettable<Base>
   @discardableResult
-  public func _modify<Value>(operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default, _ keyPath: Swift::WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift::Void) -> Resettable::Resettable<Base>
+  public func _modify<Value>(operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ keyPath: Swift.WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base>
   @discardableResult
-  public func _modify<Value>(operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default, _ keyPath: Swift::WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift::Void, undo: @escaping (inout Value) -> Swift::Void) -> Resettable::Resettable<Base>
+  public func _modify<Value>(operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ keyPath: Swift.WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift.Void, undo: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base>
   @discardableResult
-  public func _modify(operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default, using action: @escaping (inout Base) -> Swift::Void, undo: @escaping (inout Base) -> Swift::Void) -> Resettable::Resettable<Base>
-  @inlinable public subscript<Value>(dynamicMember keyPath: Swift::WritableKeyPath<Base, Value>) -> Resettable::Resettable<Base>.Resettable::WritableKeyPathContainer<Value> {
+  public func _modify(operation: Resettable.Resettable<Base>.OperationBehavior = .default, using action: @escaping (inout Base) -> Swift.Void, undo: @escaping (inout Base) -> Swift.Void) -> Resettable.Resettable<Base>
+  @inlinable public subscript<Value>(dynamicMember keyPath: Swift.WritableKeyPath<Base, Value>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<Value> {
     get {
 		WritableKeyPathContainer(
 			resettable: self,
@@ -82,7 +82,7 @@ extension Resettable::Resettable {
 		)
 	}
   }
-  @inlinable public subscript<Value>(dynamicMember keyPath: Swift::KeyPath<Base, Value>) -> Resettable::Resettable<Base>.Resettable::KeyPathContainer<Value> {
+  @inlinable public subscript<Value>(dynamicMember keyPath: Swift.KeyPath<Base, Value>) -> Resettable.Resettable<Base>.KeyPathContainer<Value> {
     get {
 		KeyPathContainer(
 			resettable: self,
@@ -92,15 +92,15 @@ extension Resettable::Resettable {
   }
   @objc deinit
 }
-extension Resettable::Resettable {
+extension Resettable.Resettable {
   @dynamicMemberLookup public struct KeyPathContainer<Value> {
     @usableFromInline
-    internal let resettable: Resettable::Resettable<Base>
+    internal let resettable: Resettable.Resettable<Base>
     @usableFromInline
-    internal let keyPath: Swift::KeyPath<Base, Value>
+    internal let keyPath: Swift.KeyPath<Base, Value>
     @usableFromInline
-    internal init(resettable: Resettable::Resettable<Base>, keyPath: Swift::KeyPath<Base, Value>)
-    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift::ReferenceWritableKeyPath<Value, LocalValue>) -> Resettable::Resettable<Base>.Resettable::WritableKeyPathContainer<LocalValue> {
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.KeyPath<Base, Value>)
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.ReferenceWritableKeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<LocalValue> {
       get {
 			WritableKeyPathContainer<LocalValue>(
 				resettable: resettable,
@@ -108,7 +108,7 @@ extension Resettable::Resettable {
 			)
 		}
     }
-    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift::KeyPath<Value, LocalValue>) -> Resettable::Resettable<Base>.Resettable::KeyPathContainer<LocalValue> {
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.KeyPathContainer<LocalValue> {
       get {
 			KeyPathContainer<LocalValue>(
 				resettable: resettable,
@@ -119,17 +119,17 @@ extension Resettable::Resettable {
   }
   @dynamicMemberLookup public struct WritableKeyPathContainer<Value> {
     @usableFromInline
-    internal let resettable: Resettable::Resettable<Base>
+    internal let resettable: Resettable.Resettable<Base>
     @usableFromInline
-    internal let keyPath: Swift::WritableKeyPath<Base, Value>
+    internal let keyPath: Swift.WritableKeyPath<Base, Value>
     @usableFromInline
-    internal init(resettable: Resettable::Resettable<Base>, keyPath: Swift::WritableKeyPath<Base, Value>)
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.WritableKeyPath<Base, Value>)
     @discardableResult
-    @inlinable public func callAsFunction(_ value: Value, operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default) -> Resettable::Resettable<Base> {
+    @inlinable public func callAsFunction(_ value: Value, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> {
 			return self.callAsFunction(operation) { $0 = value }
 		}
     @discardableResult
-    @inlinable public func callAsFunction(_ operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift::Void) -> Resettable::Resettable<Base> {
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base> {
 			return resettable._modify(
 				operation: operation,
 				keyPath,
@@ -137,7 +137,7 @@ extension Resettable::Resettable {
 			)
 		}
     @discardableResult
-    @inlinable public func callAsFunction(_ operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift::Void, undo: @escaping (inout Value) -> Swift::Void) -> Resettable::Resettable<Base> {
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift.Void, undo: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base> {
 			return resettable._modify(
 				operation: operation,
 				keyPath,
@@ -145,7 +145,7 @@ extension Resettable::Resettable {
 				undo: undo
 			)
 		}
-    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift::WritableKeyPath<Value, LocalValue>) -> Resettable::Resettable<Base>.Resettable::WritableKeyPathContainer<LocalValue> {
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.WritableKeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<LocalValue> {
       get {
 			WritableKeyPathContainer<LocalValue>(
 				resettable: resettable,
@@ -153,7 +153,7 @@ extension Resettable::Resettable {
 			)
 		}
     }
-    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift::KeyPath<Value, LocalValue>) -> Resettable::Resettable<Base>.Resettable::KeyPathContainer<LocalValue> {
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.KeyPathContainer<LocalValue> {
       get {
 			KeyPathContainer<LocalValue>(
 				resettable: resettable,
@@ -165,12 +165,12 @@ extension Resettable::Resettable {
   @dynamicMemberLookup public struct IfLetKeyPathContainer<Wrapped> {
     public typealias Value = Wrapped?
     @usableFromInline
-    internal let resettable: Resettable::Resettable<Base>
+    internal let resettable: Resettable.Resettable<Base>
     @usableFromInline
-    internal let keyPath: Swift::KeyPath<Base, Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<Wrapped>.Resettable::Value>
+    internal let keyPath: Swift.KeyPath<Base, Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>.Value>
     @usableFromInline
-    internal init(resettable: Resettable::Resettable<Base>, keyPath: Swift::KeyPath<Base, Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<Wrapped>.Resettable::Value>)
-    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift::ReferenceWritableKeyPath<Wrapped, LocalValue>) -> Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<LocalValue> {
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.KeyPath<Base, Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>.Value>)
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.ReferenceWritableKeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalValue> {
       get {
 			IfLetWritableKeyPathContainer<LocalValue>(
 				resettable: resettable,
@@ -178,7 +178,7 @@ extension Resettable::Resettable {
 			)
 		}
     }
-    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift::KeyPath<Wrapped, LocalValue>) -> Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<LocalValue> {
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalValue> {
       get {
 			IfLetKeyPathContainer<LocalValue>(
 				resettable: resettable,
@@ -190,18 +190,18 @@ extension Resettable::Resettable {
   @dynamicMemberLookup public struct IfLetWritableKeyPathContainer<Wrapped> {
     public typealias Value = Wrapped?
     @usableFromInline
-    internal let resettable: Resettable::Resettable<Base>
+    internal let resettable: Resettable.Resettable<Base>
     @usableFromInline
-    internal let keyPath: Swift::WritableKeyPath<Base, Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<Wrapped>.Resettable::Value>
+    internal let keyPath: Swift.WritableKeyPath<Base, Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>.Value>
     @usableFromInline
-    internal init(resettable: Resettable::Resettable<Base>, keyPath: Swift::WritableKeyPath<Base, Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<Wrapped>.Resettable::Value>)
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.WritableKeyPath<Base, Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>.Value>)
     @discardableResult
-    @inlinable public func callAsFunction(_ value: Wrapped, operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default) -> Resettable::Resettable<Base> {
+    @inlinable public func callAsFunction(_ value: Wrapped, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> {
 			guard resettable.wrappedValue[keyPath: keyPath] != nil else { return resettable }
 			return self.callAsFunction(operation) { $0 = value }
 		}
     @discardableResult
-    @inlinable public func callAsFunction(_ operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift::Void) -> Resettable::Resettable<Base> {
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift.Void) -> Resettable.Resettable<Base> {
 			guard let value = resettable.wrappedValue[keyPath: keyPath] else { return resettable }
 			return resettable._modify(
 				operation: operation,
@@ -210,7 +210,7 @@ extension Resettable::Resettable {
 			)
 		}
     @discardableResult
-    @inlinable public func callAsFunction(_ operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift::Void, undo: @escaping (inout Wrapped) -> Swift::Void) -> Resettable::Resettable<Base> {
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift.Void, undo: @escaping (inout Wrapped) -> Swift.Void) -> Resettable.Resettable<Base> {
 			guard let value = resettable.wrappedValue[keyPath: keyPath] else { return resettable }
 			return resettable._modify(
 				operation: operation,
@@ -219,7 +219,7 @@ extension Resettable::Resettable {
 				undo: undo
 			)
 		}
-    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift::WritableKeyPath<Wrapped, LocalValue>) -> Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<LocalValue> {
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.WritableKeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalValue> {
       get {
 			IfLetWritableKeyPathContainer<LocalValue>(
 				resettable: resettable,
@@ -227,7 +227,7 @@ extension Resettable::Resettable {
 			)
 		}
     }
-    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift::KeyPath<Wrapped, LocalValue>) -> Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<LocalValue> {
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalValue> {
       get {
 			IfLetKeyPathContainer<LocalValue>(
 				resettable: resettable,
@@ -237,60 +237,60 @@ extension Resettable::Resettable {
     }
   }
 }
-extension Resettable::Resettable where Base : SwiftMarkerProtocols::_OptionalProtocol {
-  public var ifLet: Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<Base.Wrapped> {
+extension Resettable.Resettable where Base : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Base.Wrapped> {
     get
   }
 }
-extension Resettable::Resettable {
-  public func ifLet<Wrapped>(_ keyPath: Swift::WritableKeyPath<Base, Wrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<Wrapped>
-  public func ifLet<Wrapped>(_ keyPath: Swift::KeyPath<Base, Wrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<Wrapped>
+extension Resettable.Resettable {
+  public func ifLet<Wrapped>(_ keyPath: Swift.WritableKeyPath<Base, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Base, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
 }
-extension Resettable::Resettable.Resettable::WritableKeyPathContainer where Value : SwiftMarkerProtocols::_OptionalProtocol {
-  public var ifLet: Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<Value.Wrapped> {
+extension Resettable.Resettable.WritableKeyPathContainer where Value : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Value.Wrapped> {
     get
   }
-  public func ifNil(_ value: Value, operation: Resettable::Resettable<Base>.Resettable::OperationBehavior = .default) -> Resettable::Resettable<Base>
+  public func ifNil(_ value: Value, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base>
 }
-extension Resettable::Resettable.Resettable::KeyPathContainer where Value : SwiftMarkerProtocols::_OptionalProtocol {
-  public var ifLet: Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<Value.Wrapped> {
+extension Resettable.Resettable.KeyPathContainer where Value : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetKeyPathContainer<Value.Wrapped> {
     get
   }
 }
-extension Resettable::Resettable.Resettable::IfLetWritableKeyPathContainer where Wrapped : SwiftMarkerProtocols::_OptionalProtocol {
-  public var ifLet: Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<Wrapped.Wrapped> {
+extension Resettable.Resettable.IfLetWritableKeyPathContainer where Wrapped : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped.Wrapped> {
     get
   }
 }
-extension Resettable::Resettable.Resettable::IfLetKeyPathContainer where Wrapped : SwiftMarkerProtocols::_OptionalProtocol {
-  public var ifLet: Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<Wrapped.Wrapped> {
+extension Resettable.Resettable.IfLetKeyPathContainer where Wrapped : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped.Wrapped> {
     get
   }
 }
-extension Resettable::Resettable.Resettable::WritableKeyPathContainer {
-  public func ifLet<Wrapped>(_ keyPath: Swift::WritableKeyPath<Value, Wrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<Wrapped>
-  public func ifLet<Wrapped>(_ keyPath: Swift::KeyPath<Value, Wrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<Wrapped>
+extension Resettable.Resettable.WritableKeyPathContainer {
+  public func ifLet<Wrapped>(_ keyPath: Swift.WritableKeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
 }
-extension Resettable::Resettable.Resettable::KeyPathContainer {
-  public func ifLet<Wrapped>(_ keyPath: Swift::ReferenceWritableKeyPath<Value, Wrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<Wrapped>
-  public func ifLet<Wrapped>(_ keyPath: Swift::KeyPath<Value, Wrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<Wrapped>
+extension Resettable.Resettable.KeyPathContainer {
+  public func ifLet<Wrapped>(_ keyPath: Swift.ReferenceWritableKeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
 }
-extension Resettable::Resettable.Resettable::IfLetWritableKeyPathContainer {
-  public func ifLet<LocalWrapped>(_ keyPath: Swift::WritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<LocalWrapped>
-  public func ifLet<LocalWrapped>(_ keyPath: Swift::KeyPath<Wrapped, LocalWrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<LocalWrapped>
+extension Resettable.Resettable.IfLetWritableKeyPathContainer {
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.WritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalWrapped>
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.KeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalWrapped>
 }
-extension Resettable::Resettable.Resettable::IfLetKeyPathContainer {
-  public func ifLet<LocalWrapped>(_ keyPath: Swift::ReferenceWritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetWritableKeyPathContainer<LocalWrapped>
-  public func ifLet<LocalWrapped>(_ keyPath: Swift::KeyPath<Wrapped, LocalWrapped?>) -> Resettable::Resettable<Base>.Resettable::IfLetKeyPathContainer<LocalWrapped>
+extension Resettable.Resettable.IfLetKeyPathContainer {
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.ReferenceWritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalWrapped>
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.KeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalWrapped>
 }
 @usableFromInline
 @discardableResult
-internal func modification<T>(of object: T, with action: (inout T) -> Swift::Void) -> T
-extension Resettable::Resettable : Swift::Identifiable where Base : Swift::Identifiable {
+internal func modification<T>(of object: T, with action: (inout T) -> Swift.Void) -> T
+extension Resettable.Resettable : Swift.Identifiable where Base : Swift.Identifiable {
   @inlinable public var id: Base.ID {
     get { wrappedValue.id }
   }
   public typealias ID = Base.ID
 }
-extension Resettable::Resettable.Resettable::OperationBehavior : Swift::Equatable {}
-extension Resettable::Resettable.Resettable::OperationBehavior : Swift::Hashable {}
+extension Resettable.Resettable.OperationBehavior : Swift.Equatable {}
+extension Resettable.Resettable.OperationBehavior : Swift.Hashable {}
diff --git a/.agents/interfaces/macos/_ResettableDebugging.swiftinterface b/.agents/interfaces/macos/_ResettableDebugging.swiftinterface
index 279645e..287e094 100644
--- a/.agents/interfaces/macos/_ResettableDebugging.swiftinterface
+++ b/.agents/interfaces/macos/_ResettableDebugging.swiftinterface
@@ -1,29 +1,29 @@
 // swift-interface-format-version: 1.0
-// swift-compiler-version: Apple Swift version 6.4 (swiftlang-6.4.0.25.4 clang-2100.3.25.1)
-// swift-module-flags: -target arm64-apple-macos12.0 -enable-objc-interop -language-mode 6 -O -enable-experimental-feature DebugDescriptionMacro -module-name _ResettableDebugging -package-name swift_resettable
-// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.4
+// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)
+// swift-module-flags: -target arm64-apple-macosx10.15 -enable-objc-interop -swift-version 6 -O -module-name _ResettableDebugging -package-name swift_resettable
+// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3
 import CustomDump
 @_exported import Resettable
 import Swift
 import _Concurrency
 import _StringProcessing
 import _SwiftConcurrencyShims
-extension Resettable::Resettable {
+extension Resettable.Resettable {
   @available(*, deprecated, message: "Might be removed due to lack of Value type constraint, which makes the behavior unstable, consider re-implementing this feature locally if needed")
   public struct ValuesDump {
     @usableFromInline
-    internal init(items: [Resettable::Resettable<Base>.Resettable::Object], currentIndex: Swift::Int)
-    public let items: [Resettable::Resettable<Base>.Resettable::Object]
-    public let currentIndex: Swift::Int
+    internal init(items: [Resettable.Resettable<Base>.Object], currentIndex: Swift.Int)
+    public let items: [Resettable.Resettable<Base>.Object]
+    public let currentIndex: Swift.Int
   }
 }
-extension Resettable::Resettable {
+extension Resettable.Resettable {
   @available(*, deprecated, message: "Might be removed due to lack of Value type constraint, which makes the behavior unstable, consider re-implementing this feature locally if needed")
-  public func valuesDump() -> Resettable::Resettable<Base>._ResettableDebugging::ValuesDump
-  @inlinable public func dump() -> Swift::String {
+  public func valuesDump() -> Resettable.Resettable<Base>.ValuesDump
+  @inlinable public func dump() -> Swift.String {
 		var buffer = ""
 		self.dump(to: &buffer)
 		return buffer
 	}
-  public func dump<TargetStream>(to stream: inout TargetStream) where TargetStream : Swift::TextOutputStream
+  public func dump<TargetStream>(to stream: inout TargetStream) where TargetStream : Swift.TextOutputStream
 }
diff --git a/.agents/interfaces/tvos/Resettable.swiftinterface b/.agents/interfaces/tvos/Resettable.swiftinterface
new file mode 100644
index 0000000..04375ec
--- /dev/null
+++ b/.agents/interfaces/tvos/Resettable.swiftinterface
@@ -0,0 +1,296 @@
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)
+// swift-module-flags: -target arm64-apple-tvos13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name Resettable -package-name swift_resettable
+// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3
+import KeyPathMapping
+import KeyPathsExtensions
+import Swift
+import SwiftMarkerProtocols
+import _Concurrency
+import _StringProcessing
+import _SwiftConcurrencyShims
+extension Resettable.Resettable where Base : Swift.Collection {
+  public var collection: Resettable.Resettable<Base>.WritableKeyPathContainer<Base> {
+    get
+  }
+}
+extension Resettable.Resettable.WritableKeyPathContainer where Value : Swift.Collection {
+  @discardableResult
+  public func swapAt<T>(_ idx1: Swift.Array<T>.Index, _ idx2: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+  @discardableResult
+  public func remove<T>(at idx: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+  @discardableResult
+  public func insert<T>(_ element: Swift.Array<T>.Element, at idx: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+  @discardableResult
+  public func append<T>(_ element: Swift.Array<T>.Element, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+}
+extension Resettable.Resettable {
+  public enum OperationBehavior {
+    case `default`
+    case amend
+    case insert
+    case inject
+    @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Resettable.Resettable<Base>.OperationBehavior, _ b: Resettable.Resettable<Base>.OperationBehavior) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+}
+@propertyWrapper @dynamicMemberLookup public class Resettable<Base> {
+  @available(*, deprecated, renamed: "Base")
+  public typealias Object = Base
+  convenience public init(wrappedValue: Base)
+  public init(_ base: Base)
+  @usableFromInline
+  internal var base: Base
+  @inlinable public var wrappedValue: Base {
+    _read { yield base }
+  }
+  @inlinable public var projectedValue: Resettable.Resettable<Base> {
+    get { self }
+  }
+  @discardableResult
+  public func undo() -> Resettable.Resettable<Base>
+  @discardableResult
+  public func redo() -> Resettable.Resettable<Base>
+  @discardableResult
+  @inlinable public func undo(_ count: Swift.Int) -> Resettable.Resettable<Base> {
+		for _ in 0..<count { undo() }
+		return self
+	}
+  @discardableResult
+  @inlinable public func redo(_ count: Swift.Int) -> Resettable.Resettable<Base> {
+		for _ in 0..<count { redo() }
+		return self
+	}
+  @discardableResult
+  public func undoAll() -> Resettable.Resettable<Base>
+  @discardableResult
+  public func redoAll() -> Resettable.Resettable<Base>
+  @discardableResult
+  public func _modify<Value>(operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ keyPath: Swift.WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base>
+  @discardableResult
+  public func _modify<Value>(operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ keyPath: Swift.WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift.Void, undo: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base>
+  @discardableResult
+  public func _modify(operation: Resettable.Resettable<Base>.OperationBehavior = .default, using action: @escaping (inout Base) -> Swift.Void, undo: @escaping (inout Base) -> Swift.Void) -> Resettable.Resettable<Base>
+  @inlinable public subscript<Value>(dynamicMember keyPath: Swift.WritableKeyPath<Base, Value>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<Value> {
+    get {
+		WritableKeyPathContainer(
+			resettable: self,
+			keyPath: keyPath
+		)
+	}
+  }
+  @inlinable public subscript<Value>(dynamicMember keyPath: Swift.KeyPath<Base, Value>) -> Resettable.Resettable<Base>.KeyPathContainer<Value> {
+    get {
+		KeyPathContainer(
+			resettable: self,
+			keyPath: keyPath
+		)
+	}
+  }
+  @objc deinit
+}
+extension Resettable.Resettable {
+  @dynamicMemberLookup public struct KeyPathContainer<Value> {
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.KeyPath<Base, Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.KeyPath<Base, Value>)
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.ReferenceWritableKeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<LocalValue> {
+      get {
+			WritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.KeyPathContainer<LocalValue> {
+      get {
+			KeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+  @dynamicMemberLookup public struct WritableKeyPathContainer<Value> {
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.WritableKeyPath<Base, Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.WritableKeyPath<Base, Value>)
+    @discardableResult
+    @inlinable public func callAsFunction(_ value: Value, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> {
+			return self.callAsFunction(operation) { $0 = value }
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base> {
+			return resettable._modify(
+				operation: operation,
+				keyPath,
+				using: action
+			)
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift.Void, undo: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base> {
+			return resettable._modify(
+				operation: operation,
+				keyPath,
+				using: action,
+				undo: undo
+			)
+		}
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.WritableKeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<LocalValue> {
+      get {
+			WritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.KeyPathContainer<LocalValue> {
+      get {
+			KeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+  @dynamicMemberLookup public struct IfLetKeyPathContainer<Wrapped> {
+    public typealias Value = Wrapped?
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.KeyPath<Base, Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>.Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.KeyPath<Base, Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>.Value>)
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.ReferenceWritableKeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalValue> {
+      get {
+			IfLetWritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalValue> {
+      get {
+			IfLetKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+  @dynamicMemberLookup public struct IfLetWritableKeyPathContainer<Wrapped> {
+    public typealias Value = Wrapped?
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.WritableKeyPath<Base, Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>.Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.WritableKeyPath<Base, Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>.Value>)
+    @discardableResult
+    @inlinable public func callAsFunction(_ value: Wrapped, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> {
+			guard resettable.wrappedValue[keyPath: keyPath] != nil else { return resettable }
+			return self.callAsFunction(operation) { $0 = value }
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift.Void) -> Resettable.Resettable<Base> {
+			guard let value = resettable.wrappedValue[keyPath: keyPath] else { return resettable }
+			return resettable._modify(
+				operation: operation,
+				keyPath.unwrapped(with: value),
+				using: action
+			)
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift.Void, undo: @escaping (inout Wrapped) -> Swift.Void) -> Resettable.Resettable<Base> {
+			guard let value = resettable.wrappedValue[keyPath: keyPath] else { return resettable }
+			return resettable._modify(
+				operation: operation,
+				keyPath.unwrapped(with: value),
+				using: action,
+				undo: undo
+			)
+		}
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.WritableKeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalValue> {
+      get {
+			IfLetWritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalValue> {
+      get {
+			IfLetKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+}
+extension Resettable.Resettable where Base : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Base.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable {
+  public func ifLet<Wrapped>(_ keyPath: Swift.WritableKeyPath<Base, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Base, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
+}
+extension Resettable.Resettable.WritableKeyPathContainer where Value : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Value.Wrapped> {
+    get
+  }
+  public func ifNil(_ value: Value, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base>
+}
+extension Resettable.Resettable.KeyPathContainer where Value : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetKeyPathContainer<Value.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable.IfLetWritableKeyPathContainer where Wrapped : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable.IfLetKeyPathContainer where Wrapped : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable.WritableKeyPathContainer {
+  public func ifLet<Wrapped>(_ keyPath: Swift.WritableKeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
+}
+extension Resettable.Resettable.KeyPathContainer {
+  public func ifLet<Wrapped>(_ keyPath: Swift.ReferenceWritableKeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
+}
+extension Resettable.Resettable.IfLetWritableKeyPathContainer {
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.WritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalWrapped>
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.KeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalWrapped>
+}
+extension Resettable.Resettable.IfLetKeyPathContainer {
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.ReferenceWritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalWrapped>
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.KeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalWrapped>
+}
+@usableFromInline
+@discardableResult
+internal func modification<T>(of object: T, with action: (inout T) -> Swift.Void) -> T
+extension Resettable.Resettable : Swift.Identifiable where Base : Swift.Identifiable {
+  @inlinable public var id: Base.ID {
+    get { wrappedValue.id }
+  }
+  public typealias ID = Base.ID
+}
+extension Resettable.Resettable.OperationBehavior : Swift.Equatable {}
+extension Resettable.Resettable.OperationBehavior : Swift.Hashable {}
diff --git a/.agents/interfaces/tvos/_ResettableDebugging.swiftinterface b/.agents/interfaces/tvos/_ResettableDebugging.swiftinterface
new file mode 100644
index 0000000..cd4d7b5
--- /dev/null
+++ b/.agents/interfaces/tvos/_ResettableDebugging.swiftinterface
@@ -0,0 +1,29 @@
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)
+// swift-module-flags: -target arm64-apple-tvos13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name _ResettableDebugging -package-name swift_resettable
+// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3
+import CustomDump
+@_exported import Resettable
+import Swift
+import _Concurrency
+import _StringProcessing
+import _SwiftConcurrencyShims
+extension Resettable.Resettable {
+  @available(*, deprecated, message: "Might be removed due to lack of Value type constraint, which makes the behavior unstable, consider re-implementing this feature locally if needed")
+  public struct ValuesDump {
+    @usableFromInline
+    internal init(items: [Resettable.Resettable<Base>.Object], currentIndex: Swift.Int)
+    public let items: [Resettable.Resettable<Base>.Object]
+    public let currentIndex: Swift.Int
+  }
+}
+extension Resettable.Resettable {
+  @available(*, deprecated, message: "Might be removed due to lack of Value type constraint, which makes the behavior unstable, consider re-implementing this feature locally if needed")
+  public func valuesDump() -> Resettable.Resettable<Base>.ValuesDump
+  @inlinable public func dump() -> Swift.String {
+		var buffer = ""
+		self.dump(to: &buffer)
+		return buffer
+	}
+  public func dump<TargetStream>(to stream: inout TargetStream) where TargetStream : Swift.TextOutputStream
+}
diff --git a/.agents/interfaces/watchos/Resettable.swiftinterface b/.agents/interfaces/watchos/Resettable.swiftinterface
new file mode 100644
index 0000000..abd8496
--- /dev/null
+++ b/.agents/interfaces/watchos/Resettable.swiftinterface
@@ -0,0 +1,296 @@
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)
+// swift-module-flags: -target arm64-apple-watchos6.0-simulator -enable-objc-interop -swift-version 6 -O -module-name Resettable -package-name swift_resettable
+// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3
+import KeyPathMapping
+import KeyPathsExtensions
+import Swift
+import SwiftMarkerProtocols
+import _Concurrency
+import _StringProcessing
+import _SwiftConcurrencyShims
+extension Resettable.Resettable where Base : Swift.Collection {
+  public var collection: Resettable.Resettable<Base>.WritableKeyPathContainer<Base> {
+    get
+  }
+}
+extension Resettable.Resettable.WritableKeyPathContainer where Value : Swift.Collection {
+  @discardableResult
+  public func swapAt<T>(_ idx1: Swift.Array<T>.Index, _ idx2: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+  @discardableResult
+  public func remove<T>(at idx: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+  @discardableResult
+  public func insert<T>(_ element: Swift.Array<T>.Element, at idx: Swift.Array<T>.Index, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+  @discardableResult
+  public func append<T>(_ element: Swift.Array<T>.Element, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> where Value == [T]
+}
+extension Resettable.Resettable {
+  public enum OperationBehavior {
+    case `default`
+    case amend
+    case insert
+    case inject
+    @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Resettable.Resettable<Base>.OperationBehavior, _ b: Resettable.Resettable<Base>.OperationBehavior) -> Swift.Bool
+    public func hash(into hasher: inout Swift.Hasher)
+    public var hashValue: Swift.Int {
+      get
+    }
+  }
+}
+@propertyWrapper @dynamicMemberLookup public class Resettable<Base> {
+  @available(*, deprecated, renamed: "Base")
+  public typealias Object = Base
+  convenience public init(wrappedValue: Base)
+  public init(_ base: Base)
+  @usableFromInline
+  internal var base: Base
+  @inlinable public var wrappedValue: Base {
+    _read { yield base }
+  }
+  @inlinable public var projectedValue: Resettable.Resettable<Base> {
+    get { self }
+  }
+  @discardableResult
+  public func undo() -> Resettable.Resettable<Base>
+  @discardableResult
+  public func redo() -> Resettable.Resettable<Base>
+  @discardableResult
+  @inlinable public func undo(_ count: Swift.Int) -> Resettable.Resettable<Base> {
+		for _ in 0..<count { undo() }
+		return self
+	}
+  @discardableResult
+  @inlinable public func redo(_ count: Swift.Int) -> Resettable.Resettable<Base> {
+		for _ in 0..<count { redo() }
+		return self
+	}
+  @discardableResult
+  public func undoAll() -> Resettable.Resettable<Base>
+  @discardableResult
+  public func redoAll() -> Resettable.Resettable<Base>
+  @discardableResult
+  public func _modify<Value>(operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ keyPath: Swift.WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base>
+  @discardableResult
+  public func _modify<Value>(operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ keyPath: Swift.WritableKeyPath<Base, Value>, using action: @escaping (inout Value) -> Swift.Void, undo: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base>
+  @discardableResult
+  public func _modify(operation: Resettable.Resettable<Base>.OperationBehavior = .default, using action: @escaping (inout Base) -> Swift.Void, undo: @escaping (inout Base) -> Swift.Void) -> Resettable.Resettable<Base>
+  @inlinable public subscript<Value>(dynamicMember keyPath: Swift.WritableKeyPath<Base, Value>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<Value> {
+    get {
+		WritableKeyPathContainer(
+			resettable: self,
+			keyPath: keyPath
+		)
+	}
+  }
+  @inlinable public subscript<Value>(dynamicMember keyPath: Swift.KeyPath<Base, Value>) -> Resettable.Resettable<Base>.KeyPathContainer<Value> {
+    get {
+		KeyPathContainer(
+			resettable: self,
+			keyPath: keyPath
+		)
+	}
+  }
+  @objc deinit
+}
+extension Resettable.Resettable {
+  @dynamicMemberLookup public struct KeyPathContainer<Value> {
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.KeyPath<Base, Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.KeyPath<Base, Value>)
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.ReferenceWritableKeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<LocalValue> {
+      get {
+			WritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.KeyPathContainer<LocalValue> {
+      get {
+			KeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+  @dynamicMemberLookup public struct WritableKeyPathContainer<Value> {
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.WritableKeyPath<Base, Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.WritableKeyPath<Base, Value>)
+    @discardableResult
+    @inlinable public func callAsFunction(_ value: Value, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> {
+			return self.callAsFunction(operation) { $0 = value }
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base> {
+			return resettable._modify(
+				operation: operation,
+				keyPath,
+				using: action
+			)
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Value) -> Swift.Void, undo: @escaping (inout Value) -> Swift.Void) -> Resettable.Resettable<Base> {
+			return resettable._modify(
+				operation: operation,
+				keyPath,
+				using: action,
+				undo: undo
+			)
+		}
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.WritableKeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.WritableKeyPathContainer<LocalValue> {
+      get {
+			WritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Value, LocalValue>) -> Resettable.Resettable<Base>.KeyPathContainer<LocalValue> {
+      get {
+			KeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+  @dynamicMemberLookup public struct IfLetKeyPathContainer<Wrapped> {
+    public typealias Value = Wrapped?
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.KeyPath<Base, Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>.Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.KeyPath<Base, Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>.Value>)
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.ReferenceWritableKeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalValue> {
+      get {
+			IfLetWritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalValue> {
+      get {
+			IfLetKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+  @dynamicMemberLookup public struct IfLetWritableKeyPathContainer<Wrapped> {
+    public typealias Value = Wrapped?
+    @usableFromInline
+    internal let resettable: Resettable.Resettable<Base>
+    @usableFromInline
+    internal let keyPath: Swift.WritableKeyPath<Base, Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>.Value>
+    @usableFromInline
+    internal init(resettable: Resettable.Resettable<Base>, keyPath: Swift.WritableKeyPath<Base, Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>.Value>)
+    @discardableResult
+    @inlinable public func callAsFunction(_ value: Wrapped, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base> {
+			guard resettable.wrappedValue[keyPath: keyPath] != nil else { return resettable }
+			return self.callAsFunction(operation) { $0 = value }
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift.Void) -> Resettable.Resettable<Base> {
+			guard let value = resettable.wrappedValue[keyPath: keyPath] else { return resettable }
+			return resettable._modify(
+				operation: operation,
+				keyPath.unwrapped(with: value),
+				using: action
+			)
+		}
+    @discardableResult
+    @inlinable public func callAsFunction(_ operation: Resettable.Resettable<Base>.OperationBehavior = .default, _ action: @escaping (inout Wrapped) -> Swift.Void, undo: @escaping (inout Wrapped) -> Swift.Void) -> Resettable.Resettable<Base> {
+			guard let value = resettable.wrappedValue[keyPath: keyPath] else { return resettable }
+			return resettable._modify(
+				operation: operation,
+				keyPath.unwrapped(with: value),
+				using: action,
+				undo: undo
+			)
+		}
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.WritableKeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalValue> {
+      get {
+			IfLetWritableKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+    @inlinable public subscript<LocalValue>(dynamicMember keyPath: Swift.KeyPath<Wrapped, LocalValue>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalValue> {
+      get {
+			IfLetKeyPathContainer<LocalValue>(
+				resettable: resettable,
+				keyPath: self.keyPath.appending(path: keyPath)
+			)
+		}
+    }
+  }
+}
+extension Resettable.Resettable where Base : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Base.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable {
+  public func ifLet<Wrapped>(_ keyPath: Swift.WritableKeyPath<Base, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Base, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
+}
+extension Resettable.Resettable.WritableKeyPathContainer where Value : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Value.Wrapped> {
+    get
+  }
+  public func ifNil(_ value: Value, operation: Resettable.Resettable<Base>.OperationBehavior = .default) -> Resettable.Resettable<Base>
+}
+extension Resettable.Resettable.KeyPathContainer where Value : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetKeyPathContainer<Value.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable.IfLetWritableKeyPathContainer where Wrapped : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable.IfLetKeyPathContainer where Wrapped : SwiftMarkerProtocols._OptionalProtocol {
+  public var ifLet: Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped.Wrapped> {
+    get
+  }
+}
+extension Resettable.Resettable.WritableKeyPathContainer {
+  public func ifLet<Wrapped>(_ keyPath: Swift.WritableKeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
+}
+extension Resettable.Resettable.KeyPathContainer {
+  public func ifLet<Wrapped>(_ keyPath: Swift.ReferenceWritableKeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<Wrapped>
+  public func ifLet<Wrapped>(_ keyPath: Swift.KeyPath<Value, Wrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<Wrapped>
+}
+extension Resettable.Resettable.IfLetWritableKeyPathContainer {
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.WritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalWrapped>
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.KeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalWrapped>
+}
+extension Resettable.Resettable.IfLetKeyPathContainer {
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.ReferenceWritableKeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetWritableKeyPathContainer<LocalWrapped>
+  public func ifLet<LocalWrapped>(_ keyPath: Swift.KeyPath<Wrapped, LocalWrapped?>) -> Resettable.Resettable<Base>.IfLetKeyPathContainer<LocalWrapped>
+}
+@usableFromInline
+@discardableResult
+internal func modification<T>(of object: T, with action: (inout T) -> Swift.Void) -> T
+extension Resettable.Resettable : Swift.Identifiable where Base : Swift.Identifiable {
+  @inlinable public var id: Base.ID {
+    get { wrappedValue.id }
+  }
+  public typealias ID = Base.ID
+}
+extension Resettable.Resettable.OperationBehavior : Swift.Equatable {}
+extension Resettable.Resettable.OperationBehavior : Swift.Hashable {}
diff --git a/.agents/interfaces/watchos/_ResettableDebugging.swiftinterface b/.agents/interfaces/watchos/_ResettableDebugging.swiftinterface
new file mode 100644
index 0000000..58b6bbb
--- /dev/null
+++ b/.agents/interfaces/watchos/_ResettableDebugging.swiftinterface
@@ -0,0 +1,29 @@
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)
+// swift-module-flags: -target arm64-apple-watchos6.0-simulator -enable-objc-interop -swift-version 6 -O -module-name _ResettableDebugging -package-name swift_resettable
+// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3
+import CustomDump
+@_exported import Resettable
+import Swift
+import _Concurrency
+import _StringProcessing
+import _SwiftConcurrencyShims
+extension Resettable.Resettable {
+  @available(*, deprecated, message: "Might be removed due to lack of Value type constraint, which makes the behavior unstable, consider re-implementing this feature locally if needed")
+  public struct ValuesDump {
+    @usableFromInline
+    internal init(items: [Resettable.Resettable<Base>.Object], currentIndex: Swift.Int)
+    public let items: [Resettable.Resettable<Base>.Object]
+    public let currentIndex: Swift.Int
+  }
+}
+extension Resettable.Resettable {
+  @available(*, deprecated, message: "Might be removed due to lack of Value type constraint, which makes the behavior unstable, consider re-implementing this feature locally if needed")
+  public func valuesDump() -> Resettable.Resettable<Base>.ValuesDump
+  @inlinable public func dump() -> Swift.String {
+		var buffer = ""
+		self.dump(to: &buffer)
+		return buffer
+	}
+  public func dump<TargetStream>(to stream: inout TargetStream) where TargetStream : Swift.TextOutputStream
+}