@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/FoundationBridge/Dispatch.swift

@@ -0,0 +1,458 @@
+// `DispatchQueue` for the browser. The WASI SDK ships no Dispatch, yet
+// `DispatchQueue.main.async { … }` and `asyncAfter(deadline: .now() + 0.5)`
+// are how much SwiftUI code (and many packages) defer work to the next turn
+// or a moment later. The page has one thread, so every queue is the main
+// queue: work runs on the main actor, in order, from the runtime's executor,
+// and a deadline is a `Task.sleep` (so headless runs stay deterministic, like
+// `Timer` in Timer.swift).
+//
+// The CLI's staging gives the app (and each package built against the shim)
+// typealiases for these names, so a host `check`, where Foundation re-exports
+// Dispatch, type-checks against the same API the browser build has. Work
+// items and groups are here (a group's `notify` runs once everything that
+// entered has left), and memory-pressure sources, which never fire;
+// semaphores and other sources are not (waiting would block the only
+// thread): code that needs them is a compile error in the browser build.
+
+import Foundation
+
+/// A point in time for `asyncAfter`, on the clock `Task.sleep` uses.
+public struct DispatchTime: Comparable, Hashable, Sendable {
+    /// Nanoseconds since the first `now()` of the process.
+    public let uptimeNanoseconds: UInt64
+
+    public init(uptimeNanoseconds: UInt64) {
+        self.uptimeNanoseconds = uptimeNanoseconds
+    }
+
+    nonisolated(unsafe) private static let origin = ContinuousClock.now
+
+    public static func now() -> DispatchTime {
+        let elapsed = ContinuousClock.now - origin
+        let (seconds, attoseconds) = elapsed.components
+        return DispatchTime(uptimeNanoseconds: UInt64(max(0, seconds)) * 1_000_000_000 + UInt64(max(0, attoseconds) / 1_000_000_000))
+    }
+
+    public static let distantFuture = DispatchTime(uptimeNanoseconds: .max)
+
+    public static func < (lhs: DispatchTime, rhs: DispatchTime) -> Bool {
+        lhs.uptimeNanoseconds < rhs.uptimeNanoseconds
+    }
+
+    /// The time from this one to `other` (negative when `other` is earlier).
+    public func distance(to other: DispatchTime) -> DispatchTimeInterval {
+        .nanoseconds(Int(truncatingIfNeeded: Int64(bitPattern: other.uptimeNanoseconds &- uptimeNanoseconds)))
+    }
+
+    /// The time `nanoseconds` later (or earlier), clamped. Public for the CLI's generated operators.
+    public func _adding(nanoseconds: Double) -> DispatchTime {
+        let sum = Double(uptimeNanoseconds) + nanoseconds
+        if sum <= 0 { return DispatchTime(uptimeNanoseconds: 0) }
+        if sum >= Double(UInt64.max) { return .distantFuture }
+        return DispatchTime(uptimeNanoseconds: UInt64(sum))
+    }
+}
+
+// Global, as Dispatch declares them, so that `.now() + 0.5` finds them: the
+// left operand's type comes from the context, too late for a static operator.
+
+public func + (time: DispatchTime, seconds: Double) -> DispatchTime {
+    time._adding(nanoseconds: seconds * 1_000_000_000)
+}
+
+public func - (time: DispatchTime, seconds: Double) -> DispatchTime {
+    time._adding(nanoseconds: -seconds * 1_000_000_000)
+}
+
+public func + (time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime { DispatchTime._plus(time, interval) }
+public func - (time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime { DispatchTime._minus(time, interval) }
+
+extension DispatchTime {
+    public static func _plus(_ time: DispatchTime, _ interval: DispatchTimeInterval) -> DispatchTime {
+        guard let nanoseconds = interval.nanoseconds else { return .distantFuture }
+        return time._adding(nanoseconds: nanoseconds)
+    }
+
+    public static func _minus(_ time: DispatchTime, _ interval: DispatchTimeInterval) -> DispatchTime {
+        guard let nanoseconds = interval.nanoseconds else { return DispatchTime(uptimeNanoseconds: 0) }
+        return time._adding(nanoseconds: -nanoseconds)
+    }
+}
+
+/// A duration for `DispatchTime` arithmetic.
+public enum DispatchTimeInterval: Equatable, Sendable {
+    case seconds(Int)
+    case milliseconds(Int)
+    case microseconds(Int)
+    case nanoseconds(Int)
+    case never
+
+    var nanoseconds: Double? {
+        switch self {
+        case .seconds(let n): Double(n) * 1_000_000_000
+        case .milliseconds(let n): Double(n) * 1_000_000
+        case .microseconds(let n): Double(n) * 1_000
+        case .nanoseconds(let n): Double(n)
+        case .never: nil
+        }
+    }
+}
+
+/// A quality of service, accepted and ignored: the page runs everything on one thread.
+public struct DispatchQoS: Equatable, Sendable {
+    public enum QoSClass: Equatable, Sendable {
+        case background, utility, `default`, userInitiated, userInteractive, unspecified
+    }
+
+    public let qosClass: QoSClass
+
+    public init(qosClass: QoSClass, relativePriority: Int) {
+        self.qosClass = qosClass
+    }
+
+    public static let background = DispatchQoS(qosClass: .background, relativePriority: 0)
+    public static let utility = DispatchQoS(qosClass: .utility, relativePriority: 0)
+    public static let `default` = DispatchQoS(qosClass: .default, relativePriority: 0)
+    public static let userInitiated = DispatchQoS(qosClass: .userInitiated, relativePriority: 0)
+    public static let userInteractive = DispatchQoS(qosClass: .userInteractive, relativePriority: 0)
+    public static let unspecified = DispatchQoS(qosClass: .unspecified, relativePriority: 0)
+}
+
+/// A queue of work. Every queue runs its work on the main actor, in order.
+public final class DispatchQueue: Sendable {
+    public struct Attributes: OptionSet, Sendable {
+        public let rawValue: UInt64
+        public init(rawValue: UInt64) { self.rawValue = rawValue }
+        public static let concurrent = Attributes(rawValue: 1 << 1)
+        public static let initiallyInactive = Attributes(rawValue: 1 << 2)
+    }
+
+    public let label: String
+    /// `setSpecific` values, by key.
+    private let specifics = _QueueSpecifics()
+
+    public init(label: String, qos: DispatchQoS = .unspecified, attributes: Attributes = []) {
+        self.label = label
+    }
+
+    /// The queues whose work is running, innermost last: what
+    /// `DispatchQueue.getSpecific(key:)` reads. Code outside any queue's work
+    /// runs on the main queue.
+    nonisolated(unsafe) private static var running: [DispatchQueue] = []
+
+    /// Runs `work` as this queue's: `getSpecific(key:)` reads this queue's values meanwhile.
+    private func running<T>(_ work: () throws -> T) rethrows -> T {
+        Self.running.append(self)
+        defer { Self.running.removeLast() }
+        return try work()
+    }
+
+    /// Stores `value` under `key` on this queue (nil removes it).
+    public func setSpecific<T>(key: DispatchSpecificKey<T>, value: T?) {
+        specifics.values[ObjectIdentifier(key)] = value.map { $0 as Any }
+    }
+
+    /// The value stored under `key` on this queue.
+    public func getSpecific<T>(key: DispatchSpecificKey<T>) -> T? {
+        specifics.values[ObjectIdentifier(key)] as? T
+    }
+
+    /// The value stored under `key` on the queue whose work is running (the
+    /// main queue's outside any): how code tells it is already on a queue
+    /// (SQLite.swift's connections do before `sync`).
+    public static func getSpecific<T>(key: DispatchSpecificKey<T>) -> T? {
+        (running.last ?? main).getSpecific(key: key)
+    }
+
+    public static let main = DispatchQueue(label: "com.apple.main-thread")
+
+    public static func global(qos: DispatchQoS.QoSClass = .default) -> DispatchQueue {
+        main
+    }
+
+    /// Runs `work` on the next turn of the main actor.
+    public func async(execute work: @escaping () -> Void) {
+        nonisolated(unsafe) let work = work
+        Task { @MainActor in self.running(work) }
+    }
+
+    /// `async(group:qos:flags:execute:)`: the group, QoS and flags are accepted.
+    public func async(group: DispatchGroup? = nil, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], execute work: @escaping () -> Void) {
+        group?.enter()
+        nonisolated(unsafe) let work = work
+        Task { @MainActor in
+            self.running(work)
+            group?.leave()
+        }
+    }
+
+    public func async(execute item: DispatchWorkItem) {
+        Task { @MainActor in self.running { item.perform() } }
+    }
+
+    /// Runs `work` once `deadline` has passed.
+    public func asyncAfter(deadline: DispatchTime, execute work: @escaping () -> Void) {
+        nonisolated(unsafe) let work = work
+        asyncAfter(deadline: deadline, qos: .unspecified, flags: [], execute: { work() })
+    }
+
+    public func asyncAfter(deadline: DispatchTime, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], execute work: @escaping () -> Void) {
+        nonisolated(unsafe) let work = work
+        let delay = Self.delay(until: deadline)
+        Task { @MainActor in
+            if delay > 0 { try? await Task.sleep(for: .seconds(delay)) }
+            self.running(work)
+        }
+    }
+
+    public func asyncAfter(deadline: DispatchTime, execute item: DispatchWorkItem) {
+        let delay = Self.delay(until: deadline)
+        Task { @MainActor in
+            if delay > 0 { try? await Task.sleep(for: .seconds(delay)) }
+            self.running { item.perform() }
+        }
+    }
+
+    static func delay(until deadline: DispatchTime) -> Double {
+        let now = DispatchTime.now()
+        return deadline > now ? Double(deadline.uptimeNanoseconds - now.uptimeNanoseconds) / 1_000_000_000 : 0
+    }
+
+    public func sync(execute item: DispatchWorkItem) { running { item.perform() } }
+
+    public func sync<T>(flags: DispatchWorkItemFlags, execute work: () throws -> T) rethrows -> T {
+        try running(work)
+    }
+
+    /// Runs `work` now and returns its result: with one thread, nothing else can be running.
+    public func sync<T>(execute work: () throws -> T) rethrows -> T {
+        try running(work)
+    }
+}
+
+/// A key for `DispatchQueue.setSpecific(key:value:)`; keys compare by identity.
+public final class DispatchSpecificKey<T>: @unchecked Sendable {
+    public init() {}
+}
+
+final class _QueueSpecifics: @unchecked Sendable {
+    var values: [ObjectIdentifier: Any] = [:]
+}
+
+// MARK: - Sources
+
+/// A dispatch source. The browser raises no events for the kinds here: a
+/// memory-pressure source never fires (the page cannot tell), and handlers
+/// are kept until the source is cancelled.
+public protocol DispatchSourceProtocol: AnyObject, Sendable {
+    func setEventHandler(handler: (@Sendable () -> Void)?)
+    func setCancelHandler(handler: (@Sendable () -> Void)?)
+    func setRegistrationHandler(handler: (@Sendable () -> Void)?)
+    func activate()
+    func resume()
+    func suspend()
+    func cancel()
+    var isCancelled: Bool { get }
+}
+
+public protocol DispatchSourceMemoryPressure: DispatchSourceProtocol {
+    var data: DispatchSource.MemoryPressureEvent { get }
+    var mask: DispatchSource.MemoryPressureEvent { get }
+}
+
+public enum DispatchSource {
+    public struct MemoryPressureEvent: OptionSet, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let normal = MemoryPressureEvent(rawValue: 1 << 0)
+        public static let warning = MemoryPressureEvent(rawValue: 1 << 1)
+        public static let critical = MemoryPressureEvent(rawValue: 1 << 2)
+        public static let all: MemoryPressureEvent = [.normal, .warning, .critical]
+    }
+
+    public static func makeMemoryPressureSource(eventMask: MemoryPressureEvent, queue: DispatchQueue? = nil) -> any DispatchSourceMemoryPressure {
+        _MemoryPressureSource(mask: eventMask)
+    }
+}
+
+/// A timer source: once scheduled and resumed, it calls its handler at the
+/// deadline, and every `repeating` interval after that, on the main actor's
+/// clock, the executor's (asyncAfter's).
+public protocol DispatchSourceTimer: DispatchSourceProtocol {
+    /// Fires at `deadline`, then every `nanoseconds` (nil: once).
+    func _schedule(deadline: DispatchTime, repeatingNanoseconds nanoseconds: Double?)
+}
+
+extension DispatchSourceTimer {
+    public func schedule(deadline: DispatchTime, repeating interval: DispatchTimeInterval = .never, leeway: DispatchTimeInterval = .nanoseconds(0)) {
+        _schedule(deadline: deadline, repeatingNanoseconds: interval.nanoseconds.flatMap { $0 > 0 ? $0 : nil })
+    }
+    public func schedule(deadline: DispatchTime, repeating interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) {
+        _schedule(deadline: deadline, repeatingNanoseconds: interval > 0 && interval.isFinite ? interval * 1_000_000_000 : nil)
+    }
+}
+
+extension DispatchSource {
+    public struct TimerFlags: OptionSet, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let strict = TimerFlags(rawValue: 1)
+    }
+
+    public static func makeTimerSource(flags: TimerFlags = [], queue: DispatchQueue? = nil) -> any DispatchSourceTimer {
+        _TimerSource()
+    }
+}
+
+final class _TimerSource: DispatchSourceTimer, @unchecked Sendable {
+    private var handler: (@Sendable () -> Void)?
+    private var cancelHandler: (@Sendable () -> Void)?
+    private var deadline: DispatchTime?
+    /// Nanoseconds between firings; nil for once.
+    private var interval: Double?
+    private var task: Task<Void, Never>?
+    private var running = false
+    private(set) var isCancelled = false
+
+    func setEventHandler(handler: (@Sendable () -> Void)?) { self.handler = handler }
+    func setCancelHandler(handler: (@Sendable () -> Void)?) { cancelHandler = handler }
+    func setRegistrationHandler(handler: (@Sendable () -> Void)?) { handler?() }
+
+    func _schedule(deadline: DispatchTime, repeatingNanoseconds nanoseconds: Double?) {
+        self.deadline = deadline
+        interval = nanoseconds
+        if running { start() }
+    }
+
+    func activate() { resume() }
+
+    func resume() {
+        guard !running, !isCancelled else { return }
+        running = true
+        start()
+    }
+
+    func suspend() {
+        running = false
+        task?.cancel()
+        task = nil
+    }
+
+    func cancel() {
+        guard !isCancelled else { return }
+        isCancelled = true
+        suspend()
+        handler = nil
+        let cancelHandler = self.cancelHandler
+        self.cancelHandler = nil
+        if let cancelHandler { DispatchQueue.main.async { cancelHandler() } }
+    }
+
+    private func start() {
+        task?.cancel()
+        guard let deadline, deadline != .distantFuture else { return }
+        nonisolated(unsafe) let source = self
+        task = Task { @MainActor in
+            let wait = Double(deadline.uptimeNanoseconds) - Double(DispatchTime.now().uptimeNanoseconds)
+            if wait > 0 { try? await Task.sleep(nanoseconds: UInt64(wait)) }
+            while !Task.isCancelled {
+                source.handler?()
+                guard let interval = source.interval else { break }
+                try? await Task.sleep(nanoseconds: UInt64(interval))
+            }
+        }
+    }
+}
+
+final class _MemoryPressureSource: DispatchSourceMemoryPressure, @unchecked Sendable {
+    let mask: DispatchSource.MemoryPressureEvent
+    private var handlers: [@Sendable () -> Void] = []
+    private(set) var isCancelled = false
+
+    init(mask: DispatchSource.MemoryPressureEvent) { self.mask = mask }
+
+    var data: DispatchSource.MemoryPressureEvent { [] }
+    func setEventHandler(handler: (@Sendable () -> Void)?) { handlers = handler.map { [$0] } ?? [] }
+    func setCancelHandler(handler: (@Sendable () -> Void)?) {}
+    func setRegistrationHandler(handler: (@Sendable () -> Void)?) {}
+    func activate() {}
+    func resume() {}
+    func suspend() {}
+    func cancel() {
+        isCancelled = true
+        handlers = []
+    }
+}
+
+// MARK: - Work items and groups
+
+public struct DispatchWorkItemFlags: OptionSet, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let barrier = DispatchWorkItemFlags(rawValue: 1 << 0)
+    public static let detached = DispatchWorkItemFlags(rawValue: 1 << 1)
+    public static let assignCurrentContext = DispatchWorkItemFlags(rawValue: 1 << 2)
+    public static let noQoS = DispatchWorkItemFlags(rawValue: 1 << 3)
+    public static let inheritQoS = DispatchWorkItemFlags(rawValue: 1 << 4)
+    public static let enforceQoS = DispatchWorkItemFlags(rawValue: 1 << 5)
+}
+
+/// Work that can be cancelled before it runs.
+public final class DispatchWorkItem: @unchecked Sendable {
+    private var block: (() -> Void)?
+    public private(set) var isCancelled = false
+
+    public init(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], block: @escaping @convention(block) () -> Void) {
+        self.block = block
+    }
+
+    public func perform() {
+        guard !isCancelled else { return }
+        block?()
+    }
+
+    public func cancel() {
+        isCancelled = true
+        block = nil
+    }
+
+    /// Returns at once: with one thread, the work ran already or cannot run while this waits.
+    public func wait() {}
+}
+
+/// A group of work. `notify` runs once everything entered has left.
+public final class DispatchGroup: @unchecked Sendable {
+    private var count = 0
+    private var waiting: [() -> Void] = []
+
+    public init() {}
+
+    public func enter() { count += 1 }
+
+    public func leave() {
+        count = max(0, count - 1)
+        guard count == 0 else { return }
+        let ready = waiting
+        waiting = []
+        for work in ready { work() }
+    }
+
+    public func notify(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], queue: DispatchQueue, execute work: @escaping () -> Void) {
+        nonisolated(unsafe) let work = work
+        if count == 0 {
+            queue.async(execute: { work() })
+        } else {
+            waiting.append { queue.async(execute: { work() }) }
+        }
+    }
+}
+
+// MARK: - Time constants
+
+// Dispatch's (C) time constants, which code multiplies `Task.sleep`
+// durations with (`Task.sleep(nanoseconds: NSEC_PER_SEC / 2)`).
+public let NSEC_PER_SEC: UInt64 = 1_000_000_000
+public let NSEC_PER_MSEC: UInt64 = 1_000_000
+public let NSEC_PER_USEC: UInt64 = 1_000
+public let USEC_PER_SEC: UInt64 = 1_000_000
+public let MSEC_PER_SEC: UInt64 = 1_000

