What's new in PencilKit

extension PKStroke : Identifiable {

    /// The unique identity of the stroke.
    @available(iOS 27.0, macOS 27.0, *)
    public var id: UUID

    /// A type representing the stable identity of the entity associated with
    /// an instance.
    @available(macOS 27.0, iOS 27.0, *)
    public typealias ID = UUID
}

extension PKStrokePath : Identifiable {

    /// Creates a stroke path with the specified cubic B-spline control points and a unique identifier.
    ///
    /// - Parameters:
    ///   - controlPoints: An array of control points for a cubic B-spline.
    ///   - creationDate: The start time of this path.
    ///   - id: The unique identity of the path.
    ///
    /// > Warning: Using multiple stroke paths with identical IDs but different control points
    /// will result in undefined rendering behavior. Ensure each stroke path has a unique identifier.
    @available(iOS 27.0, macOS 27.0, *)
    public init<T>(controlPoints: T, creationDate: Date, id: UUID) where T : Sequence, T.Element == PKStrokePoint

    /// The unique identity of the stroke path.
    ///
    /// > Warning: Using multiple stroke paths with identical IDs but different control points
    /// will result in undefined rendering behavior. Ensure each stroke path has a unique identifier.
    @available(iOS 27.0, macOS 27.0, *)
    public var id: UUID { get }

    /// A type representing the stable identity of the entity associated with
    /// an instance.
    @available(macOS 27.0, iOS 27.0, *)
    public typealias ID = UUID
}

final public actor PKStrokeRecognizer {

    /// A result containing the matched strokes and their bounds from a search query.
    public struct SearchResult {

        /// The identifiers of the strokes the result contains.
        public let strokes: Set<UUID>

        /// The bounds of the matched strokes in the coordinate space of their drawing.
        public let bounds: CGRect
    }

    /// The languages the recognizer supports.
    public static var supportedLanguages: Set<Locale.Language> { get }

    /// The version number of the recognition engine.
    ///
    /// If you persist results this recognizer returns, store this value alongside them
    /// and regenerate the results when running on an OS with a higher version number.
    public static var recognitionVersion: Int { get }

    /// Creates a recognizer with the specified preferred languages.
    ///
    /// Languages are respected on a best-effort basis. Factors such as feature support
    /// may affect which languages the recognizer uses.
    ///
    /// - Parameters:
    ///   - preferredLanguages: A list of languages to recognize ordered by descending priority.
    ///     Pass nil to use the system languages.
    ///     The system languages may be used if no listed language is available for recognition.
    public init(preferredLanguages: [Locale.Language]? = nil)

    /// The drawing the recognizer analyzes.
    final public var drawing: PKDrawing { get }

    /// Updates the drawing the recognizer analyzes.
    ///
    /// Recognition expects handwriting and strokes scaled as if written on standard paper
    /// sizes in points, such as US-letter or A4.
    /// - Parameter drawing: The new drawing.
    final public func updateDrawing(_ drawing: PKDrawing) async

    /// The languages the recognizer uses, ordered by descending priority.
    final public var languages: [Locale.Language] { get }

    /// A string suitable for indexing the drawing's recognized text in search systems such as Spotlight.
    ///
    /// The string may contain multiple concatenated candidate matches for recognized text in the drawing.
    final public var indexableContent: String? { get async }

    /// Returns the recognized text from the specified strokes in the drawing.
    /// - Parameter strokeIDs: The `id`s of the `PKStrokes` in `drawing` to analyze.
    ///   Pass `nil` to return the recognized text from the whole drawing.
    final public func recognizedText(strokeIDs: Set<UUID>? = nil) async -> String?

    /// Searches the drawing for strokes whose recognized text matches the query.
    /// - Parameters:
    ///   - query: The query string to search for.
    ///   - fullWordsOnly: Restricts matches to whole words only.
    ///   - caseMatchingOnly: Restricts matches to exact case.
    /// - Returns: An array of all results found.
    final public func search(_ query: String, fullWordsOnly: Bool = false, caseMatchingOnly: Bool = false) async -> [PKStrokeRecognizer.SearchResult]

    @objc deinit

    /// Retrieve the executor for this actor as an optimized, unowned
    /// reference.
    ///
    /// This property must always evaluate to the same executor for a
    /// given actor instance, and holding on to the actor must keep the
    /// executor alive.
    ///
    /// This property will be implicitly accessed when work needs to be
    /// scheduled onto this actor.  These accesses may be merged,
    /// eliminated, and rearranged with other work, and they may even
    /// be introduced when not strictly required.  Visible side effects
    /// are therefore strongly discouraged within this property.
    ///
    /// - SeeAlso: ``SerialExecutor``
    /// - SeeAlso: ``TaskExecutor``

Truncated.

public struct RenderState : Sendable, Codable, Equatable {

    /// The pre-transform position of the grain texture for strokes with a backing grain texture such as crayon.
    public var grainOffset: CGPoint?

    /// Creates a render state with the specified grain offset.
    ///
    /// - Parameter grainOffset: The grain texture offset. Defaults to nil.
    public init(grainOffset: CGPoint? = nil)

    /// Creates a `RenderState` from its Objective-C counterpart `PKStrokeRenderState`.
    ///
    /// - Parameter objcValue: The Objective-C `PKStrokeRenderState` to convert from.
    public init(_ objcValue: __PKStrokeRenderState)

    /// Returns the Objective-C `PKStrokeRenderState` representation of this render state.
    public func asObjCRenderState() -> __PKStrokeRenderState

    /// Creates a new instance by decoding from the given decoder.
    ///
    /// This initializer throws an error if reading from the decoder fails, or
    /// if the data read is corrupted or otherwise invalid.
    ///
    /// - Parameter decoder: The decoder to read data from.
    public init(from decoder: any Decoder) throws

    /// Encodes this value into the given encoder.
    ///
    /// If the value fails to encode anything, `encoder` will encode an empty
    /// keyed container in its place.
    ///
    /// This function throws an error if any values are invalid for the given
    /// encoder's format.
    ///
    /// - Parameter encoder: The encoder to write data to.
    public func encode(to encoder: any Encoder) throws

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (a: PKStroke.RenderState, b: PKStroke.RenderState) -> Bool
}

public struct ConvertedBezierPoint {

    /// The index of the point along the path.
    public let index: Int

    /// The total number of B-Spline control points in the path.
    public let pointCount: Int

    /// The location of the cubic uniform B-Spline control point.
    public let location: CGPoint

    /// The index of the Bézier segment the point originates from, not including `move to` elements.
    public let bezierSegmentIndex: Int
}