akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/native/ios/Sources/AkanNativeSchemeHandler.swift

@@ -0,0 +1,209 @@
+// app://localhost/* (docs/architecture.md §5). Routes, MIME types and Range requests are the
+// kernel's (AkanNativeKernel.swift, checked with the shared vectors).
+//
+// Stopped tasks: calling didReceive/didFinish on a stopped WKURLSchemeTask aborts the app
+// (verified). Live tasks are tracked in a set and every answer is sent on the main thread after
+// checking the set; stop also arrives on the main thread, so there is no race.
+//
+// akan-native dev --hmr (dev builds with shell.json `devServer`): every path outside /__akan_native/* is fetched
+// from the dev gateway on 127.0.0.1 (packages/cli/src/lib/hmr.ts) and answered on app://localhost,
+// so the bridge, storage and CSP see the usual origin. Without the gateway (akan-native dev ended) the
+// bundled files are served.
+
+import UIKit
+import WebKit
+
+@MainActor
+final class AkanNativeSchemeHandler: NSObject, WKURLSchemeHandler {
+    /// The web bundle being served: the app's own, or a downloaded one (UP-2, AkanNativeUpdates).
+    var root: URL {
+        didSet { root = root.standardizedFileURL }
+    }
+    /// akan-native dev --hmr: where pages come from instead of `root` (nil: the bundled files).
+    let devServer: URL?
+    private let initScript: () -> Data
+    private var active = Set<ObjectIdentifier>()
+    private var devWarned = false
+    private lazy var devSession: URLSession = {
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.requestCachePolicy = .reloadIgnoringLocalCacheData
+        configuration.urlCache = nil
+        configuration.timeoutIntervalForRequest = 60 // Bun bundles on the first request
+        return URLSession(configuration: configuration)
+    }()
+
+    init(root: URL, devServer: URL? = nil, initScript: @escaping () -> Data) {
+        self.root = root.standardizedFileURL
+        self.devServer = devServer
+        self.initScript = initScript
+    }
+
+    /// shell.json `devServer` (dev builds only): plain http to the loopback interface, or to a private
+    /// LAN address for an iPhone that reaches the Mac over Wi-Fi (O4-3).
+    nonisolated static func devServerURL(_ text: String) -> URL? {
+        guard let url = URL(string: text), url.scheme == "http", url.port != nil, let host = url.host else { return nil }
+        if ["127.0.0.1", "localhost"].contains(host) { return url }
+        let octets = host.split(separator: ".").compactMap { UInt8($0) }
+        guard octets.count == 4, host.split(separator: ".").count == 4 else { return nil }
+        let privateLan = octets[0] == 10 || (octets[0] == 172 && (16...31).contains(octets[1])) || (octets[0] == 192 && octets[1] == 168)
+        return privateLan ? url : nil
+    }
+
+
+    func webView(_ webView: WKWebView, start task: any WKURLSchemeTask) {
+        let key = ObjectIdentifier(task)
+        active.insert(key)
+        guard let url = task.request.url else { return respond(task, key, status: 400, mime: "text/plain", body: Data()) }
+        if let devServer, !AkanNativeKernel.isHostPath(url.path(percentEncoded: true)) {
+            return proxy(task, key, url: url, devServer: devServer)
+        }
+        serveLocal(task, key, url: url)
+    }
+
+    private func serveLocal(_ task: any WKURLSchemeTask, _ key: ObjectIdentifier, url: URL) {
+        let range = task.request.value(forHTTPHeaderField: "Range")
+        let root = self.root
+        let route = AkanNativeKernel.route(url.path(percentEncoded: true)) { relative in
+            var isDir: ObjCBool = false
+            let path = root.appendingPathComponent(relative).standardizedFileURL.path
+            return path.hasPrefix(root.path + "/") && FileManager.default.fileExists(atPath: path, isDirectory: &isDir) && !isDir.boolValue
+        }
+        switch route {
+        case .initScript:
+            respond(task, key, status: 200, mime: "text/javascript; charset=utf-8", body: initScript(), headers: ["Cache-Control": "no-store"])
+        case .file(let id):
+            guard let entry = AkanNativeFiles.shared.lookup(id) else { return notFound(task, key) }
+            serve(task, key, file: entry.url, mime: entry.mime, range: range, fileRef: true)
+        case .asset(let relative):
+            serve(task, key, file: root.appendingPathComponent(relative), mime: AkanNativeKernel.assetMime(relative), range: range)
+        case .ipc, .hello, .notFound: // the desktop's and Android's
+            notFound(task, key)
+        }
+    }
+
+    func webView(_ webView: WKWebView, stop task: any WKURLSchemeTask) {
+        active.remove(ObjectIdentifier(task))
+    }
+
+    // MARK: akan-native dev --hmr
+
+    /// Request headers not passed on: hop-by-hop, the gateway's own host, and validators (the gateway never
+    /// answers 304). Everything else goes, Authorization included, so the page's API calls work through it.
+    private static let devSkip: Set<String> = ["host", "connection", "keep-alive", "content-length", "accept-encoding", "if-none-match", "if-modified-since"]
+    /// Framing headers of the gateway's reply; respond() sets Content-Type and Content-Length itself.
+    private static let devDrop: Set<String> = ["connection", "keep-alive", "transfer-encoding", "content-length", "content-encoding", "content-type"]
+
+    private func proxy(_ task: any WKURLSchemeTask, _ key: ObjectIdentifier, url: URL, devServer: URL) {
+        var components = URLComponents()
+        components.scheme = devServer.scheme
+        components.host = devServer.host
+        components.port = devServer.port
+        let path = url.path(percentEncoded: true)
+        components.percentEncodedPath = path.isEmpty ? "/" : path
+        components.percentEncodedQuery = url.query(percentEncoded: true)
+        guard let target = components.url else { return serveLocal(task, key, url: url) }
+        var request = URLRequest(url: target)
+        request.httpMethod = task.request.httpMethod ?? "GET"
+        request.httpBody = Self.bodyOf(task.request)
+        for (name, value) in task.request.allHTTPHeaderFields ?? [:] where !Self.devSkip.contains(name.lowercased()) {
+            request.setValue(value, forHTTPHeaderField: name)
+        }
+        let box = UncheckedBox(task)
+        devSession.dataTask(with: request) { data, response, error in
+            let result = UncheckedBox((data, response as? HTTPURLResponse, error))
+            DispatchQueue.main.async {
+                MainActor.assumeIsolated {
+                    let (data, http, error) = result.value
+                    guard let http, let data else {
+                        if !self.devWarned {
+                            self.devWarned = true
+                            AkanNativeLog.info("dev server \(devServer.absoluteString): \(error?.localizedDescription ?? "no response"); serving the bundled files")
+                        }
+                        return self.serveLocal(box.value, key, url: url)
+                    }
+                    var headers: [String: String] = [:]
+                    for (name, value) in http.allHeaderFields {
+                        guard let name = name as? String, !Self.devDrop.contains(name.lowercased()) else { continue }
+                        headers[name] = "\(value)"
+                    }
+                    let mime = http.value(forHTTPHeaderField: "Content-Type") ?? AkanNativeKernel.assetMime(url.path)
+                    self.respond(box.value, key, status: http.statusCode, mime: mime, body: data, headers: headers)
+                }
+            }
+        }.resume()
+    }
+
+    /// WebKit hands a Blob or FormData body to the handler as a stream instead of `httpBody`.
+    private static func bodyOf(_ request: URLRequest) -> Data? {
+        if let body = request.httpBody { return body }
+        guard let stream = request.httpBodyStream else { return nil }
+        stream.open()
+        defer { stream.close() }
+        var data = Data()
+        var buffer = [UInt8](repeating: 0, count: 64 * 1024)
+        while true {
+            let read = stream.read(&buffer, maxLength: buffer.count)
+            if read <= 0 { break }
+            data.append(buffer, count: read)
+        }
+        return data
+    }
+
+    private func notFound(_ task: any WKURLSchemeTask, _ key: ObjectIdentifier) {
+        respond(task, key, status: 404, mime: "text/plain; charset=utf-8", body: Data("not found".utf8))
+    }
+
+    /// Reads off the main thread, answers on it. Single-range requests get 206 (IN-5), at most
+    /// maxRangeBytes (Tauri's 1000 KiB: media elements ask for the rest) of the mapped, not read, file.
+    /// `fileRef`: a file a plugin registered, whose content the app does not control. It is never the
+    /// app's document: no MIME sniffing, not for other origins, and anything but plain media opens
+    /// sandboxed, with an opaque origin the bridge refuses (AkanNativeKernel.fileRefSandboxed; N1).
+    private func serve(_ task: any WKURLSchemeTask, _ key: ObjectIdentifier, file: URL, mime: String, range: String?, fileRef: Bool = false) {
+        let box = UncheckedBox(task)
+        DispatchQueue.global(qos: .userInitiated).async {
+            var status = 200
+            var body = Data()
+            var headers = ["Accept-Ranges": "bytes", "Cache-Control": "no-cache"]
+            if fileRef {
+                headers["X-Content-Type-Options"] = "nosniff"
+                headers["Cross-Origin-Resource-Policy"] = "same-origin"
+                if AkanNativeKernel.fileRefSandboxed(mime) { headers["Content-Security-Policy"] = "sandbox" }
+            }
+            do {
+                let data = try Data(contentsOf: file, options: .mappedIfSafe)
+                switch AkanNativeKernel.parseRange(range, size: Int64(data.count)) {
+                case .whole:
+                    body = data
+                case .part(let first, let last):
+                    status = 206
+                    body = data.subdata(in: Int(first)..<Int(last + 1))
+                    headers["Content-Range"] = "bytes \(first)-\(last)/\(data.count)"
+                case .unsatisfiable:
+                    status = 416
+                    headers["Content-Range"] = "bytes */\(data.count)"
+                }
+            } catch {
+                status = 404
+                body = Data("not found".utf8)
+            }
+            let result = UncheckedBox((status, body, headers))
+            DispatchQueue.main.async {
+                MainActor.assumeIsolated {
+                    let (status, body, headers) = result.value
+                    self.respond(box.value, key, status: status, mime: status == 404 ? "text/plain; charset=utf-8" : mime, body: body, headers: headers)
+                }
+            }
+        }
+    }
+
+    private func respond(_ task: any WKURLSchemeTask, _ key: ObjectIdentifier, status: Int, mime: String, body: Data, headers: [String: String] = [:]) {
+        guard active.remove(key) != nil, let url = task.request.url else { return } // stopped meanwhile
+        var all = headers
+        all["Content-Type"] = mime
+        all["Content-Length"] = String(body.count)
+        let response = HTTPURLResponse(url: url, statusCode: status, httpVersion: "HTTP/1.1", headerFields: all)!
+        task.didReceive(response)
+        task.didReceive(body)
+        task.didFinish()
+    }
+}

