craft-native 0.0.436 → 0.0.442

package/dist/ios/templates/CraftNativePedometer.swift

@@ -0,0 +1,181 @@
+import Foundation
+#if CRAFT_PERMISSION_MOTION
+import CoreMotion
+#endif
+
+struct CraftPedometerSample {
+    let startDate: Double
+    let endDate: Double
+    let steps: Int
+    var distanceMeters: Double?
+    var cadenceStepsPerSecond: Double?
+    var paceSecondsPerMeter: Double?
+    var averageActivePaceSecondsPerMeter: Double?
+    var floorsAscended: Int?
+    var floorsDescended: Int?
+
+    var payload: [String: Any] {
+        var value: [String: Any] = ["state": "sample", "kind": "interval", "startDate": startDate, "endDate": endDate, "steps": steps]
+        if let distanceMeters { value["distanceMeters"] = distanceMeters }
+        if let cadenceStepsPerSecond { value["cadenceStepsPerSecond"] = cadenceStepsPerSecond }
+        if let paceSecondsPerMeter { value["paceSecondsPerMeter"] = paceSecondsPerMeter }
+        if let averageActivePaceSecondsPerMeter { value["averageActivePaceSecondsPerMeter"] = averageActivePaceSecondsPerMeter }
+        if let floorsAscended { value["floorsAscended"] = floorsAscended }
+        if let floorsDescended { value["floorsDescended"] = floorsDescended }
+        return value
+    }
+}
+
+protocol CraftPedometerSource: AnyObject {
+    var availability: [String: Bool] { get }
+    var permission: String { get }
+    func start(from: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void)
+    func query(from: Date, to: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void)
+    func stop()
+}
+
+#if CRAFT_PERMISSION_MOTION
+private final class CraftCoreMotionPedometer: CraftPedometerSource {
+    private let pedometer = CMPedometer()
+    var availability: [String: Bool] {
+        ["steps": CMPedometer.isStepCountingAvailable(), "distance": CMPedometer.isDistanceAvailable(),
+         "floors": CMPedometer.isFloorCountingAvailable(), "cadence": CMPedometer.isCadenceAvailable(),
+         "pace": CMPedometer.isPaceAvailable(), "history": CMPedometer.isStepCountingAvailable(), "background": false]
+    }
+    var permission: String {
+        switch CMPedometer.authorizationStatus() {
+        case .authorized: return "granted"
+        case .denied: return "denied"
+        case .restricted: return "restricted"
+        case .notDetermined: return "notDetermined"
+        @unknown default: return "unavailable"
+        }
+    }
+    private func handler(_ receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) -> CMPedometerHandler {
+        { data, error in
+            let result: Result<CraftPedometerSample, Error>
+            if let error { result = .failure(error) }
+            else if let data {
+                result = .success(CraftPedometerSample(startDate: data.startDate.timeIntervalSince1970 * 1000,
+                    endDate: data.endDate.timeIntervalSince1970 * 1000, steps: data.numberOfSteps.intValue,
+                    distanceMeters: data.distance?.doubleValue, cadenceStepsPerSecond: data.currentCadence?.doubleValue,
+                    paceSecondsPerMeter: data.currentPace?.doubleValue, averageActivePaceSecondsPerMeter: data.averageActivePace?.doubleValue,
+                    floorsAscended: data.floorsAscended?.intValue, floorsDescended: data.floorsDescended?.intValue))
+            } else { result = .failure(NSError(domain: "CraftPedometer", code: 1, userInfo: [NSLocalizedDescriptionKey: "Pedometer returned no data"])) }
+            DispatchQueue.main.async { receive(result) }
+        }
+    }
+    func start(from: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) {
+        pedometer.startUpdates(from: from, withHandler: handler(receive))
+    }
+    func query(from: Date, to: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) {
+        pedometer.queryPedometerData(from: from, to: to, withHandler: handler(receive))
+    }
+    func stop() { pedometer.stopUpdates() }
+}
+#endif
+
+private final class CraftUnavailablePedometer: CraftPedometerSource {
+    var availability: [String: Bool] { ["steps": false, "distance": false, "floors": false, "cadence": false, "pace": false, "history": false, "background": false] }
+    var permission: String { "unavailable" }
+    func start(from: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) {}
+    func query(from: Date, to: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) {}
+    func stop() {}
+}
+
+/// Interval counts are never relabelled as Android's counter since boot.
+final class CraftNativePedometer {
+    typealias Completion = (Result<Any, CraftNativeActionError>) -> Void
+    private let makeSource: () -> CraftPedometerSource
+    private let now: () -> Date
+    private var live: CraftPedometerSource?
+    private var pending = [String: CraftPedometerSource]()
+    private var closed = false
+    var emit: ([String: Any]) -> Void = { _ in }
+
+    init(makeSource: (() -> CraftPedometerSource)? = nil, now: @escaping () -> Date = Date.init) {
+        self.now = now
+        self.makeSource = makeSource ?? {
+            #if CRAFT_PERMISSION_MOTION
+            return CraftCoreMotionPedometer()
+            #else
+            return CraftUnavailablePedometer()
+            #endif
+        }
+    }
+
+    func perform(method: String, args: [Any], token: String, completion: @escaping Completion) {
+        guard !closed else { return completion(failure("HOST_CLOSED", "Pedometer host is closed")) }
+        if method == "stop" { completion(.success(stop(reason: "requested"))); return }
+        let source = makeSource()
+        if method == "getAvailability" { completion(.success(source.availability)); return }
+        if method == "getPermissionStatus" { completion(.success(source.permission)); return }
+        guard ["start", "query", "requestPermission"].contains(method) else { return completion(failure("UNKNOWN_ACTION", "Unsupported Pedometer method")) }
+        guard source.availability["steps"] == true else { return completion(failure("UNAVAILABLE", "Step counting is not present")) }
+        if method == "requestPermission", ["granted", "denied", "restricted"].contains(source.permission) {
+            completion(.success(source.permission)); return
+        }
+        guard !["denied", "restricted"].contains(source.permission) else { return completion(failure("PERMISSION_DENIED", "Motion access was denied or restricted")) }
+        guard args.isEmpty || args.first is [String: Any] else { return completion(failure("INVALID_ARGUMENT", "Pedometer options must be an object")) }
+        let options = args.first as? [String: Any] ?? [:]
+        if let background = options["background"] {
+            guard let flag = background as? NSNumber, CFGetTypeID(flag) == CFBooleanGetTypeID() else { return completion(failure("INVALID_ARGUMENT", "background must be boolean")) }
+            if flag.boolValue { return completion(failure("UNSUPPORTED", "Background pedometer streaming is not supported")) }
+        }
+        let current = now().timeIntervalSince1970 * 1000
+        let first: Double, last: Double
+        if method == "requestPermission" { first = current - 1000; last = current }
+        else {
+            guard let start = date(options["startDate"] ?? (method == "start" ? current : NSNull())),
+                  let end = date(options["endDate"] ?? current), start >= current - 7 * 86400 * 1000,
+                  start <= current, end <= current, (method == "start" ? start <= end : start < end) else {
+                return completion(failure("INVALID_ARGUMENT", "Dates must describe an interval within the last seven days"))
+            }
+            first = start; last = end
+        }
+        if method == "start" {
+            let previous = live
+            live = source
+            source.start(from: Date(timeIntervalSince1970: first / 1000)) { [weak self, weak source] result in
+                guard let self, let source, !self.closed, self.live === source else { return }
+                switch result {
+                case .success(let sample): self.emit(sample.payload)
+                case .failure: self.stop(reason: ["denied", "restricted"].contains(source.permission) ? "permissionDenied" : "sensorError")
+                }
+            }
+            previous?.stop()
+            completion(.success(true))
+        } else {
+            pending[token] = source
+            source.query(from: Date(timeIntervalSince1970: first / 1000), to: Date(timeIntervalSince1970: last / 1000)) { [weak self, weak source] result in
+                guard let self, let source, !self.closed, self.pending[token] === source else { return }
+                self.pending.removeValue(forKey: token)
+                if method == "requestPermission", ["granted", "denied", "restricted"].contains(source.permission) {
+                    completion(.success(source.permission)); return
+                }
+                switch result {
+                case .success(let sample): completion(.success(method == "requestPermission" ? source.permission as Any : sample.payload))
+                case .failure(let error): completion(self.failure(["denied", "restricted"].contains(source.permission) ? "PERMISSION_DENIED" : "SENSOR_ERROR", error.localizedDescription))
+                }
+            }
+        }
+    }
+
+    private func date(_ value: Any) -> Double? {
+        guard let value = value as? NSNumber, CFGetTypeID(value) != CFBooleanGetTypeID(), value.doubleValue.isFinite else { return nil }
+        return value.doubleValue
+    }
+    func cancel(_ token: String) { pending.removeValue(forKey: token) }
+    @discardableResult func stop(reason: String) -> Bool {
+        guard let previous = live else { return false }
+        live = nil
+        previous.stop()
+        emit(["state": "stopped", "reason": reason])
+        return true
+    }
+    func close() { closed = true; pending.removeAll(); stop(reason: "disposed"); emit = { _ in } }
+    deinit { live?.stop() }
+    private func failure(_ code: String, _ message: String) -> Result<Any, CraftNativeActionError> {
+        .failure(CraftNativeActionError(code: code, message: message))
+    }
+}

