Refactoring of hook types

Package.swift

@@ -5,10 +5,10 @@ import PackageDescription
 let package = Package(
     name: "InterposeKit",
     platforms: [
-        .iOS(.v12),
-        .macOS(.v10_13),
-        .tvOS(.v12),
-        .watchOS(.v5)
+        .iOS(.v13),
+        .macOS(.v10_15),
+        .tvOS(.v13),
+        .watchOS(.v6)
     ],
     products: [
         .library(

Sources/InterposeKit/Deprecated/Hook+Deprecated.swift

@@ -0,0 +1,36 @@
+extension Hook {
+
+    @available(*, deprecated, renamed: "HookState", message: "Use top-level 'HookState'.")
+    public typealias State = HookState
+
+    @available(*, deprecated, message: "Use 'apply()' returning Void. The overload returning 'Self' has been removed.")
+    @_disfavoredOverload
+    public func apply() throws -> Self {
+        try self.apply()
+        return self
+    }
+
+    @available(*, deprecated, message: "Use 'revert()' returning Void. The overload returning 'Self' has been removed.")
+    @_disfavoredOverload
+    public func revert() throws -> Self {
+        try revert()
+        return self
+    }
+
+}
+
+extension HookState {
+
+    @available(*, deprecated, renamed: "pending", message: "Use 'pending' instead.")
+    public static var prepared: Self { .pending }
+
+    @available(*, deprecated, renamed: "active", message: "Use 'active' instead.")
+    public static var interposed: Self { .active }
+
+    @available(*, deprecated, renamed: "failed", message: """
+    Use 'failed' instead. The state no longer carries an associated error—handle errors  where
+    the hook is applied.
+    """)
+    public static var error: Self { .failed }
+
+}

Sources/InterposeKit/Deprecated/Interpose+Deprecated.swift

@@ -0,0 +1,114 @@
+import ObjectiveC
+
+extension Interpose {
+
+    @available(
+        *,
+         unavailable,
+         message: """
+        The builder-based initializer pattern is no longer supported. Use the static method \
+        'Interpose.applyHook(on:for:methodSignature:hookSignature:build:)' for immediate \
+        installation, or 'Interpose.prepareHook(…)' for manual control.
+        """
+    )
+    public init(
+        _ class: AnyClass,
+        builder: (Interpose) throws -> Void
+    ) throws {
+        Interpose.fail("Unavailable API")
+    }
+
+    @available(
+        *,
+         unavailable,
+         message: """
+        The builder-based initializer pattern is no longer supported. Use the static method \
+        'Interpose.applyHook(on:for:methodSignature:hookSignature:build:)' for immediate \
+        installation, or 'Interpose.prepareHook(…)' for manual control.
+        """
+    )
+    public init(
+        _ object: NSObject,
+        builder: ((Interpose) throws -> Void)? = nil
+    ) throws {
+        Interpose.fail("Unavailable API")
+    }
+
+    @available(
+        *,
+         unavailable,
+         message: """
+        Instance method 'hook(_:methodSignature:hookSignature:_:)' is no longer supported. \
+        Use 'Interpose.applyHook(on:for:methodSignature:hookSignature:build:)' instead.
+        """
+    )
+    @discardableResult
+    public func hook<MethodSignature, HookSignature>(
+        _ selectorName: String,
+        methodSignature: MethodSignature.Type,
+        hookSignature: HookSignature.Type,
+        _ build: @escaping HookBuilder<MethodSignature, HookSignature>
+    ) throws -> Hook {
+        Interpose.fail("Unavailable API")
+    }
+
+    @available(
+        *,
+         unavailable,
+         message: """
+        Instance method 'hook(_:methodSignature:hookSignature:_:)' is no longer supported. \
+        Use 'Interpose.applyHook(on:for:methodSignature:hookSignature:build:)' instead.
+        """
+    )
+    @discardableResult
+    public func hook<MethodSignature, HookSignature>(
+        _ selector: Selector,
+        methodSignature: MethodSignature.Type,
+        hookSignature: HookSignature.Type,
+        _ build: @escaping HookBuilder<MethodSignature, HookSignature>
+    ) throws -> Hook {
+        Interpose.fail("Unavailable API")
+    }
+
+    @available(
+        *,
+         unavailable,
+         message: """
+        Instance method 'prepareHook(_:methodSignature:hookSignature:_:)' is no longer supported. \
+        Use 'Interpose.prepareHook(on:for:methodSignature:hookSignature:build:)' instead.
+        """
+    )
+    public func prepareHook<MethodSignature, HookSignature>(
+        _ selector: Selector,
+        methodSignature: MethodSignature.Type,
+        hookSignature: HookSignature.Type,
+        _ build: @escaping HookBuilder<MethodSignature, HookSignature>
+    ) throws -> Hook {
+        Interpose.fail("Unavailable API")
+    }
+
+    @available(
+        *,
+         unavailable,
+         message: """
+        'apply()' is no longer supported. Use 'Interpose.applyHook(…)' to apply individual hooks \
+        directly using the new static API.
+        """
+    )
+    public func apply(_ builder: ((Interpose) throws -> Void)? = nil) throws -> Interpose {
+        Interpose.fail("Unavailable API")
+    }
+
+    @available(
+        *,
+         unavailable,
+         message: """
+        'revert()' is no longer supported. Keep a reference to each individual hook and call \
+        'revert()' on them directly.
+        """
+    )
+    public func revert(_ builder: ((Interpose) throws -> Void)? = nil) throws -> Interpose {
+        Interpose.fail("Unavailable API")
+    }
+
+}

Sources/InterposeKit/Deprecated/NSObject+Deprecated.swift

@@ -0,0 +1,47 @@
+import ObjectiveC
+
+extension NSObject {
+
+    @available(*, deprecated, renamed: "applyHook(for:methodSignature:hookSignature:build:)")
+    @discardableResult
+    public func hook<MethodSignature, HookSignature> (
+        _ selector: Selector,
+        methodSignature: MethodSignature.Type,
+        hookSignature: HookSignature.Type,
+        _ build: @escaping HookBuilder<MethodSignature, HookSignature>
+    ) throws -> Hook {
+        precondition(
+            !(self is AnyClass),
+            "There should not be a way to cast an NSObject to AnyClass."
+        )
+
+        return try self.applyHook(
+            for: selector,
+            methodSignature: methodSignature,
+            hookSignature: hookSignature,
+            build: build
+        )
+    }
+
+    @available(*, deprecated, message: """
+    Deprecated to avoid confusion: this hooks instance methods on classes, but can be mistaken \
+    for hooking class methods, which is not supported. Use `Interpose(Class.self)` with \
+    `prepareHook(…)` to make the intent explicit.
+    """)
+    @discardableResult
+    public class func hook<MethodSignature, HookSignature> (
+        _ selector: Selector,
+        methodSignature: MethodSignature.Type,
+        hookSignature: HookSignature.Type,
+        _ build: @escaping HookBuilder<MethodSignature, HookSignature>
+    ) throws -> Hook {
+        let hook = try Hook(
+            target: .class(self),
+            selector: selector,
+            build: build
+        )
+        try hook.apply()
+        return hook
+    }
+
+}