package/vendor/@akanjs/native/native/ios/Sources/AkanNativeShell.swift

@@ -0,0 +1,161 @@
+// Shell configuration, logging and the session file registry.
+
+import UIKit
+import os
+
+enum AkanNativeLog {
+    private static let logger = Logger(subsystem: "com.akanjs", category: "shell")
+
+    /// stdout reaches `simctl launch --console-pty` (akan-native run ios); os_log reaches `log stream`.
+    static func info(_ text: String) {
+        print("[akan-native] \(text)")
+        fflush(stdout)
+        logger.info("\(text, privacy: .public)")
+    }
+
+    static func page(_ level: String, _ text: String) {
+        print("[page \(level)] \(text)")
+        fflush(stdout)
+        logger.info("[page \(level, privacy: .public)] \(text, privacy: .public)")
+    }
+}
+
+/// Files written by `akan-native build` next to the executable: boot.json, env.runtime.json, shell.json.
+struct AkanNativeShellConfig {
+    var backgroundColor: UIColor
+    var devtools: Bool
+    var hideFormAccessoryBar: Bool
+    /// keyboard.resize (O6-1): the keyboard mode from the first frame, until keyboard.setResizeMode.
+    var keyboardResizes: Bool
+    var dev: Bool
+    /** Launch screen cover (SH-6): hide after the first page load, and at the latest after the timeout. */
+    var splashAutoHide: Bool
+    var splashTimeout: TimeInterval
+    /// akan-native dev --hmr (dev builds only): the dev gateway pages are fetched from (AkanNativeSchemeHandler).
+    var devServer: URL?
+    /// Dev builds only (O4-5): the first page's path and query on the app's origin.
+    var startPath: String
+    /// security.shell.externalSchemes (L0): schemes links and the opener may also hand to the system.
+    var externalSchemes: [String]
+
+    /// A path on the app's origin, never one of akan-native's own (/__akan_native/*); anything else is "/".
+    static func startPath(_ text: String?) -> String {
+        guard let text, text.hasPrefix("/"), !text.hasPrefix("//"), !text.hasPrefix("/__akan_native"), !text.contains(where: \.isWhitespace) else { return "/" }
+        return text
+    }
+
+    static func load() -> AkanNativeShellConfig {
+        let shell = AkanNativeResources.json("shell.json")
+        let light = UIColor(hex: shell["backgroundColor"] as? String ?? "") ?? .systemBackground
+        let dark = UIColor(hex: shell["backgroundColorDark"] as? String ?? "") ?? light
+        let boot = AkanNativeResources.json("boot.json")
+        let splash = shell["splash"] as? [String: Any] ?? [:]
+        let dev = boot["dev"] as? Bool ?? false
+        return AkanNativeShellConfig(
+            backgroundColor: UIColor { $0.userInterfaceStyle == .dark ? dark : light },
+            devtools: shell["devtools"] as? Bool ?? false,
+            hideFormAccessoryBar: shell["hideFormAccessoryBar"] as? Bool ?? false,
+            keyboardResizes: shell["keyboardResize"] as? String != "none",
+            dev: dev,
+            splashAutoHide: splash["autoHide"] as? Bool ?? true,
+            splashTimeout: (splash["timeout"] as? Double ?? 10_000) / 1000,
+            devServer: dev ? (shell["devServer"] as? String).flatMap(AkanNativeSchemeHandler.devServerURL) : nil,
+            startPath: dev ? AkanNativeShellConfig.startPath(shell["startPath"] as? String) : "/",
+            externalSchemes: shell["externalSchemes"] as? [String] ?? []
+        )
+    }
+}
+
+/// What the shell hands to the system (L0) and how often: the page's links and window.open, and the
+/// opener, share one limit of externalOpensPerSecond, so a page cannot flood the device with other apps.
+@MainActor
+enum AkanNativeExternal {
+    /// http, https, mailto, tel and security.shell.externalSchemes (never the forbidden ones).
+    static let schemes: [String] = AkanNativeKernel.externalSchemes(AkanNativeShellConfig.load().externalSchemes)
+    private static var last = Date.distantPast
+
+    /// Whether an open may happen now; counts it when it may.
+    static func allowed() -> Bool {
+        let now = Date()
+        guard now.timeIntervalSince(last) >= 1 / Double(AkanNativeContract.externalOpensPerSecond) else { return false }
+        last = now
+        return true
+    }
+}
+
+enum AkanNativeResources {
+    static func url(_ name: String) -> URL { Bundle.main.bundleURL.appendingPathComponent(name) }
+
+    static func text(_ name: String) -> String {
+        (try? String(contentsOf: url(name), encoding: .utf8)) ?? "{}"
+    }
+
+    static func json(_ name: String) -> [String: Any] {
+        guard let data = try? Data(contentsOf: url(name)),
+              let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return [:] }
+        return object
+    }
+}
+
+extension UIColor {
+    convenience init?(hex: String) {
+        var s = hex.trimmingCharacters(in: .whitespaces)
+        if s.hasPrefix("#") { s.removeFirst() }
+        guard s.count == 6 || s.count == 8, let v = UInt64(s, radix: 16) else { return nil }
+        let (r, g, b, a) = s.count == 6
+            ? ((v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff, UInt64(0xff))
+            : ((v >> 24) & 0xff, (v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff)
+        self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255)
+    }
+}
+
+/// Files served at /__akan_native/file/<id> for the app session (PL-7).
+final class AkanNativeFiles: @unchecked Sendable {
+    static let shared = AkanNativeFiles()
+    private let lock = NSLock()
+    private var files: [String: (url: URL, mime: String)] = [:]
+
+    let directory = FileManager.default.temporaryDirectory.appendingPathComponent("akan-native-files", isDirectory: true)
+
+    /// Called at launch: files of an earlier session are no longer reachable anyway.
+    func resetSessionDirectory() {
+        try? FileManager.default.removeItem(at: directory)
+        try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+    }
+
+    func register(_ url: URL, mime: String) -> String {
+        // ASCII letters and digits only: the route accepts no other id (AkanNativeKernel.isFileRefId).
+        let ext = url.pathExtension.lowercased().filter { AkanNativeContract.idFileRef.extChars.contains($0) }.prefix(AkanNativeContract.idFileRef.extMax)
+        let id = UUID().uuidString.lowercased() + (ext.isEmpty ? "" : ".\(ext)")
+        lock.lock()
+        files[id] = (url, mime)
+        lock.unlock()
+        return "/__akan_native/file/\(id)"
+    }
+
+    func lookup(_ id: String) -> (url: URL, mime: String)? {
+        lock.lock()
+        defer { lock.unlock() }
+        return files[id]
+    }
+
+    /// Stops serving a FileRef ($bridge.release). A file in the session folder is akan-native's own copy
+    /// (a photo, a download) and is deleted; other files belong to the user and stay.
+    func release(_ id: String) -> Bool {
+        lock.lock()
+        let entry = files.removeValue(forKey: id)
+        lock.unlock()
+        guard let entry else { return false }
+        if entry.url.standardizedFileURL.path.hasPrefix(directory.standardizedFileURL.path + "/") {
+            try? FileManager.default.removeItem(at: entry.url)
+        }
+        return true
+    }
+
+    /// How many FileRefs are served (K13).
+    var count: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return files.count
+    }
+}