package/dist/ios/templates/CraftNativeScreen.swift

@@ -6191,6 +6191,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var inputIdentities: [ObjectIdentifier: String] = [:]
     private var inputDrafts: [String: String] = [:]
     private var longPressHandlers: [ObjectIdentifier: String] = [:]
+    private var accessibilityActionHandlers: [ObjectIdentifier: String] = [:]
     private var textMaxLengths: [ObjectIdentifier: Int] = [:]
     private var scrollHandlers: [ObjectIdentifier: String] = [:]
     private var scrollBeginHandlers: [ObjectIdentifier: String] = [:]
@@ -6259,6 +6260,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private let audio = CraftWebAudio()
     /// `craft.audio`'s sounds and the streaming responses this screen reads.
     private let sounds = CraftNativeSounds()
+    private let barometer = CraftNativeBarometer()
+    private let pedometer = CraftNativePedometer()
     private let streams = CraftNativeEventStreams()
     /// A request a screen-owned module answers, by request token, and how to
     /// call it off when it times out or is cancelled.
@@ -6595,6 +6598,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         audio.close()
         sounds.close()
+        barometer.close()
+        pedometer.close()
         streams.close()
         screenRequestCancellers.values.forEach { $0() }
         screenRequestCancellers.removeAll()
@@ -8037,6 +8042,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             guard let name = notification.userInfo?["event"] as? String else { return }
             self?.send(type: "CRAFT_EVENT", payload: ["event": name, "detail": notification.userInfo?["detail"] ?? [:]])
         })
