@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/CoreML/Model.swift

@@ -0,0 +1,269 @@
+// Core ML as a stand-in for the models Create ML makes from tables: linear
+// and logistic regressions, boosted trees and random forests, and the
+// pipelines around them. @swiftbrowser/cli compiles each `.mlmodel` of the
+// app's target into the class Xcode would generate, with the model's
+// specification embedded (packages/cli/src/coreml.ts); `MLModel` evaluates it
+// in Swift, so a prediction is a few multiplications, synchronous and exact.
+// Models of other kinds (neural networks, ML programs, Vision and Natural
+// Language models) are refused by the CLI, by name.
+
+import Foundation
+
+/// Where a model may run. Every value runs on the CPU here.
+public enum MLComputeUnits: Int, Sendable {
+    case cpuOnly = 0
+    case cpuAndGPU = 1
+    case all = 2
+    case cpuAndNeuralEngine = 3
+}
+
+public final class MLModelConfiguration: @unchecked Sendable {
+    public var computeUnits: MLComputeUnits = .all
+    public var allowLowPrecisionAccumulationOnGPU = false
+    public var modelDisplayName: String?
+
+    public init() {}
+}
+
+public final class MLPredictionOptions: @unchecked Sendable {
+    @available(*, deprecated, message: "Use MLModelConfiguration.computeUnits instead.")
+    public var usesCPUOnly = false
+    public var outputBackings: [String: Any] = [:]
+
+    public init() {}
+}
+
+/// Why loading or predicting failed. `code` matches Core ML's codes.
+public struct MLModelError: Error, CustomStringConvertible, LocalizedError, Sendable {
+    public enum Code: Int, Sendable {
+        case generic = 0
+        case featureType = 1
+        case io = 3
+        case customLayer = 4
+        case customModel = 5
+        case update = 6
+        case parameters = 7
+        case modelDecryptionKeyFetch = 8
+        case modelDecryption = 9
+        case modelCollection = 10
+        case predictionCancelled = 11
+    }
+
+    public let code: Code
+    public let message: String
+
+    public init(_ code: Code, _ message: String = "") {
+        self.code = code
+        self.message = message
+    }
+
+    public static var generic: Code { .generic }
+    public static var featureType: Code { .featureType }
+    public static var io: Code { .io }
+
+    public var errorDescription: String? { message }
+    public var description: String { "MLModelError(\(code)): \(message)" }
+}
+
+/// Keys of `MLModelDescription.metadata`.
+public struct MLModelMetadataKey: RawRepresentable, Hashable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+
+    public static let author = MLModelMetadataKey(rawValue: "MLModelAuthorKey")
+    public static let description = MLModelMetadataKey(rawValue: "MLModelDescriptionKey")
+    public static let versionString = MLModelMetadataKey(rawValue: "MLModelVersionStringKey")
+    public static let license = MLModelMetadataKey(rawValue: "MLModelLicenseKey")
+    /// The creator's own key-value pairs, a `[String: String]`.
+    public static let creatorDefinedKey = MLModelMetadataKey(rawValue: "MLModelCreatorDefinedKey")
+}
+
+public final class MLMultiArrayConstraint: @unchecked Sendable {
+    public let shape: [NSNumber]
+    public let dataType: MLMultiArrayDataType
+
+    init(shape: [NSNumber], dataType: MLMultiArrayDataType) {
+        self.shape = shape
+        self.dataType = dataType
+    }
+}
+
+public final class MLDictionaryConstraint: @unchecked Sendable {
+    public let keyType: MLFeatureType
+
+    init(keyType: MLFeatureType) { self.keyType = keyType }
+}
+
+/// One input or output of a model.
+public final class MLFeatureDescription: @unchecked Sendable, CustomStringConvertible {
+    public let name: String
+    public let type: MLFeatureType
+    public let isOptional: Bool
+    public let multiArrayConstraint: MLMultiArrayConstraint?
+    public let dictionaryConstraint: MLDictionaryConstraint?
+
+    init(_ feature: Specification.Feature) {
+        name = feature.name
+        type = feature.featureType
+        isOptional = feature.isOptional
+        if type == .multiArray {
+            let dataType: MLMultiArrayDataType = switch feature.dataType {
+            case "float32": .float32
+            case "float16": .float16
+            case "int32": .int32
+            case "int8": .int8
+            default: .double
+            }
+            multiArrayConstraint = MLMultiArrayConstraint(shape: (feature.shape ?? []).map { NSNumber(value: $0) }, dataType: dataType)
+        } else {
+            multiArrayConstraint = nil
+        }
+        dictionaryConstraint = type == .dictionary ? MLDictionaryConstraint(keyType: feature.keyType == "int64" ? .int64 : .string) : nil
+    }
+
+    /// Whether `value` can be given for this feature.
+    public func isAllowedValue(_ value: MLFeatureValue) -> Bool {
+        if value.isUndefined { return isOptional }
+        switch (type, value.type) {
+        case (.double, .int64), (.int64, .double): return true
+        default: return type == value.type
+        }
+    }
+
+    public var description: String { "\(name) : \(type)\(isOptional ? " (optional)" : "")" }
+}
+
+/// What a model takes and returns, and who made it.
+public final class MLModelDescription: @unchecked Sendable {
+    public let inputDescriptionsByName: [String: MLFeatureDescription]
+    public let outputDescriptionsByName: [String: MLFeatureDescription]
+    public let predictedFeatureName: String?
+    public let predictedProbabilitiesName: String?
+    public let metadata: [MLModelMetadataKey: Any]
+    /// A classifier's labels (`String`s or `Int64`s), else nil.
+    public let classLabels: [Any]?
+
+    init(_ specification: Specification) {
+        let description = specification.description
+        inputDescriptionsByName = Dictionary(description.inputs.map { ($0.name, MLFeatureDescription($0)) }, uniquingKeysWith: { first, _ in first })
+        outputDescriptionsByName = Dictionary(description.outputs.map { ($0.name, MLFeatureDescription($0)) }, uniquingKeysWith: { first, _ in first })
+        predictedFeatureName = description.predictedFeatureName
+        predictedProbabilitiesName = description.predictedProbabilitiesName
+        var metadata: [MLModelMetadataKey: Any] = [:]
+        if let given = description.metadata {
+            if let author = given.author { metadata[.author] = author }
+            if let text = given.shortDescription { metadata[.description] = text }
+            if let version = given.versionString { metadata[.versionString] = version }
+            if let license = given.license { metadata[.license] = license }
+            if let creatorDefined = given.creatorDefined { metadata[.creatorDefinedKey] = creatorDefined }
+        }
+        self.metadata = metadata
+        classLabels = MLModelDescription.labels(of: specification)?.anyValues
+    }
+
+    /// The labels of a classifier, or of the classifier ending a pipeline.
+    private static func labels(of specification: Specification) -> Specification.Labels? {
+        switch specification.model {
+        case .glmClassifier(_, _, _, _, let labels), .treeEnsembleClassifier(_, let labels): labels
+        case .pipeline(let models): models.last.flatMap { labels(of: $0) }
+        default: nil
+        }
+    }
+}
+
+/// A model compiled into the app by @swiftbrowser/cli, found by the name of
+/// its `.mlmodelc`.
+private final class CompiledModels: @unchecked Sendable {
+    private let lock = NSLock()
+    private var specifications: [String: String] = [:]
+    private var decoded: [String: Specification] = [:]
+
+    func register(_ name: String, json: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        if specifications[name] == nil { specifications[name] = json }
+    }
+
+    func specification(named name: String) throws -> Specification? {
+        lock.lock()
+        defer { lock.unlock() }
+        if let cached = decoded[name] { return cached }
+        guard let json = specifications[name] else { return nil }
+        let specification = try Specification.decode(json)
+        decoded[name] = specification
+        return specification
+    }
+}
+
+private let compiledModels = CompiledModels()
+
+open class MLModel: @unchecked Sendable {
+    public let modelDescription: MLModelDescription
+    public let configuration: MLModelConfiguration
+    let specification: Specification
+
+    init(specification: Specification, configuration: MLModelConfiguration) {
+        self.specification = specification
+        self.configuration = configuration
+        modelDescription = MLModelDescription(specification)
+    }
+
+    /// Loads a compiled model (`<Name>.mlmodelc`): one of the app's models,
+    /// which the CLI compiled into its generated class.
+    public convenience init(contentsOf url: URL) throws {
+        try self.init(contentsOf: url, configuration: MLModelConfiguration())
+    }
+
+    public convenience init(contentsOf url: URL, configuration: MLModelConfiguration) throws {
+        let name = url.deletingPathExtension().lastPathComponent
+        guard let specification = try compiledModels.specification(named: name) else {
+            throw MLModelError(.io, "No compiled model at \(url.path). In the browser, the models are the .mlmodel files of the app's target, compiled by @swiftbrowser/cli.")
+        }
+        self.init(specification: specification, configuration: configuration)
+    }
+
+    /// The `.mlmodelc` URL of a generated model class (`urlOfModelInThisBundle`),
+    /// registering the model the CLI embedded in it.
+    public static func _compiledModelURL(named name: String, specification json: String) -> URL {
+        compiledModels.register(name, json: json)
+        return URL(fileURLWithPath: "/bundle").appendingPathComponent("\(name).mlmodelc", isDirectory: true)
+    }
+
+    public class func load(contentsOf url: URL, configuration: MLModelConfiguration = MLModelConfiguration()) async throws -> MLModel {
+        try MLModel(contentsOf: url, configuration: configuration)
+    }
+
+    public class func load(contentsOf url: URL, configuration: MLModelConfiguration, completionHandler handler: @escaping (Result<MLModel, any Error>) -> Void) {
+        handler(Result(catching: { try MLModel(contentsOf: url, configuration: configuration) }))
+    }
+
+    open func prediction(from input: MLFeatureProvider) throws -> MLFeatureProvider {
+        try prediction(from: input, options: MLPredictionOptions())
+    }
+
+    open func prediction(from input: MLFeatureProvider, options: MLPredictionOptions) throws -> MLFeatureProvider {
+        try predict(input)
+    }
+
+    public func prediction(from input: MLFeatureProvider, options: MLPredictionOptions = MLPredictionOptions()) async throws -> MLFeatureProvider {
+        try predict(input)
+    }
+
+    open func predictions(from inputs: MLBatchProvider, options: MLPredictionOptions = MLPredictionOptions()) throws -> MLBatchProvider {
+        MLArrayBatchProvider(array: try (0..<inputs.count).map { try predict(inputs.features(at: $0)) })
+    }
+
+    /// Checks the inputs against the description, evaluates, and returns the declared outputs.
+    private func predict(_ input: MLFeatureProvider) throws -> MLFeatureProvider {
+        var values: [String: Value] = [:]
+        for feature in specification.description.inputs {
+            guard let value = input.featureValue(for: feature.name), !value.isUndefined else {
+                if feature.isOptional { continue }
+                throw MLModelError(.featureType, "Feature \(feature.name) is required but not specified.")
+            }
+            values[feature.name] = try Value(value).converted(to: feature)
+        }
+        let outputs = try specification.evaluate(values)
+        return try MLDictionaryFeatureProvider(dictionary: outputs.mapValues { $0.featureValue })
+    }
+}