package/vendor/@akanjs/native/native/ios/Sources/AkanNativeSpec.swift

@@ -0,0 +1,143 @@
+// Runtime side of the plugin bindings akan-native generates from a plugin's TypeScript spec (PL-10):
+// decoding call arguments with the field path in the INVALID_ARGS message, and typed replies.
+
+import Foundation
+
+struct AkanNativeArgsError: Error {
+    let message: String
+}
+
+/// Decoders used by the generated `init(akan-native:at:)` of argument types.
+enum AkanNativeJSON {
+    static func key(_ path: String, _ name: String) -> String { path.isEmpty ? name : "\(path).\(name)" }
+
+    static func isNull(_ value: Any?) -> Bool { value == nil || value is NSNull }
+
+    /// JSON booleans arrive as NSNumber too; only CFBoolean ones are true/false.
+    private static func isBool(_ n: NSNumber) -> Bool { CFGetTypeID(n as CFTypeRef) == CFBooleanGetTypeID() }
+
+    private static func fail(_ value: Any?, _ path: String, _ expected: String) -> AkanNativeArgsError {
+        let name = path.isEmpty ? "the argument" : path
+        return AkanNativeArgsError(message: isNull(value) ? "\(name) is required" : "\(name) must be \(expected)")
+    }
+
+    static func object(_ value: Any?, _ path: String) throws -> [String: Any] {
+        guard let o = value as? [String: Any] else { throw fail(value, path, "an object") }
+        return o
+    }
+
+    static func string(_ value: Any?, _ path: String) throws -> String {
+        guard let s = value as? String else { throw fail(value, path, "a string") }
+        return s
+    }
+
+    static func number(_ value: Any?, _ path: String) throws -> Double {
+        guard let n = value as? NSNumber, !isBool(n), n.doubleValue.isFinite else { throw fail(value, path, "a number") }
+        return n.doubleValue
+    }
+
+    static func bool(_ value: Any?, _ path: String) throws -> Bool {
+        guard let n = value as? NSNumber, isBool(n) else { throw fail(value, path, "true or false") }
+        return n.boolValue
+    }
+
+    /// TS `unknown`: any JSON value, null included (NSNull).
+    static func any(_ value: Any?, _ path: String) throws -> Any {
+        value ?? NSNull()
+    }
+
+    static func literal<E: RawRepresentable & CaseIterable>(_ value: Any?, _ path: String, _ type: E.Type) throws -> E where E.RawValue == String {
+        guard let s = value as? String, let e = E(rawValue: s) else {
+            throw fail(value, path, "one of " + E.allCases.map(\.rawValue).joined(separator: ", "))
+        }
+        return e
+    }
+
+    static func array<T>(_ value: Any?, _ path: String, _ item: (Any?, String) throws -> T) throws -> [T] {
+        guard let a = value as? [Any] else { throw fail(value, path, "an array") }
+        return try a.enumerated().map { try item($1, "\(path)[\($0)]") }
+    }
+
+    static func map<T>(_ value: Any?, _ path: String, _ item: (Any?, String) throws -> T) throws -> [String: T] {
+        let o = try object(value, path)
+        var out: [String: T] = [:]
+        for (k, v) in o { out[k] = try item(v, key(path, k)) }
+        return out
+    }
+
+    /// Missing and null both mean "not given" for optional fields.
+    static func optional<T>(_ value: Any?, _ decode: (Any?) throws -> T) rethrows -> T? {
+        isNull(value) ? nil : try decode(value)
+    }
+
+    /// Decodes a call's arguments, or rejects it with INVALID_ARGS and returns nil.
+    static func decode<T>(_ call: AkanNativeCall, _ decode: ([String: Any]) throws -> T) -> T? {
+        do {
+            return try decode(call.args)
+        } catch let error as AkanNativeArgsError {
+            call.reject(.invalidArgs, error.message)
+        } catch {
+            call.reject(.invalidArgs, "\(error)")
+        }
+        return nil
+    }
+}
+
+/// A typed answer to one call. Like AkanNativeCall, resolve or reject once, from any thread. `call` is
+/// there for what the types do not cover, e.g. `call.inScope(...)` (PL-11).
+final class AkanNativeReply<T>: @unchecked Sendable {
+    let call: AkanNativeCall
+    private let encode: @Sendable (T) -> Any?
+
+    init(_ call: AkanNativeCall, _ encode: @escaping @Sendable (T) -> Any?) {
+        self.call = call
+        self.encode = encode
+    }
+
+    func resolve(_ value: T) { call.resolve(encode(value)) }
+
+    func reject(_ code: AkanNativeErrorCode, _ message: String, data: Any? = nil, retryable: Bool = false) {
+        call.reject(code, message, data: data, retryable: retryable)
+    }
+
+    /// See AkanNativeCall.onCancel.
+    @MainActor
+    func onCancel(_ handler: @escaping @MainActor () -> Void) { call.onCancel(handler) }
+
+    var isCancelled: Bool { call.isCancelled }
+}
+
+extension AkanNativeReply where T == Void {
+    func resolve() { call.resolve() }
+}
+
+/// A file served at /__akan_native/file/<id> (PL-7): `FileRef` in plugin specs. Generated types that
+/// extend FileRef take one in `init(file:…)`.
+struct AkanNativeFileRef: Sendable, Equatable {
+    var url: String
+    var mime: String
+    var size: Double
+
+    init(url: String, mime: String, size: Double) {
+        self.url = url
+        self.mime = mime
+        self.size = size
+    }
+
+    init(akanNative value: Any?, at path: String) throws {
+        let o = try AkanNativeJSON.object(value, path)
+        url = try AkanNativeJSON.string(o["url"], AkanNativeJSON.key(path, "url"))
+        mime = try AkanNativeJSON.string(o["mime"], AkanNativeJSON.key(path, "mime"))
+        size = try AkanNativeJSON.number(o["size"], AkanNativeJSON.key(path, "size"))
+    }
+
+    var akanNativeJSON: [String: Any] { ["url": url, "mime": mime, "size": size] }
+}
+
+extension AkanNativePluginContext {
+    /// registerFile, as the typed FileRef of generated result types.
+    func fileRef(_ url: URL, mime: String) -> AkanNativeFileRef {
+        let ref = registerFile(url, mime: mime)
+        return AkanNativeFileRef(url: ref["url"] as? String ?? "", mime: mime, size: (ref["size"] as? NSNumber)?.doubleValue ?? 0)
+    }
+}