+        pedometer.emit = { [weak self] detail in self?.send(type: "CRAFT_EVENT", payload: ["event": "craftPedometerUpdate", "detail": detail]) }
+        barometer.emit = { [weak self] detail in self?.send(type: "CRAFT_EVENT", payload: ["event": "craftBarometerUpdate", "detail": detail]) }
         sounds.emit = { [weak self] payload in self?.send(type: "SOUND_EVENT", payload: payload) }
         streams.emit = { [weak self] payload in self?.send(type: "NETWORK_STREAM", payload: payload) }
         sendAppState(CraftNativeActions.currentAppState())
@@ -8201,6 +8208,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     private func sendAppState(_ state: String) {
+        if state != "active" { barometer.stop(reason: "background"); pedometer.stop(reason: "background") }
         // A screen hears it while it is on top of its stack; the app script,
         // which is on no stack, always.
         guard isAppScript || navigationController?.topViewController === self else { return }
@@ -8412,6 +8420,29 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         let id = args.first as? String ?? ""
         switch (module, method) {
+        case ("Pedometer", _):
+            if !config.enablePedometer {
+                reply(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "Pedometer is disabled")))
+            } else if isAppScript {
+                reply(.failure(CraftNativeActionError(code: "NEEDS_ACTIVITY", message: "Pedometer needs a visible app")))
+            } else if ["start", "requestPermission"].contains(method) && UIApplication.shared.applicationState != .active {
+                reply(.failure(CraftNativeActionError(code: "APP_INACTIVE", message: "Pedometer needs a foreground app")))
+            } else {
+                screenRequestCancellers[requestToken] = { [weak self] in self?.pedometer.cancel(requestToken) }
+                pedometer.perform(method: method, args: args, token: requestToken, completion: reply)
+            }
+            return true
+        case ("Barometer", _):
+            if !config.enableBarometer {
+                reply(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "Barometer is disabled")))
+            } else if isAppScript {
+                reply(.failure(CraftNativeActionError(code: "NEEDS_ACTIVITY", message: "Barometer needs a visible app")))
+            } else if method == "start" && UIApplication.shared.applicationState != .active {
+                reply(.failure(CraftNativeActionError(code: "APP_INACTIVE", message: "Barometer needs a foreground app")))
+            } else {
+                reply(barometer.perform(method: method, args: args))
+            }
+            return true
         case ("AudioRecording", _):
             guard config.enableAudioRecording else {
                 reply(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "Audio recording is disabled")))
@@ -9400,6 +9431,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         result.craftPointerEvents = CraftNativePointerEvents.resolve(props: props, style: style)
         applyAccessibility(props, type: type, to: result)
+        // After applyAccessibility: it settles whether the view is an element
+        // at all, and an action on a non-element is unreachable.
+        updateAccessibilityActions(props["accessibilityActions"], handler: props["disabled"] as? Bool == true ? nil : events["onAccessibilityAction"], for: result)
         (result as? CraftNativeFlowView)?.configureCelebration(props["celebration"])
         return current
     }
@@ -9882,6 +9916,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         inputEventCounts.removeValue(forKey: id)
         if node.type == "TextInput" && !preservingInputDrafts { inputDrafts.removeValue(forKey: node.identity) }
         longPressHandlers.removeValue(forKey: id)