package/Sources/CoreML/MultiArray.swift

@@ -0,0 +1,92 @@
+// `MLMultiArray`, as far as tabular models need it: a shaped array of numbers
+// (held as doubles whatever the data type) read and written by index.
+
+import Foundation
+
+/// The element type of a multiarray, with Core ML's raw values.
+public enum MLMultiArrayDataType: Int, Sendable {
+    case double = 65600
+    case float32 = 65568
+    case float16 = 65552
+    case int32 = 131104
+    case int8 = 131080
+
+    public static var float64: MLMultiArrayDataType { .double }
+    public static var float: MLMultiArrayDataType { .float32 }
+}
+
+public final class MLMultiArray: @unchecked Sendable, CustomStringConvertible {
+    public let shape: [NSNumber]
+    public let strides: [NSNumber]
+    public let dataType: MLMultiArrayDataType
+    /// The elements in row-major order.
+    var values: [Double]
+
+    public init(shape: [NSNumber], dataType: MLMultiArrayDataType) throws {
+        let dimensions = shape.map(\.intValue)
+        guard dimensions.allSatisfy({ $0 >= 0 }) else { throw MLModelError(.generic, "A multiarray's shape cannot be negative: \(dimensions).") }
+        self.shape = shape
+        self.dataType = dataType
+        strides = MLMultiArray.strides(of: dimensions).map { NSNumber(value: $0) }
+        values = Array(repeating: 0, count: dimensions.reduce(1, *))
+    }
+
+    /// A one-dimensional array of `values`.
+    init(values: [Double], shape: [Int]? = nil, dataType: MLMultiArrayDataType = .double) {
+        let dimensions = shape ?? [values.count]
+        self.shape = dimensions.map { NSNumber(value: $0) }
+        self.dataType = dataType
+        strides = MLMultiArray.strides(of: dimensions).map { NSNumber(value: $0) }
+        self.values = values
+    }
+
+    private static func strides(of dimensions: [Int]) -> [Int] {
+        var strides = Array(repeating: 1, count: dimensions.count)
+        var stride = 1
+        for index in dimensions.indices.reversed() {
+            strides[index] = stride
+            stride *= dimensions[index]
+        }
+        return strides
+    }
+
+    public var count: Int { values.count }
+
+    private func number(_ value: Double) -> NSNumber {
+        switch dataType {
+        case .int32, .int8: NSNumber(value: Int32(clamping: Int64(value)))
+        case .float32, .float16: NSNumber(value: Float(value))
+        case .double: NSNumber(value: value)
+        }
+    }
+
+    private func stored(_ number: NSNumber) -> Double {
+        switch dataType {
+        case .int32: Double(number.int32Value)
+        case .int8: Double(number.int8Value)
+        case .float32, .float16: Double(number.floatValue)
+        case .double: number.doubleValue
+        }
+    }
+
+    /// The element at a linear (row-major) index.
+    public subscript(index: Int) -> NSNumber {
+        get { number(values[index]) }
+        set { values[index] = stored(newValue) }
+    }
+
+    /// The element at a multidimensional index.
+    public subscript(key: [NSNumber]) -> NSNumber {
+        get { self[linearIndex(key)] }
+        set { self[linearIndex(key)] = newValue }
+    }
+
+    private func linearIndex(_ key: [NSNumber]) -> Int {
+        precondition(key.count == strides.count, "MLMultiArray: index \(key.map(\.intValue)) has \(key.count) dimensions; the array has \(strides.count)")
+        return zip(key, strides).reduce(0) { $0 + $1.0.intValue * $1.1.intValue }
+    }
+
+    public var description: String {
+        "MLMultiArray(shape: \(shape.map(\.intValue)), \(values))"
+    }
+}

