@swiftbrowser/swift 0.1.0 → 0.3.0

package/Package.swift

@@ -1,8 +1,11 @@
 // swift-tools-version: 6.0
-// The SwiftBrowser Swift package as @swiftbrowser/cli ships it: the SwiftUI
-// shim, Swift Charts, FoundationLite and FoundationBridge, library products only. `Sources/` is
-// copied from the repository's Sources/ at `npm pack` time (sync-sources.mjs);
-// in a repository checkout the CLI uses the repository's own Package.swift.
+// The SwiftBrowser Swift package as @swiftbrowser/cli ships it: every library
+// of the repository's Package.swift (the SwiftUI shim, Charts, SwiftData,
+// FoundationBridge and the framework and package stand-ins), library products
+// only. Generated from that manifest by sync-sources.mjs (manifest.mjs), which
+// also copies the targets' Sources/ in at `npm pack` time; in a repository
+// checkout the CLI uses the repository's own Package.swift.
+import CompilerPluginSupport
 import PackageDescription
 
 let package = Package(
@@ -10,14 +13,202 @@ let package = Package(
     products: [
         .library(name: "SwiftUI", targets: ["SwiftUI"]),
         .library(name: "Charts", targets: ["Charts"]),
-        .library(name: "FoundationLite", targets: ["FoundationLite"]),
         .library(name: "FoundationBridge", targets: ["FoundationBridge"]),
+        .library(name: "SwiftData", targets: ["SwiftData"]),
+        .library(name: "StoreKit", targets: ["StoreKit"]),
+        .library(name: "CoreLocation", targets: ["CoreLocation"]),
+        .library(name: "MapKit", targets: ["MapKit"]),
+        .library(name: "WeatherKit", targets: ["WeatherKit"]),
+        .library(name: "LocalAuthentication", targets: ["LocalAuthentication"]),
+        .library(name: "CoreML", targets: ["CoreML"]),
+        .library(name: "PhotosUI", targets: ["PhotosUI"]),
+        .library(name: "UniformTypeIdentifiers", targets: ["UniformTypeIdentifiers"]),
+        .library(name: "CoreImage", targets: ["CoreImage"]),
+        .library(name: "UserNotifications", targets: ["UserNotifications"]),
+        .library(name: "UIKit", targets: ["UIKit"]),
+        .library(name: "CoreGraphics", targets: ["CoreGraphics"]),
+        .library(name: "ImageIO", targets: ["ImageIO"]),
+        .library(name: "CryptoKit", targets: ["CryptoKit"]),
+        .library(name: "os", targets: ["os"]),
+        .library(name: "OSLog", targets: ["OSLog"]),
+        .library(name: "Security", targets: ["Security"]),
+        .library(name: "Accelerate", targets: ["Accelerate"]),
+        .library(name: "CommonCrypto", targets: ["CommonCrypto"]),
+        .library(name: "MobileCoreServices", targets: ["MobileCoreServices"]),
+        .library(name: "Combine", targets: ["Combine"]),
+        .library(name: "AppIntents", targets: ["AppIntents"]),
+        .library(name: "CoreHaptics", targets: ["CoreHaptics"]),
+        .library(name: "NaturalLanguage", targets: ["NaturalLanguage"]),
+        .library(name: "Compression", targets: ["Compression"]),
+        .library(name: "zlib", targets: ["zlib"]),
+        .library(name: "CoreText", targets: ["CoreText"]),
+        .library(name: "AVFoundation", targets: ["AVFoundation"]),
+        .library(name: "AudioToolbox", targets: ["AudioToolbox"]),
+        .library(name: "Symbols", targets: ["Symbols"]),
+        .library(name: "QuickLook", targets: ["QuickLook"]),
+        .library(name: "AVKit", targets: ["AVKit"]),
+        .library(name: "AuthenticationServices", targets: ["AuthenticationServices"]),
+        .library(name: "SafariServices", targets: ["SafariServices"]),
+        .library(name: "WebKit", targets: ["WebKit"]),
+        .library(name: "CoreTransferable", targets: ["CoreTransferable"]),
+        .library(name: "Photos", targets: ["Photos"]),
+        .library(name: "LinkPresentation", targets: ["LinkPresentation"]),
+        .library(name: "Translation", targets: ["Translation"]),
+        .library(name: "FoundationModels", targets: ["FoundationModels"]),
+    ],
+    // SwiftData's macros (`@Model`, `#Predicate`) build against swift-syntax.
+    // 604.0.0 is the release SwiftPM has prebuilt for Swift 6.4, so a macro
+    // build takes seconds instead of compiling swift-syntax (minutes). SwiftPM
+    // uses the prebuilt only for a macro that depends on swift-syntax alone.
+    // SwiftUI links the macros too, for `@Entry`.
+    dependencies: [
+        .package(url: "https://github.com/swiftlang/swift-syntax.git", "604.0.0"..<"605.0.0"),
     ],
     targets: [
-        .target(name: "SwiftUI", path: "Sources/SwiftUI"),
-        .target(name: "_FoundationCommon", dependencies: ["SwiftUI"], path: "Sources/_FoundationCommon"),
-        .target(name: "FoundationLite", dependencies: ["SwiftUI", "_FoundationCommon"], path: "Sources/FoundationLite"),
-        .target(name: "FoundationBridge", dependencies: ["SwiftUI", "_FoundationCommon"], path: "Sources/FoundationBridge"),
+        // API-compatible subset of SwiftUI plus the runtime that turns a view
+        // tree into render ops. Builds for Wasm and natively on Linux.
+        // SwiftDataMacros also expands SwiftUI's `@Entry`. It re-exports
+        // CoreTransferable (`Transferable`, `ShareLink`'s items), as on iOS.
+        .target(name: "SwiftUI", dependencies: ["SwiftDataMacros", "CoreTransferable"], path: "Sources/SwiftUI"),
+
+        // What apps need from Foundation that swift-corelibs Foundation does
+        // not have on WASI: Timer and RunLoop, a persisting UserDefaults, a
+        // Bundle over the staged resources, URLSession over fetch, AsyncImage,
+        // the viewer's Locale. Staged in by the CLI next to `import SwiftUI`.
+        .target(name: "FoundationBridge", dependencies: ["SwiftUI", "Security", "os", "CoreFoundationTypes"], path: "Sources/FoundationBridge"),
+
+        // Swift Charts. The chart types live in the SwiftUI target (they use
+        // its internal runtime protocols); this target re-exports SwiftUI and
+        // adds `Date: Plottable` and `DateBins`.
         .target(name: "Charts", dependencies: ["SwiftUI"], path: "Sources/Charts"),
+
+        // SwiftData over the browser's IndexedDB: `@Model`, `ModelContainer`,
+        // `ModelContext`, `@Query`. Models live in memory; the store is handed
+        // in at launch and every save goes back to the page as a `swiftdata`
+        // op (docs/ops-protocol.md, "Phase 18").
+        .target(name: "SwiftData", dependencies: ["SwiftUI", "SwiftDataMacros"], path: "Sources/SwiftData"),
+        .macro(
+            name: "SwiftDataMacros",
+            dependencies: [
+                .product(name: "SwiftSyntax", package: "swift-syntax"),
+                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+                .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
+                .product(name: "SwiftDiagnostics", package: "swift-syntax"),
+                .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
+                // Nothing else in the published manifest (packages/swift, what
+                // apps build), or SwiftPM compiles swift-syntax there instead
+                // of using its prebuilt. Compiled from source after this
+                // package's OSLog module, swift-syntax logs through it
+                // (`canImport(OSLog)`) and the macro must link it: the CLI sets
+                // SWIFT_BUILD_SCRIPT_ENVIRONMENT, which turns that logging off
+                // (toolchain.ts). This repository's own builds always compile
+                // swift-syntax (SwiftDataTests links the macro target): without
+                // that variable, the end of its Package.swift has the macro link
+                // os too (lines manifest.mjs leaves out of the published one).
+            ],
+            path: "Sources/SwiftDataMacros"
+        ),
+
+        // Stand-ins for Apple frameworks apps import for one or two calls:
+        // StoreKit's review request (a no-op), Core Location's coordinate type
+        // and a LocalAuthentication context that always succeeds. Linked only
+        // into apps that import them (packages/cli/src/stage.ts).
+        .target(name: "StoreKit", dependencies: ["SwiftUI", "UIKit"], path: "Sources/StoreKit"),
+        .target(name: "CoreLocation", path: "Sources/CoreLocation"),
+        // MapKit's SwiftUI map and value types, drawn without map data, and
+        // UIKit's `MKMapView`, which draws that map at its region (Sources/MapKit).
+        .target(name: "MapKit", dependencies: ["SwiftUI", "UIKit", "CoreLocation"], path: "Sources/MapKit"),
+        // WeatherKit's service and types; every request throws, as for an app
+        // without the capability (Sources/WeatherKit).
+        .target(name: "WeatherKit", dependencies: ["CoreLocation"], path: "Sources/WeatherKit"),
+        .target(name: "LocalAuthentication", path: "Sources/LocalAuthentication"),
+        // PhotosUI's `PhotosPicker` over the page's file chooser (a `pickFiles`
+        // host request; docs/ops-protocol.md, "Photos picker"), and the
+        // `UTType`s its items report.
+        .target(name: "PhotosUI", dependencies: ["SwiftUI", "UniformTypeIdentifiers", "Photos"], path: "Sources/PhotosUI"),
+        .target(name: "UniformTypeIdentifiers", path: "Sources/UniformTypeIdentifiers"),
+
+        // Core ML for the models Create ML makes from tables (linear and
+        // logistic regressions, boosted trees, their pipelines): the CLI
+        // compiles each .mlmodel into the class Xcode generates, with the model
+        // embedded, and this target evaluates it. Linked only into apps that
+        // have a model or import CoreML (packages/cli/src/coreml.ts).
+        .target(name: "CoreML", path: "Sources/CoreML"),
+
+        // Core Image's built-in filters and QR code generator as recipes the
+        // page runs on the decoded pixels (`UIImage` and `CGImage` are the
+        // shim's, as SwiftUI re-exports them on iOS). Linked only into apps
+        // that import it, like the stand-ins above.
+        .target(name: "CoreImage", dependencies: ["SwiftUI"], path: "Sources/CoreImage"),
+
+        // UserNotifications over the browser's Notification API, scheduled with
+        // the executor's timers while the page is open; it talks to the page
+        // through host requests (docs/ops-protocol.md, "Notifications").
+        .target(name: "UserNotifications", dependencies: ["SwiftUI"], path: "Sources/UserNotifications"),
+
+        // The Apple frameworks under SwiftUI that packages build on, as far as
+        // image and utility code uses them: UIKit's UIImage and UIColor, Core
+        // Graphics contexts and Image I/O sources over the shim's image
+        // recipes, CryptoKit's hashes, and os's locks and logs
+        // (docs/ops-protocol.md, "Core Graphics and Image I/O").
+        .target(name: "CoreGraphics", dependencies: ["SwiftUI"], path: "Sources/CoreGraphics"),
+        .target(name: "ImageIO", dependencies: ["CoreGraphics", "SwiftUI", "CoreFoundationTypes"], path: "Sources/ImageIO"),
+        // UIKit re-exports UserNotifications, as iOS's does (`UNUserNotificationCenter` with `import UIKit`).
+        .target(name: "UIKit", dependencies: ["CoreGraphics", "ImageIO", "CoreImage", "SwiftUI", "FoundationBridge", "UserNotifications"], path: "Sources/UIKit"),
+        .target(name: "CryptoKit", path: "Sources/CryptoKit"),
+        .target(name: "os", path: "Sources/os"),
+        .target(name: "OSLog", dependencies: ["os"], path: "Sources/OSLog"),
+        // The keychain's SecItem functions over a file in the app's home.
+        // Core Foundation's types, which Security, Image I/O, Audio Toolbox and
+        // FoundationBridge re-export (the name CoreFoundation is the Linux toolchain's).
+        .target(name: "CoreFoundationTypes", path: "Sources/CoreFoundationTypes"),
+        .target(name: "Security", dependencies: ["CoreFoundationTypes"], path: "Sources/Security"),
+        // Frameworks Ice Cubes' packages import: App Intents' types (Shortcuts
+        // has nothing to run them), haptics and sound (the browser has neither
+        // engine), natural-language detection, and zlib-style compression.
+        .target(name: "AppIntents", dependencies: ["SwiftUI", "FoundationBridge", "UIKit", "UniformTypeIdentifiers"], path: "Sources/AppIntents"),
+        .target(name: "CoreHaptics", dependencies: ["FoundationBridge"], path: "Sources/CoreHaptics"),
+        .target(name: "NaturalLanguage", dependencies: ["FoundationBridge"], path: "Sources/NaturalLanguage"),
+        .target(name: "Compression", path: "Sources/Compression"),
+        // `import zlib` re-exports Compression, where zlib's inflate API lives;
+        // Core Text has the font manager's registration (which loads nothing).
+        .target(name: "zlib", dependencies: ["Compression"], path: "Sources/zlib"),
+        .target(name: "CoreText", dependencies: ["CoreFoundationTypes"], path: "Sources/CoreText"),
+        // vImage's box convolutions: a recipe step for Core Graphics contexts, computed for real memory.
+        .target(name: "Accelerate", dependencies: ["CoreGraphics", "SwiftUI"], path: "Sources/Accelerate"),
+        // CommonCrypto's digest functions over CryptoKit's hashes; MobileCoreServices
+        // re-exports UniformTypeIdentifiers with the old kUTType constants.
+        .target(name: "CommonCrypto", dependencies: ["CryptoKit"], path: "Sources/CommonCrypto"),
+        .target(name: "MobileCoreServices", dependencies: ["UniformTypeIdentifiers"], path: "Sources/MobileCoreServices"),
+        // OpenCombine as the module Combine, with the SwiftUI shim's ObservableObject (Sources/Combine/SwiftUIObservation.swift);
+        // FoundationBridge's DispatchQueue and RunLoop are its schedulers (Sources/Combine/Schedulers.swift).
+        .target(name: "Combine", dependencies: ["SwiftUI", "FoundationBridge"], path: "Sources/Combine", exclude: ["LICENSE"],
+                swiftSettings: [.define("WASI"), .swiftLanguageMode(.v5)]),
+        // Video and audio over the page's media elements (docs/ops-protocol.md,
+        // "Video and audio"): players, assets and Core Media's times, and the
+        // `video` element their views draw (`AVPlayerLayer` is a UIKit layer).
+        .target(name: "AVFoundation", dependencies: ["AudioToolbox", "FoundationBridge", "UIKit", "SwiftUI"], path: "Sources/AVFoundation"),
+        // System sounds: registered, never played (no page-side audio yet).
+        .target(name: "AudioToolbox", dependencies: ["CoreFoundationTypes"], path: "Sources/AudioToolbox"),
+        // SF Symbols' effect types, declared in SwiftUI (which re-exports them on iOS).
+        .target(name: "Symbols", dependencies: ["SwiftUI"], path: "Sources/Symbols"),
+        // Quick Look previews open the file in a new tab (a `media` host request).
+        .target(name: "QuickLook", dependencies: ["FoundationBridge", "UIKit", "SwiftUI"], path: "Sources/QuickLook"),
+        .target(name: "AVKit", dependencies: ["AVFoundation", "UIKit", "SwiftUI"], path: "Sources/AVKit"),
+        // Signing in and web pages: the sign-in window is a popup whose
+        // redirect comes back through the page's callback page (docs/ops-protocol.md,
+        // "Signing in"), Safari's sheet a new tab, and a web view keeps its state.
+        .target(name: "AuthenticationServices", dependencies: ["FoundationBridge", "UIKit", "SwiftUI"], path: "Sources/AuthenticationServices"),
+        .target(name: "SafariServices", dependencies: ["FoundationBridge", "UIKit", "SwiftUI"], path: "Sources/SafariServices"),
+        .target(name: "WebKit", dependencies: ["FoundationBridge", "UIKit", "SwiftUI"], path: "Sources/WebKit"),
+        // Sharing and media: `Transferable` and its representations (under
+        // SwiftUI, which re-exports it), the photo library (which PhotosUI
+        // re-exports), link previews.
+        .target(name: "CoreTransferable", dependencies: ["UniformTypeIdentifiers"], path: "Sources/CoreTransferable"),
+        .target(name: "Photos", dependencies: ["FoundationBridge", "UIKit", "SwiftUI"], path: "Sources/Photos"),
+        .target(name: "LinkPresentation", dependencies: ["FoundationBridge", "UIKit", "SwiftUI"], path: "Sources/LinkPresentation"),
+        // Apple Intelligence: translation and the on-device language model.
+        .target(name: "Translation", dependencies: ["FoundationBridge", "SwiftUI"], path: "Sources/Translation"),
+        .target(name: "FoundationModels", dependencies: ["FoundationBridge", "SwiftUI"], path: "Sources/FoundationModels"),
     ]
 )

package/README.md

@@ -1,13 +1,11 @@
 # @swiftbrowser/swift
 
-The SwiftBrowser Swift package (the `SwiftUI` shim, `Charts`, `FoundationLite`
-for lean builds, `FoundationBridge` for full-Foundation builds and the
-`_FoundationCommon` they share) packaged for npm, so that `@swiftbrowser/cli` builds apps
-against exactly the shim version it was released with. The CLI's generated
-staging package depends on it by path (`swiftPackagePath()`).
+The SwiftBrowser Swift package (the `SwiftUI` shim, `Charts`, `SwiftData` and
+`FoundationBridge`, the browser's Foundation glue) packaged for npm, so that
+`@swiftbrowser/cli` builds apps against exactly the shim version it was
+released with. The CLI's generated staging package depends on it by path
+(`swiftPackagePath()`).
 
 In a repository checkout `Sources/` is not here; `swiftPackagePath()` then
-points at the repository root, whose package also declares the example
-executables (so an app named like one of them, `Counter` say, needs this
-package synced: `node packages/swift/sync-sources.mjs`). `npm pack` copies the
-sources in (`prepack`).
+points at the repository root, whose package declares the same libraries.
+`npm pack` copies the sources in (`prepack`).

package/Sources/AVFoundation/AVFoundation.swift

@@ -0,0 +1,131 @@
+// `import AVFoundation` for the browser: playback over the page's media
+// elements (docs/ops-protocol.md, "Video and audio").
+//
+// - `AVPlayer` (and `AVQueuePlayer`, `AVPlayerLooper`) is state that outlives
+//   views: the item, the rate, mute and volume, the last seek, the position
+//   the page last reported. The views that show it (AVKit's `VideoPlayer`,
+//   an `AVPlayerLayer` in a UIKit view, `AVPlayerViewController`) each draw a
+//   `video` element whose props are worked out from that state, and the
+//   page's `video` events (ready, time, status, ended, error, and what the
+//   viewer did with the native controls) come back to the player, which
+//   updates itself, calls its time observers and posts AVFoundation's
+//   notifications through the bridge's `NotificationCenter`.
+// - A player plays only while a view shows it: the newest view attached to a
+//   player plays it, the others show it paused and muted. A player shown
+//   nowhere keeps its rate and position and plays nothing.
+// - Assets are URLs. Remote, data and blob URLs go to the page as they are;
+//   a file URL (the app's bundle, home or temporary directory) is read and
+//   handed to the page as a blob (a `media` host request). `load(.duration)`
+//   asks the page to read the file's metadata (a `media` probe).
+// - `AVAudioSession` keeps its category and mode and succeeds: the browser
+//   mixes audio as it does. `AVAssetImageGenerator` fails (Swift holds no
+//   decoded frames), and `AVAssetExportSession` copies the file as it is,
+//   as `AVAssetExportPresetPassthrough` does, whatever the preset.
+//
+// As on iOS, it brings AudioToolbox (System Sound Services) and Core Media's
+// time types (CMTime.swift) along.
+@_exported import AudioToolbox
+@_exported import Foundation
+import FoundationBridge
+import SwiftUI
+import struct SwiftUI.CGSize
+import struct SwiftUI.CGRect
+import UIKit
+
+/// AVFoundation's error domain, for the errors this module reports as `NSError`.
+public let AVFoundationErrorDomain = "AVFoundationErrorDomain"
+
+/// AVFoundation's errors (the codes the shim reports).
+public struct AVError: Error, Hashable, Sendable, CustomStringConvertible {
+    public enum Code: Int, Sendable {
+        case unknown = -11800
+        case outOfMemory = -11801
+        case decodeFailed = -11821
+        case fileFormatNotRecognized = -11828
+        case fileFailedToParse = -11829
+        case noDataCaptured = -11805
+        case operationNotSupportedForAsset = -11838
+        case failedToLoadMediaData = -11849
+        case contentIsUnavailable = -11863
+        case exportFailed = -11820
+    }
+
+    public let code: Code
+    /// What the page or the shim said went wrong.
+    public let message: String
+
+    public init(_ code: Code, message: String = "") {
+        self.code = code
+        self.message = message
+    }
+
+    public static var unknown: Code { .unknown }
+    public static var decodeFailed: Code { .decodeFailed }
+    public static var fileFormatNotRecognized: Code { .fileFormatNotRecognized }
+    public static var operationNotSupportedForAsset: Code { .operationNotSupportedForAsset }
+    public static var failedToLoadMediaData: Code { .failedToLoadMediaData }
+    public static var contentIsUnavailable: Code { .contentIsUnavailable }
+
+    public var errorCode: Int { code.rawValue }
+    public var localizedDescription: String { message.isEmpty ? "The operation could not be completed" : message }
+    public var description: String { "AVError(\(code), \"\(message)\")" }
+
+    public static func == (lhs: AVError, rhs: AVError) -> Bool { lhs.code == rhs.code && lhs.message == rhs.message }
+    public func hash(into hasher: inout Hasher) { hasher.combine(code) }
+}
+
+/// `catch AVError.decodeFailed`-style matching on the code.
+public func ~= (code: AVError.Code, error: any Error) -> Bool {
+    (error as? AVError)?.code == code
+}
+
+/// A media type of a track.
+public struct AVMediaType: RawRepresentable, Hashable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+    public init(_ rawValue: String) { self.rawValue = rawValue }
+    public static let video = AVMediaType("vide")
+    public static let audio = AVMediaType("soun")
+    public static let text = AVMediaType("text")
+    public static let closedCaption = AVMediaType("clcp")
+    public static let subtitle = AVMediaType("sbtl")
+    public static let timecode = AVMediaType("tmcd")
+    public static let metadata = AVMediaType("meta")
+    public static let muxed = AVMediaType("muxx")
+}
+
+/// A container format, by its uniform type identifier.
+public struct AVFileType: RawRepresentable, Hashable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+    public init(_ rawValue: String) { self.rawValue = rawValue }
+    public static let mov = AVFileType("com.apple.quicktime-movie")
+    public static let mp4 = AVFileType("public.mpeg-4")
+    public static let m4v = AVFileType("com.apple.m4v-video")
+    public static let m4a = AVFileType("com.apple.m4a-audio")
+    public static let mp3 = AVFileType("public.mp3")
+    public static let wav = AVFileType("com.microsoft.waveform-audio")
+    public static let aiff = AVFileType("public.aiff-audio")
+    public static let caf = AVFileType("com.apple.coreaudio-format")
+    public static let heic = AVFileType("public.heic")
+    public static let jpg = AVFileType("public.jpeg")
+}
+
+/// The media type the page should be told for a file, from its extension.
+func _mimeType(forPathExtension pathExtension: String) -> String {
+    switch pathExtension.lowercased() {
+    case "mp4", "mpeg4": "video/mp4"
+    case "m4v": "video/x-m4v"
+    case "mov", "qt": "video/quicktime"
+    case "webm": "video/webm"
+    case "ogv": "video/ogg"
+    case "mp3": "audio/mpeg"
+    case "m4a", "aac": "audio/mp4"
+    case "wav": "audio/wav"
+    case "aif", "aiff": "audio/aiff"
+    case "caf": "audio/x-caf"
+    case "oga", "ogg", "opus": "audio/ogg"
+    case "gif": "image/gif"
+    default: "application/octet-stream"
+    }
+}