+        accessibilityActionHandlers.removeValue(forKey: id)
         textMaxLengths.removeValue(forKey: id)
         scrollHandlers.removeValue(forKey: id)
         scrollBeginHandlers.removeValue(forKey: id)
@@ -10099,6 +10134,47 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
     }
 
+    /// What a hold offers, published where the rotor can reach it.
+    ///
+    /// A long press is invisible to VoiceOver: nothing announces that it is
+    /// there and nothing can perform it, so an action living only behind a
+    /// hold does not exist for anyone driving the screen by assistive
+    /// technology. A thread that holds a message for Copy and Report is the
+    /// case this was written for; without this the honest mitigation is a
+    /// permanently visible button under every message.
+    ///
+    /// Shape follows the rest of the accessibility props: `name` identifies
+    /// the action to the handler, `label` is what a person hears, and the
+    /// event says which one ran so one handler can serve them all.
+    private func updateAccessibilityActions(_ raw: Any?, handler: String?, for view: UIView) {
+        let id = ObjectIdentifier(view)
+        let entries = (raw as? [[String: Any]] ?? []).compactMap { entry -> (name: String, label: String)? in
+            guard let name = entry["name"] as? String, !name.isEmpty else { return nil }
+            return (name, (entry["label"] as? String).flatMap { $0.isEmpty ? nil : $0 } ?? name)
+        }
+        guard let handler, !handler.isEmpty, !entries.isEmpty else {
+            accessibilityActionHandlers.removeValue(forKey: id)
+            view.accessibilityCustomActions = nil
+            return
+        }
+        accessibilityActionHandlers[id] = handler
+        view.accessibilityCustomActions = entries.map { entry in
+            UIAccessibilityCustomAction(name: entry.label) { [weak self, weak view] _ in
+                // Read the handler at firing time: a reconcile can rename it
+                // while the rotor sits on the element.
+                guard let self, let view, let current = self.accessibilityActionHandlers[ObjectIdentifier(view)] else { return false }
+                self.send(type: "EVENT", payload: ["handlerName": current, "nativeEvent": ["actionName": entry.name]])
+                return true
+            }
+        }
+        // The rotor only lands on an element, and actions on a view it walks
+        // straight through are actions nobody can get to. A bubble whose own
+        // label is its text is exactly that case.
+        if !view.isAccessibilityElement && view.accessibilityElements == nil && view.accessibilityLabel != nil {
+            view.isAccessibilityElement = true
+        }
+    }
+
     /// Legacy runtimes echo values without a revision. Keep their bounded
     /// history on either script thread; bridge delivery may still be delayed.
     private var unechoedText: [ObjectIdentifier: [String]] = [:]

package/dist/macos/src/index.js