package/Sources/CoreML/Specification.swift

@@ -0,0 +1,233 @@
+// The model specification @swiftbrowser/cli embeds in each generated model
+// class (packages/cli/src/coreml.ts): Core ML's protobuf, read when the app is
+// built and written as JSON, decoded here once per model. The shapes mirror
+// Model.proto in apple/coremltools; trees come resolved (root first, children
+// as positions) and checked by the CLI.
+
+import Foundation
+
+struct Specification: Decodable {
+    var specificationVersion: Int
+    var description: Description
+    var model: Kind
+
+    struct Description: Decodable {
+        var inputs: [Feature]
+        var outputs: [Feature]
+        var predictedFeatureName: String?
+        var predictedProbabilitiesName: String?
+        var metadata: Metadata?
+    }
+
+    struct Metadata: Decodable {
+        var shortDescription: String?
+        var versionString: String?
+        var author: String?
+        var license: String?
+        var creatorDefined: [String: String]?
+    }
+
+    struct Feature: Decodable {
+        var name: String
+        var type: String
+        var optional: Bool?
+        var shape: [Int]?
+        var dataType: String?
+        var keyType: String?
+
+        var featureType: MLFeatureType {
+            switch type {
+            case "int64": .int64
+            case "double": .double
+            case "string": .string
+            case "multiArray": .multiArray
+            case "dictionary": .dictionary
+            default: .invalid
+            }
+        }
+
+        var isOptional: Bool { optional ?? false }
+    }
+
+    /// Class labels, or the categories of an encoder: strings or integers.
+    enum Labels: Decodable {
+        case strings([String])
+        case int64s([Int64])
+
+        private enum CodingKeys: String, CodingKey { case strings, int64s }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            if let strings = try container.decodeIfPresent([String].self, forKey: .strings) {
+                self = .strings(strings)
+            } else {
+                self = .int64s(try container.decode([Int64].self, forKey: .int64s))
+            }
+        }
+
+        var count: Int {
+            switch self {
+            case .strings(let labels): labels.count
+            case .int64s(let labels): labels.count
+            }
+        }
+
+        func value(at index: Int) -> Value {
+            switch self {
+            case .strings(let labels): .string(labels[index])
+            case .int64s(let labels): .int64(labels[index])
+            }
+        }
+
+        /// The position of a string or integer value among the labels.
+        func index(of value: Value) -> Int? {
+            switch (self, value) {
+            case (.strings(let labels), .string(let string)): labels.firstIndex(of: string)
+            case (.int64s(let labels), .int64(let integer)): labels.firstIndex(of: integer)
+            case (.int64s(let labels), .double(let double)): Int64(exactly: double).flatMap { labels.firstIndex(of: $0) }
+            default: nil
+            }
+        }
+
+        var anyValues: [Any] {
+            switch self {
+            case .strings(let labels): labels
+            case .int64s(let labels): labels
+            }
+        }
+    }
+
+    struct Tree: Decodable {
+        /// TreeNodeBehavior: 0 ≤, 1 <, 2 ≥, 3 >, 4 ==, 5 ≠ (branches), 6 leaf.
+        var behaviors: [Int]
+        var features: [Int]
+        var thresholds: [Double]
+        var trueChildren: [Int]
+        var falseChildren: [Int]
+        var missingTrue: [Bool]
+        var leafStarts: [Int]
+        var leafIndices: [Int]
+        var leafValues: [Double]
+    }
+
+    struct TreeEnsemble: Decodable {
+        var dimensions: Int
+        var base: [Double]
+        var trees: [Tree]
+        /// "none", "softmax", "logistic" or "softmaxWithZeroClassReference".
+        var transform: String
+    }
+
+    struct Imputed: Decodable {
+        var double: Double?
+        var int64: Int64?
+        var string: String?
+        var doubles: [Double]?
+        var int64s: [Int64]?
+        var stringDictionary: [String: Double]?
+        /// Keys in decimal.
+        var int64Dictionary: [String: Double]?
+    }
+
+    struct Replace: Decodable {
+        var double: Double?
+        var int64: Int64?
+        var string: String?
+    }
+
+    struct CategoricalMapping: Decodable {
+        var stringToInt64: [String: Int64]?
+        /// Keys in decimal.
+        var int64ToString: [String: String]?
+        var defaultString: String?
+        var defaultInt64: Int64?
+    }
+
+    struct Column: Decodable {
+        var name: String
+        var dimensions: Int
+    }
+
+    indirect enum Kind: Decodable {
+        case pipeline([Specification])
+        case glmRegressor(weights: [[Double]], offsets: [Double], transform: String)
+        case glmClassifier(weights: [[Double]], offsets: [Double], transform: String, encoding: String, labels: Labels)
+        case treeEnsembleRegressor(TreeEnsemble)
+        case treeEnsembleClassifier(TreeEnsemble, labels: Labels)
+        case featureVectorizer([Column])
+        case oneHotEncoder(categories: Labels, sparse: Bool, ignoreUnknown: Bool)
+        case normalizer(String)
+        case imputer(Imputed, replace: Replace?)
+        case scaler(shift: [Double], scale: [Double])
+        case dictVectorizer(Labels)
+        case arrayFeatureExtractor([Int])
+        case categoricalMapping(CategoricalMapping)
+        case identity
+
+        private enum CodingKeys: String, CodingKey {
+            case kind, models, weights, offsets, transform, encoding, labels, columns, categories, sparse, ignoreUnknown
+            case norm, imputed, replace, shift, scale, keys, indices
+        }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            let kind = try container.decode(String.self, forKey: .kind)
+            switch kind {
+            case "pipeline", "pipelineClassifier", "pipelineRegressor":
+                self = .pipeline(try container.decode([Specification].self, forKey: .models))
+            case "glmRegressor":
+                self = .glmRegressor(
+                    weights: try container.decode([[Double]].self, forKey: .weights),
+                    offsets: try container.decode([Double].self, forKey: .offsets),
+                    transform: try container.decode(String.self, forKey: .transform))
+            case "glmClassifier":
+                self = .glmClassifier(
+                    weights: try container.decode([[Double]].self, forKey: .weights),
+                    offsets: try container.decode([Double].self, forKey: .offsets),
+                    transform: try container.decode(String.self, forKey: .transform),
+                    encoding: try container.decode(String.self, forKey: .encoding),
+                    labels: try container.decode(Labels.self, forKey: .labels))
+            case "treeEnsembleRegressor":
+                self = .treeEnsembleRegressor(try TreeEnsemble(from: decoder))
+            case "treeEnsembleClassifier":
+                self = .treeEnsembleClassifier(try TreeEnsemble(from: decoder), labels: try container.decode(Labels.self, forKey: .labels))
+            case "featureVectorizer":
+                self = .featureVectorizer(try container.decode([Column].self, forKey: .columns))
+            case "oneHotEncoder":
+                self = .oneHotEncoder(
+                    categories: try container.decode(Labels.self, forKey: .categories),
+                    sparse: try container.decode(Bool.self, forKey: .sparse),
+                    ignoreUnknown: try container.decode(Bool.self, forKey: .ignoreUnknown))
+            case "normalizer":
+                self = .normalizer(try container.decode(String.self, forKey: .norm))
+            case "imputer":
+                self = .imputer(try container.decode(Imputed.self, forKey: .imputed), replace: try container.decodeIfPresent(Replace.self, forKey: .replace))
+            case "scaler":
+                self = .scaler(shift: try container.decode([Double].self, forKey: .shift), scale: try container.decode([Double].self, forKey: .scale))
+            case "dictVectorizer":
+                self = .dictVectorizer(try container.decode(Labels.self, forKey: .keys))
+            case "arrayFeatureExtractor":
+                self = .arrayFeatureExtractor(try container.decode([Int].self, forKey: .indices))
+            case "categoricalMapping":
+                self = .categoricalMapping(try CategoricalMapping(from: decoder))
+            case "identity":
+                self = .identity
+            default:
+                throw MLModelError(.io, "Unknown model type \(kind) in the model specification.")
+            }
+        }
+    }
+
+    /// Decodes the JSON the CLI wrote.
+    static func decode(_ json: String) throws -> Specification {
+        let decoder = JSONDecoder()
+        decoder.nonConformingFloatDecodingStrategy = .convertFromString(positiveInfinity: "inf", negativeInfinity: "-inf", nan: "nan")
+        do {
+            return try decoder.decode(Specification.self, from: Data(json.utf8))
+        } catch let error as MLModelError {
+            throw error
+        } catch {
+            throw MLModelError(.io, "The model specification could not be read: \(error)")
+        }
+    }
+}