package/Sources/FoundationBridge/EnvironmentFoundation.swift

@@ -0,0 +1,41 @@
+// SwiftUI's environment values of Foundation types: `locale`, `calendar` and
+// `timeZone`. The SwiftUI shim does not import Foundation, so they are
+// declared here. Each defaults to the current one (the viewer's locale,
+// FoundationBridge/Locale.swift); a view may set them for the views it
+// contains, which read them back. The shim's own texts and formatters do
+// not consult them.
+
+import Foundation
+import SwiftUI
+
+private struct LocaleKey: EnvironmentKey {
+    static var defaultValue: Locale? { nil }
+}
+
+private struct CalendarKey: EnvironmentKey {
+    static var defaultValue: Calendar? { nil }
+}
+
+private struct TimeZoneKey: EnvironmentKey {
+    static var defaultValue: TimeZone? { nil }
+}
+
+extension EnvironmentValues {
+    /// The locale views format for: the viewer's unless a view sets one.
+    public var locale: Locale {
+        get { self[LocaleKey.self] ?? .current }
+        set { self[LocaleKey.self] = newValue }
+    }
+
+    /// The calendar views use: the current one unless a view sets one.
+    public var calendar: Calendar {
+        get { self[CalendarKey.self] ?? .current }
+        set { self[CalendarKey.self] = newValue }
+    }
+
+    /// The time zone views use: the current one unless a view sets one.
+    public var timeZone: TimeZone {
+        get { self[TimeZoneKey.self] ?? .current }
+        set { self[TimeZoneKey.self] = newValue }
+    }
+}