@@ -43,7 +43,7 @@ import process from "process";
 var macosToolchain = {
   zig: "0.18.0-dev.252+86dc5ce25",
   sources: {
-    "zig-js": { repository: "zig-utils/zig-js", revision: "44a0a2ba814a911ac701c44073bd8d7d8ff6a22d", paths: ["src", "include", "tests", "tools", "docs", "bench", "conformance"] },
+    "zig-js": { repository: "zig-utils/zig-js", revision: "95d835edcbad55a7456cff76a9bb7ef6cdf265fc", paths: ["src", "include", "tests", "tools", "docs", "bench", "conformance"] },
     "zig-regex": { repository: "zig-utils/zig-regex", revision: "fdd9c2e333ea6ac2fd06d080d939ef7f11d61b1b", paths: ["src"] },
     "zig-gc": { repository: "zig-utils/zig-gc", revision: "73c802e05768a729614e9c4296abb118aa06faf9", paths: ["src"] }
   }

package/dist/macos/src/toolchain.d.ts

@@ -9,7 +9,7 @@ export declare const macosToolchain: {
     readonly sources: {
         readonly 'zig-js': {
             readonly repository: 'zig-utils/zig-js';
-            readonly revision: '44a0a2ba814a911ac701c44073bd8d7d8ff6a22d';
+            readonly revision: '95d835edcbad55a7456cff76a9bb7ef6cdf265fc';
             readonly paths: readonly ['src', 'include', 'tests', 'tools', 'docs', 'bench', 'conformance'];
         };
         readonly 'zig-regex': {

package/dist/macos/templates/CraftMacApplication.swift

@@ -1,5 +1,6 @@
 import AppKit
 import AVKit
+import ZigJS
 import CoreImage
 import UserNotifications
 import UniformTypeIdentifiers
@@ -23,19 +24,31 @@ final class CraftMacScene: NSObject, NSWindowDelegate {
     var holdsQuit = false
     /// The content width the screen last heard, so a resize that changes nothing sends nothing.
     var reportedViewportWidth: CGFloat = -1
-    init(name: String, route: String, options: [String: Any], application: CraftMacApplication) {
+    /// The content size the screen started with, which the window corrects once it shows.
+    let startedViewport: CGSize
+    private var shown = false
+    /// How long a window waits for its screen's first tree before it opens without it.
+    static let firstTreeGrace: TimeInterval = 0.5
+    /// `runtime` is the screen already started for this window (the main one starts before AppKit has
+    /// launched); without one the screen starts here, and evaluates its bundle while the window is made.
+    init(name: String, route: String, options: [String: Any], application: CraftMacApplication, runtime prepared: CraftMacRuntime? = nil) {
+        CraftTrace.mark("scene \(name)")
         self.name = name
-        runtime = CraftMacRuntime(route: route, params: options["params"] as? [String: Any] ?? [:], network: application.network)
-        renderer = CraftMacRenderer(runtime: runtime)
         let width = number(options["width"]) ?? 1120, height = number(options["height"]) ?? 740
         let transparent = (options["titlebarStyle"] as? String ?? application.titlebarStyle) == "transparent"
+        let viewport = Self.contentSize(options: options, application: application, name: name)
+        runtime = prepared ?? application.startScreen(route: route, options: options, viewport: viewport, colorScheme: CraftMacColor.isDark ? "dark" : "light")
+        reportedViewportWidth = viewport.width
+        startedViewport = viewport
+        renderer = CraftMacRenderer(runtime: runtime)
         let lights = options["trafficLights"] as? [Any] ?? (name == "main" ? application.trafficLights : nil)
         trafficLights = lights.flatMap { values in values.count == 2 ? number(values[0]).flatMap { x in number(values[1]).map { CGPoint(x: x, y: $0) } } : nil }
-        let panel = CraftMacWindow(contentRect: CGRect(x: 0, y: 0, width: width, height: height), styleMask: transparent ? [.titled, .closable, .resizable, .miniaturizable, .fullSizeContentView] : [.titled, .closable, .resizable, .miniaturizable], backing: .buffered, defer: false)
+        let panel = CraftMacWindow(contentRect: CGRect(x: 0, y: 0, width: width, height: height), styleMask: transparent ? [.titled, .closable, .resizable, .miniaturizable, .fullSizeContentView] : [.titled, .closable, .resizable, .miniaturizable], backing: .buffered, defer: true)
         panel.runtime = runtime
         window = panel
+        CraftTrace.mark("window created")
         super.init()
-        runtime.scene = self; renderer.window = window
+        renderer.window = window
         window.title = options["title"] as? String ?? application.appName
         if (options["titlebarStyle"] as? String ?? application.titlebarStyle) == "transparent" {
             window.titlebarAppearsTransparent = true
@@ -48,14 +61,54 @@ final class CraftMacScene: NSObject, NSWindowDelegate {
         renderer.root.autoresizingMask = [.width, .height]
         window.contentView = renderer.root
         window.delegate = self; window.center()
-        if name == "main" && application.testDirectory == nil { window.setFrameAutosaveName("\(application.appName)NativeMain") }
-        window.makeKeyAndOrderFront(nil)
+        if let autosave = Self.autosaveName(name: name, application: application) { window.setFrameAutosaveName(autosave) }
+        // Whatever the screen drew while the window was made is in it before it shows. A screen that has not
+        // drawn yet gets a moment to, so the window opens with its content rather than blank.
+        runtime.attach(self)
+        if runtime.hasDrawn { show() } else {
+            runtime.whenDrawn { [weak self] in self?.show() }
+            DispatchQueue.main.asyncAfter(deadline: .now() + Self.firstTreeGrace) { [weak self] in self?.show() }
+        }
+    }
+
+    /// Orders the window front the first time. The window is made deferred, so the window server's side
+    /// of it is made here, once, rather than updated for each property set while it was configured; and
+    /// it opens without the zoom AppKit plays for a new window, which runs a display link and draws it in
+    /// over several frames. Later showings animate as usual.
+    func show() {
+        guard !shown else { return }
+        shown = true
+        let behavior = window.animationBehavior
+        window.animationBehavior = .none
+        CraftTrace.span("window ordered front") { window.makeKeyAndOrderFront(nil) }
+        window.animationBehavior = behavior
         placeTrafficLights()
-        // The screen starts knowing its width, so `md:`/`lg:` classes and `matchMedia` are right on the first frame.
+        // The screen started with the size this window was expected to open at; a saved frame the
+        // screen cannot fit, or a smaller display, makes it another, which the screen now hears.
         let size = window.contentLayoutRect.size
-        reportedViewportWidth = size.width
-        runtime.context.evaluateScript("__stxNativeBridge.viewportWidth = \(Double(size.width)); __stxNativeBridge.viewportHeight = \(Double(size.height));")
-        runtime.load(application.bundle)
+        if abs(size.width - startedViewport.width) >= 0.5 || abs(size.height - startedViewport.height) >= 0.5 {
+            reportedViewportWidth = size.width
+            runtime.send("VIEWPORT", ["width": Double(size.width), "height": Double(size.height)])
+        }
+    }
+
+    static func autosaveName(name: String, application: CraftMacApplication) -> String? {
+        name == "main" && application.testDirectory == nil ? "\(application.appName)NativeMain" : nil
+    }
+
+    /// The content size (below the title bar) the window will open at, known before it exists: the size
+    /// asked for, or the frame AppKit saved for it last time. Its screen starts with it.
+    static func contentSize(options: [String: Any], application: CraftMacApplication, name: String) -> CGSize {
+        let transparent = (options["titlebarStyle"] as? String ?? application.titlebarStyle) == "transparent"
+        let titlebar = NSWindow.frameRect(forContentRect: CGRect(x: 0, y: 0, width: 100, height: 100), styleMask: [.titled]).height - 100
+        let width = number(options["width"]) ?? 1120, height = number(options["height"]) ?? 740
+        // `x y width height` of the frame, then the screen's.
+        if let autosave = autosaveName(name: name, application: application),
+           let saved = UserDefaults.standard.string(forKey: "NSWindow Frame \(autosave)")?.split(separator: " ").compactMap({ Double($0) }), saved.count >= 4 {
+            return CGSize(width: saved[2], height: max(0, saved[3] - titlebar))
+        }
+        // A full-size content view runs under the title bar, which its layout rect leaves out.
+        return CGSize(width: width, height: transparent ? max(0, height - titlebar) : height)
     }
 
     /// Tells the screen its new width (VIEWPORT, as a phone does on rotation): only when the width changed,
@@ -109,8 +162,8 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
     var titlebarStyle = "standard"
     var trafficLights: [Any]?
     /// Apps that ship their own agent (Attic) hand out a session cookie at
-    /// `/native/session`. An app that talks to a hosted API has no such
-    /// endpoint and starts with `--no-session`.
+    /// `/native/session` (`authorize`). An app that talks to a hosted API has
+    /// no such endpoint and starts with `--no-session`.
     var requiresSession = true
     var mainWindowOptions: [String: Any] = [:]
     /// The Dock icon's menu (`craft-app.json` `dockMenu`): each item sends its action as a desktop command.
@@ -128,34 +181,46 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
     var testMenu: [[String: Any]] = []
     var testMenuChoice: String?
     var appearanceObservation: NSKeyValueObservation?
+    /// The main window's screen, started before AppKit launched, waiting for its window.
+    var preparedMain: CraftMacRuntime?
+    /// The appearance it started with, which AppKit could not be asked yet.
+    var preparedColorScheme = ""
+    var mainOptions: [String: Any] { mainWindowOptions.merging(["title": appName]) { _, new in new } }
+    /// Launch finished, and why the agent issued no session, if it did not (shown once both are known).
+    var launched = false
+    var sessionFailure: String?
     /// A quit waiting for screens to finish (`craft.desktop.onQuit`), for at most `quitGrace` seconds.
     private var pendingQuit: (token: String, waiting: Set<String>, timeout: Timer)?
     static let quitGrace: TimeInterval = 3
 
+    func applicationWillFinishLaunching(_ notification: Notification) { CraftTrace.mark("will finish launching") }
     func applicationDidFinishLaunching(_ notification: Notification) {
-        installMenus()
+        CraftTrace.mark("did finish launching")
+        CraftTrace.span("menus installed") { installMenus() }
         appearanceObservation = NSApp.observe(\.effectiveAppearance, options: [.new]) { [weak self] _, _ in
             DispatchQueue.main.async { self?.appearanceChanged() }
         }
         NSApp.activate(ignoringOtherApps: true)
-        if !requiresSession {
-            open(name: "main", route: initialRoute, options: mainWindowOptions.merging(["title": appName]) { _, new in new })
-            startTestDriver()
-            return
-        }
-        // The agent issues an HttpOnly cookie. It stays in URLSession, shared
-        // by native windows, and is never handed to the JavaScript context.
-        let request = URLRequest(url: network.base.appendingPathComponent("native/session"))
-        network.session.dataTask(with: request) { [weak self] _, response, error in
+        open(name: "main", route: initialRoute, options: mainOptions)
+        if preparedColorScheme != (CraftMacColor.isDark ? "dark" : "light") { appearanceChanged() }
+        startTestDriver()
+        launched = true
+        if let failure = sessionFailure { sessionFailed(failure) }
+    }
+    /// Asks the agent for the session cookie (`CraftMacNetwork.authorize`) as the app starts, before
+    /// AppKit has launched; the screen's requests wait for it. Without one the app says so and quits.
+    func authorize() {
+        network.authorize { failure in
             DispatchQueue.main.async {
-                guard let self else { return }
-                guard error == nil, (response as? HTTPURLResponse)?.statusCode == 200 else {
-                    let alert = NSAlert(); alert.messageText = "Could not connect to the app"; alert.informativeText = error?.localizedDescription ?? "The local agent did not issue a native session."; alert.runModal(); NSApp.terminate(nil); return
-                }
-                self.open(name: "main", route: self.initialRoute, options: self.mainWindowOptions.merging(["title": self.appName]) { _, new in new })
-                self.startTestDriver()
+                CraftTrace.mark("native session answered")
+                guard let failure else { return }
+                self.sessionFailure = failure
+                if self.launched { self.sessionFailed(failure) }
             }
-        }.resume()
+        }
+    }
+    private func sessionFailed(_ message: String) {
+        let alert = NSAlert(); alert.messageText = "Could not connect to the app"; alert.informativeText = message; alert.runModal(); NSApp.terminate(nil)
     }
     func applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows flag: Bool) -> Bool { scenes["main"]?.window.makeKeyAndOrderFront(nil); return true }
     /// Links from other apps (this app as the default browser) and files dropped on the Dock icon.
@@ -212,7 +277,24 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
     }
     func open(name: String, route: String, options: [String: Any]) {
         if let scene = scenes[name] { scene.window.makeKeyAndOrderFront(nil); return }
-        scenes[name] = CraftMacScene(name: name, route: route, options: options, application: self)
+        let prepared = name == "main" ? preparedMain : nil
+        if prepared != nil { preparedMain = nil }
+        scenes[name] = CraftMacScene(name: name, route: route, options: options, application: self, runtime: prepared)
+    }
+    /// A screen's thread and context, its bundle evaluated as soon as the thread can.
+    func startScreen(route: String, options: [String: Any], viewport: CGSize, colorScheme: String) -> CraftMacRuntime {
+        let runtime = CraftMacRuntime(route: route, params: options["params"] as? [String: Any] ?? [:], network: network, colorScheme: colorScheme)
+        runtime.load(bundle, viewport: viewport)
+        return runtime
+    }
+    /// Starts the main window's screen before AppKit launches: connecting to the window server and
+    /// launching take a few hundred milliseconds, most of them waiting, and the screen evaluates its
+    /// bundle, mounts and sends its first requests meanwhile. Its tree is drawn when the window opens.
+    func prepareMainScreen() {
+        // NSApp does not exist yet, so the system's setting stands in for AppKit's appearance;
+        // launching checks it against AppKit's.
+        preparedColorScheme = UserDefaults.standard.string(forKey: "AppleInterfaceStyle") == "Dark" ? "dark" : "light"
+        preparedMain = startScreen(route: initialRoute, options: mainOptions, viewport: CraftMacScene.contentSize(options: mainOptions, application: self, name: "main"), colorScheme: preparedColorScheme)
     }
     /// A menu command goes to the window it was chosen in (the key window), else the main one: with
     /// two windows of the same screen open, cmd-T opens one tab, not one in each.
@@ -231,7 +313,7 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
             // AppKit lays the title bar out again for the new appearance, after this returns.
             scene.placeTrafficLights()
             DispatchQueue.main.async { [weak scene] in scene?.placeTrafficLights() }
-            scene.runtime.context.evaluateScript("__stxNativeBridge.colorScheme = '\(scheme)';")
+            scene.runtime.evaluate("__stxNativeBridge.colorScheme = '\(scheme)';")
             // The protocol's own message: the screen restyles its `dark:` classes and tells `craft.appearance.onChange`.
             scene.runtime.send("APPEARANCE", ["colorScheme": scheme])
             scene.window.effectiveAppearance.performAsCurrentDrawingAppearance {
@@ -293,7 +375,7 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
         if parts.contains("alt") { item.keyEquivalentModifierMask.insert(.option) }
         item.isEnabled = raw["disabled"] as? Bool != true
         item.state = raw["checked"] as? Bool == true ? .on : .off
-        if let symbol = raw["icon"] as? String { item.image = NSImage(systemSymbolName: symbol, accessibilityDescription: nil) }
+        if let symbol = raw["icon"] as? String { item.image = CraftMacSymbols.image(symbol) }
         return item
     }
     func perform(_ method: String, args: [Any], scene: CraftMacScene?, reply: @escaping (Any) -> Void) {
@@ -373,10 +455,10 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
             guard let path = file["path"], chosenFiles.contains(path), let data = try? Data(contentsOf: URL(fileURLWithPath: path)), data.count <= 256 * 1024 * 1024,
                   var request = network.request(["url": endpoint, "method": "POST", "headers": ["x-filename": file["name"] ?? "Attachment", "content-type": file["type"] ?? "application/octet-stream"]]) else { reply(["error": "Could not read a picked attachment"]); return }
             request.httpBody = data
-            network.session.dataTask(with: request) { data, response, error in DispatchQueue.main.async {
+            network.resume(network.session.dataTask(with: request) { data, response, error in DispatchQueue.main.async {
                 guard error == nil, (response as? HTTPURLResponse)?.statusCode == 200, let data, let value = try? JSONSerialization.jsonObject(with: data) else { reply(["error": error?.localizedDescription ?? "Attachment upload failed"]); return }
                 results.append(value); next(index + 1)
-            } }.resume()
+            } })
         }; next(0)
     }
     private func preview(_ options: [String: Any], scene: CraftMacScene?) {
@@ -390,18 +472,18 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
             player.player?.play()
         } else {
             let image = NSImageView(); image.imageScaling = .scaleProportionallyUpOrDown; panel.contentView = image
-            network.session.dataTask(with: request) { data, _, _ in DispatchQueue.main.async { image.image = data.flatMap(NSImage.init(data:)) } }.resume()
+            network.resume(network.session.dataTask(with: request) { data, _, _ in DispatchQueue.main.async { image.image = data.flatMap(NSImage.init(data:)) } })
         }
         panel.center(); panel.makeKeyAndOrderFront(nil)
     }
     private func export(_ options: [String: Any], reply: @escaping (Any) -> Void) {
         let panel = NSSavePanel(); panel.nameFieldStringValue = options["name"] as? String ?? "Attachment"
         guard panel.runModal() == .OK, let destination = panel.url, let request = network.request(["url": options["url"] ?? ""]) else { reply(false); return }
-        network.session.downloadTask(with: request) { location, response, error in
+        network.resume(network.session.downloadTask(with: request) { location, response, error in
             var saved = false
             if error == nil, (response as? HTTPURLResponse)?.statusCode == 200, let location { do { if FileManager.default.fileExists(atPath: destination.path) { try FileManager.default.removeItem(at: destination) }; try FileManager.default.moveItem(at: location, to: destination); saved = true } catch {} }
             DispatchQueue.main.async { reply(saved) }
-        }.resume()
+        })
     }
     func notification(_ method: String, options: [String: Any], reply: @escaping (Any) -> Void) {
         guard method == "schedule" else { reply(false); return }
@@ -554,7 +636,7 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
                 return node
             }
             func classes(_ view: NSView) -> [String] { [String(describing: type(of: view))] + view.subviews.flatMap(classes) }
-            return ["name": scene.name, "title": scene.window.title, "route": scene.runtime.route, "contextClass": String(describing: type(of: scene.runtime.context)), "nodes": nodes, "viewClasses": classes(scene.renderer.root), "viewportWidth": Double(scene.reportedViewportWidth), "errors": scene.runtime.errors]
+            return ["name": scene.name, "title": scene.window.title, "route": scene.runtime.route, "contextClass": String(describing: ZigJSContext.self), "nodes": nodes, "viewClasses": classes(scene.renderer.root), "viewportWidth": Double(scene.reportedViewportWidth), "errors": scene.runtime.errors]
         }
         let webViews = windows.reduce(0) { count, window in count + ((window["viewClasses"] as? [String] ?? []).filter { $0.contains("WKWebView") || $0 == "WebView" }.count) }
         return ["renderer": "appkit", "scriptEngine": "zig-js", "appearance": CraftMacColor.isDark ? "dark" : "light", "windows": windows, "webViews": webViews, "menu": testMenu]
@@ -563,6 +645,7 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
 
 @main struct CraftMacMain {
     static func main() throws {
+        CraftTrace.mark("main")
         // A bundled app is launched by Finder with no arguments: its settings are
         // `Contents/Resources/craft-app.json`, written by the build. A flag on the
         // command line still wins, so a development run can point elsewhere.
@@ -595,6 +678,8 @@ final class CraftMacApplication: NSObject, NSApplicationDelegate, UNUserNotifica
         application.network = CraftMacNetwork(base: api)
         let testDirectory = argument("--test-dir")
         if !testDirectory.isEmpty { application.testDirectory = URL(fileURLWithPath: testDirectory, isDirectory: true) }
+        if application.requiresSession { application.authorize() }
+        application.prepareMainScreen()
         let app = NSApplication.shared
         app.setActivationPolicy(.regular); app.delegate = application; app.run()
     }