package/Sources/CoreText/CoreText.swift

@@ -0,0 +1,64 @@
+// `import CoreText` for the browser: the font manager's registration, which
+// packages call for the fonts they ship (`CTFontManagerRegisterFontsForURL`).
+// The page lays out text with the browser's fonts and loads none of these, so
+// registering a font that exists succeeds and changes nothing; a missing file
+// fails with `kCTFontManagerErrorFontFileNotFound`, as on Apple platforms.
+// The rest of Core Text (fonts, lines, frames) is not here.
+
+import Foundation
+@_exported import CoreFoundationTypes
+
+/// Where a registration applies. The page has one process; every scope is it.
+public enum CTFontManagerScope: UInt32, Sendable {
+    case none = 0
+    case process = 1
+    case persistent = 2
+    case session = 3
+
+    public static let user = CTFontManagerScope.persistent
+}
+
+/// The font manager's error codes, in `kCTFontManagerErrorDomain`.
+public enum CTFontManagerError: CFIndex, Sendable {
+    case fileNotFound = 101
+    case insufficientPermissions = 102
+    case unrecognizedFormat = 103
+    case invalidFontData = 104
+    case alreadyRegistered = 105
+    case exceededResourceLimit = 106
+    case assetNotFound = 107
+    case notRegistered = 201
+    case inUse = 202
+    case systemRequired = 203
+    case registrationFailed = 301
+    case missingEntitlement = 302
+    case insufficientInfo = 303
+    case cancelledByUser = 304
+    case duplicatedName = 305
+    case invalidFilePath = 306
+    case unsupportedScope = 307
+}
+
+public let kCTFontManagerErrorDomain: CFString = "com.apple.CoreText.CTFontManagerErrorDomain"
+public let kCTFontManagerErrorFontFileNotFound = CTFontManagerError.fileNotFound.rawValue
+
+/// Registers the fonts in the file at `fontURL`: true when the file exists
+/// (the page does not load it), else false with a `fileNotFound` error.
+@discardableResult
+public func CTFontManagerRegisterFontsForURL(_ fontURL: CFURL, _ scope: CTFontManagerScope, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>?) -> Bool {
+    _fontFileResult(fontURL, error)
+}
+
+/// Unregisters the fonts in the file at `fontURL`: true when the file exists.
+@discardableResult
+public func CTFontManagerUnregisterFontsForURL(_ fontURL: CFURL, _ scope: CTFontManagerScope, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>?) -> Bool {
+    _fontFileResult(fontURL, error)
+}
+
+func _fontFileResult(_ fontURL: URL, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>?) -> Bool {
+    if fontURL.isFileURL, FileManager.default.fileExists(atPath: fontURL.path) { return true }
+    let failure = NSError(domain: kCTFontManagerErrorDomain, code: CTFontManagerError.fileNotFound.rawValue,
+                          userInfo: [NSURLErrorKey: fontURL])
+    error?.pointee = Unmanaged.passRetained(failure)
+    return false
+}