package/Sources/FoundationBridge/FileImporter.swift

@@ -0,0 +1,128 @@
+// `.fileImporter`: the page's file chooser in place of the Files app. It is
+// the photo picker's `pickFiles` host request (docs/ops-protocol.md, "Photos
+// picker"), with an `accept` made from the allowed content types. The
+// chosen files are written to a folder of their own in the app's temporary
+// directory, and `onCompletion` gets their file URLs, which the app reads
+// like any file (no security scope to start: `startAccessingSecurityScopedResource`
+// answers true). A dismissed chooser calls `onCancellation`, if given, and
+// not `onCompletion`, as on iOS. Opening a chooser needs a tap, so set
+// `isPresented` from a button's action.
+
+import Foundation
+import SwiftUI
+import UniformTypeIdentifiers
+
+/// One file import: what to offer and what to do with the files.
+struct _FileImport {
+    let types: [UTType]
+    let multiple: Bool
+    let completion: @MainActor (Result<[URL], any Error>) -> Void
+    let cancellation: (@MainActor () -> Void)?
+
+    /// The chooser's `accept`: a MIME pattern or an extension per type;
+    /// empty (any file) when a type covers all data.
+    var accept: String {
+        var parts: [String] = []
+        for type in types {
+            if [UTType.item, .data, .content].contains(type) { return "" }
+            if type == .image { parts.append("image/*") }
+            else if type == .movie || type == .video || type == .audiovisualContent { parts.append("video/*") }
+            else if type == .audio { parts.append("audio/*") }
+            else if type == .text || type == .plainText { parts.append("text/*") }
+            else if let mime = type.preferredMIMEType { parts.append(mime) }
+            else if let ext = type.preferredFilenameExtension { parts.append(".\(ext)") }
+        }
+        return parts.joined(separator: ",")
+    }
+
+    @MainActor func run() async {
+        let params: _JSON = .object(["accept": .string(accept), "multiple": .bool(multiple)])
+        let value: _JSON
+        do {
+            value = try await _Runtime.shared._hostRequest(kind: "pickFiles", params: params)
+        } catch {
+            completion(.failure(error))
+            return
+        }
+        guard case .object(let fields) = value, case .array(let entries)? = fields["items"], !entries.isEmpty else {
+            cancellation?()
+            return
+        }
+        do {
+            completion(.success(try entries.map(Self.write)))
+        } catch {
+            completion(.failure(error))
+        }
+    }
+
+    /// Writes one chosen file (`{name, data}`) to a new folder in the temporary directory.
+    static func write(_ entry: _JSON) throws -> URL {
+        guard case .object(let fields) = entry, case .string(let base64)? = fields["data"],
+              let data = Data(base64Encoded: base64) else {
+            throw CocoaError(.fileReadCorruptFile)
+        }
+        var name = "file"
+        if case .string(let given)? = fields["name"], !given.isEmpty, !given.contains("/") { name = given }
+        let folder = FileManager.default.temporaryDirectory.appendingPathComponent("Imports/\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        let url = folder.appendingPathComponent(name)
+        try data.write(to: url)
+        return url
+    }
+}
+
+/// Opens the chooser when `isPresented` becomes true and sets it back to false once the viewer is done.
+struct _FileImporterPresenter<Content: View>: View {
+    let content: Content
+    let isPresented: Binding<Bool>
+    let fileImport: _FileImport
+
+    var body: some View {
+        let isPresented = isPresented
+        nonisolated(unsafe) let fileImport = fileImport
+        return content.onChange(of: isPresented.wrappedValue, initial: true) { _, presented in
+            guard presented else { return }
+            MainActor.assumeIsolated {
+                Task { @MainActor in
+                    await fileImport.run()
+                    isPresented.wrappedValue = false
+                }
+            }
+        }
+    }
+}
+
+extension View {
+    /// Lets the viewer pick one file of `allowedContentTypes`.
+    public func fileImporter(isPresented: Binding<Bool>, allowedContentTypes: [UTType],
+                             onCompletion: @escaping (Result<URL, any Error>) -> Void) -> some View {
+        _FileImporterPresenter(content: self, isPresented: isPresented,
+                               fileImport: _FileImport(types: allowedContentTypes, multiple: false,
+                                                       completion: { onCompletion($0.flatMap { urls in .success(urls[0]) }) },
+                                                       cancellation: nil))
+    }
+
+    /// Lets the viewer pick files of `allowedContentTypes`, several when `allowsMultipleSelection`.
+    public func fileImporter(isPresented: Binding<Bool>, allowedContentTypes: [UTType], allowsMultipleSelection: Bool,
+                             onCompletion: @escaping (Result<[URL], any Error>) -> Void) -> some View {
+        _FileImporterPresenter(content: self, isPresented: isPresented,
+                               fileImport: _FileImport(types: allowedContentTypes, multiple: allowsMultipleSelection,
+                                                       completion: { onCompletion($0) }, cancellation: nil))
+    }
+
+    /// As above, with `onCancellation` called when the viewer dismisses the chooser.
+    public func fileImporter(isPresented: Binding<Bool>, allowedContentTypes: [UTType], allowsMultipleSelection: Bool,
+                             onCompletion: @escaping (Result<[URL], any Error>) -> Void,
+                             onCancellation: @escaping () -> Void) -> some View {
+        _FileImporterPresenter(content: self, isPresented: isPresented,
+                               fileImport: _FileImport(types: allowedContentTypes, multiple: allowsMultipleSelection,
+                                                       completion: { onCompletion($0) }, cancellation: { onCancellation() }))
+    }
+}
+
+extension URL {
+    /// True: picked files are plain files of the app's.
+    public func startAccessingSecurityScopedResource() -> Bool { true }
+    /// Nothing to stop.
+    public func stopAccessingSecurityScopedResource() {}
+}