Added list of changes over original implementation

Author: lukaskubanek

README-legacy.md

@@ -58,36 +58,6 @@ InterposeKit can hook classes and object. Class hooking is similar to swizzling,
 
 Caveat: Hooking will fail with an error if the object uses KVO. The KVO machinery is fragile and it's to easy to cause a crash. Using KVO after a hook was created is supported and will not cause issues.
 
-## Various ways to define the signature
-
-Next to using  `methodSignature` and `hookSignature`, following variants to define the signature are also possible:
-
-### methodSignature + casted block
-```
-let interposer = try Interpose(testObj) {
-    try $0.hook(
-        #selector(TestClass.sayHi),
-        methodSignature: (@convention(c) (AnyObject, Selector) -> String).self) { store in { `self` in
-            let string = store.original(`self`, store.selector)
-            return string + testString
-            } as @convention(block) (AnyObject) -> String }
-}
-```
-
-### Define type via store object
-```
-// Functions need to be `@objc dynamic` to be hookable.
-let interposer = try Interpose(testObj) {
-    try $0.hook(#selector(TestClass.returnInt)) { (store: TypedHook<@convention(c) (AnyObject, Selector) -> Int, @convention(block) (AnyObject) -> Int>) in {
-
-        // You're free to skip calling the original implementation.
-        let int = store.original($0, store.selector)
-        return int + returnIntOverrideOffset
-        }
-    }
-}
-```
-
 ## FAQ
 
 ### Why didn't you call it Interpose? "Kit" feels so old-school.

README.md

@@ -26,9 +26,36 @@ This is a continuation and modernization of [Peter Steinberger’s original impl
 - arm64 and x86_64 architectures
 - Examples: instance method on class, class method on class, object  
 
-## Changes from [Original Implementation](https://github.com/steipete/InterposeKit)
+## What’s Changed
 
-- ...
+Compared to the [original implementation](https://github.com/steipete/InterposeKit), this fork introduces several API and internal changes. Here is a summary of key differences with migration hints.
+
+### Environment
+
+- Switched the library to Swift Package Manager only. Carthage and CocoaPods support was removed.
+- Raised minimum Swift version to 5.9.
+- Limited to Apple platforms with arm64 and x86_64 architectures. Support for Linux was removed.
+
+### API Changes
+
+- Class hooks now support class methods.
+- Removed the builder-based API `Interpose(…) { … }` for applying hooks in batches. Each hook must now be individually prepared, applied, and reverted.
+- Signature types must now be specified via parameters, improving clarity and streamlining the API.
+- Renamed `hook(…)` methods to `applyHook(…)`.
+- Removed fluent-style `Hook` API, meaning that methods no longer return `self`.
+- Introduced `HookProxy`, which is passed into the hook builder. It still provides access to the original method implementation and selector, but hides irrelevant APIs like `revert()`.
+- Hook types now use composition instead of inheritance. The public `Hook` class delegates to internal strategies conforming to `HookStrategy`.
+- Object hooks now use a global counter instead of UUIDs for dynamic subclass names.
+- Dynamic subclasses created at runtime are now cleaned up when the last hook is reverted on an object.
+- Class hooks must now target the exact class that actually implements the method to ensure the revert functionality works correctly.
+- Added initial Swift 6 compatibility with some thread-safety checks. Most usage is still expected to be single-threaded, though.
+- Removed support for [delayed hooking](https://steipete.com/posts/mac-catalyst-crash-hunt/) (`whenAvailable(…)`) to keep the library laser-focused.
+- …and heavily refactored the Swift part of the codebase: cleaner use of Objective-C runtime APIs, a revamped `InterposeError` enum, and new supporting types like `HookScope` or `HookState`.
+
+### Fixes
+
+- Fixed a crash where `IKTAddSuperImplementationToClass` was stripped in release builds per [steipete/InterposeKit#29](https://github.com/steipete/InterposeKit#29) by using the fix from [steipete/InterposeKit#30](https://github.com/steipete/InterposeKit#30) submitted by @Thomvis, which replaces a call via dynamic library with a direct Swift call to `IKTSuperBuilder.addSuperInstanceMethod(to:selector:)`.
+- Fixed floating-point register handling on arm64 using the patch from [steipete/InterposeKit#37](https://github.com/steipete/InterposeKit#37) submitted by @ishutinvv, which resolves an issue affecting swizzled methods with `CGFloat` parameters or structs like `CGPoint` and `CGRect` due to floating-point registers not being restored in the correct order after the trampoline call.
 
 ## References