@tokamakdev/platform-ios-simulator-arm64 0.1.1-beta.48 → 0.1.1-beta.50

package/ios-simulator-arm64/build/entrypoint

@@ -89,36 +89,32 @@ sign_bundle() {
       signing_args+=(--device-id "$(cat "$metadata/device-id")")
     fi
     "$apple_tool" "${signing_args[@]}"
-  elif [[ "$platform" == macos && -n "${TOKAMAK_MACOS_TEAM_ID:-}" ]]; then
+  elif [[ "$platform" == macos ]]; then
     "$apple_tool" sign \
       --platform macos \
       --project "$project_dir" \
       --bundle "$bundle" \
       --bundle-id "$identifier"
   else
-    # Ad-hoc signatures carry no provisioning profile.
-    rm -f "$contents/embedded.provisionprofile"
     codesign --force --timestamp=none --sign - "$bundle"
   fi
 }
 
 bundle_key_file=$output_parent/.tokamak/$(basename "$output").input-key
 if [[ -f "$metadata/input-key" ]]; then
-  plist_path=
   case "$platform" in
-    ios|ios-simulator) plist_path=${TOKAMAK_IOS_PLIST:-} ;;
-    macos) plist_path=${TOKAMAK_MACOS_PLIST:-} ;;
+    ios|ios-simulator) app_files=("${TOKAMAK_IOS_PLIST:-}" "${TOKAMAK_IOS_ENTITLEMENTS:-}") ;;
+    macos) app_files=("${TOKAMAK_MACOS_PLIST:-}" "${TOKAMAK_MACOS_ENTITLEMENTS:-}") ;;
   esac
-  if [[ -n "$plist_path" && "$plist_path" != /* ]]; then
-    plist_path=$project_dir/$plist_path
-  fi
   bundle_key=$(
     {
       cat "$metadata/input-key"
       shasum -a 256 "$0" "$apple_tool"
-      if [[ -n "$plist_path" ]]; then
-        shasum -a 256 "$plist_path"
-      fi
+      for app_file in "${app_files[@]}"; do
+        if [[ -n "$app_file" ]]; then
+          shasum -a 256 "$app_file"
+        fi
+      done
       env | LC_ALL=C sort | sed -n '/^TOKAMAK_/p' |
         sed '/^TOKAMAK_IOS_TEAM_ID=/d; /^TOKAMAK_IOS_SIGNING_IDENTITY=/d; /^TOKAMAK_IOS_PROVISIONING_PROFILE=/d; /^TOKAMAK_MACOS_TEAM_ID=/d; /^TOKAMAK_IOS_BUILD_NUMBER=/d; /^TOKAMAK_MACOS_BUILD_NUMBER=/d'
       printf '%s\n' "${DEVELOPER_DIR:-}" "$PATH"
@@ -188,11 +184,11 @@ done
 registry=$temporary/TokamakPluginRegistry.swift
 {
   printf '%s\n\n' 'import Foundation'
-  printf '%s\n' 'func tokamakPlugins() -> [any TokamakPlugin] {'
+  printf '%s\n' 'func tokamakPlugins(host: TokamakHost) -> [any TokamakPlugin] {'
   printf '%s\n' '  ['
   for plugin in "$input/plugins"/*; do
     [[ -d "$plugin" ]] || continue
-    printf '    %s(),\n' "$(cat "$plugin/class")"
+    printf '    %s(host: host),\n' "$(cat "$plugin/class")"
   done
   printf '%s\n' '  ]'
   printf '%s\n' '}'
@@ -222,24 +218,11 @@ for plugin in "$input/plugins"/*; do
   done
 done
 
-# Simulator builds embed application-identifier and keychain-access-groups in
-# __TEXT,__entitlements, where the simulator reads them.
+# Simulator builds embed their entitlements in __TEXT,__entitlements, where
+# the simulator reads them.
 if [[ "$platform" == ios-simulator ]]; then
   simulator_entitlements=$temporary/simulator.entitlements
-  cat > "$simulator_entitlements" <<EOF
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>application-identifier</key>
-  <string>$identifier</string>
-  <key>keychain-access-groups</key>
-  <array>
-    <string>$identifier</string>
-  </array>
-</dict>
-</plist>
-EOF
+  "$apple_tool" simulator-entitlements --identifier "$identifier" --output "$simulator_entitlements"
   swift_args+=(-Xlinker -sectcreate -Xlinker __TEXT -Xlinker __entitlements -Xlinker "$simulator_entitlements")
 fi
 

package/ios-simulator-arm64/frameworks/TokamakRuntime.framework/Headers/TokamakRuntime.h

@@ -11,6 +11,12 @@ enum {
   TOKAMAK_DECISION_USE = 2,
 };
 
+enum {
+  TOKAMAK_DISPATCH_HANDLED = 0,
+  TOKAMAK_DISPATCH_UNHANDLED = 1,
+  TOKAMAK_DISPATCH_FAILED = 2,
+};
+
 typedef struct {
   uint8_t *data;
   size_t len;
@@ -33,6 +39,10 @@ uint16_t tokamak_runtime_restore_gateway(const void *runtime, char *error,
 bool tokamak_runtime_suspend(const void *runtime);
 bool tokamak_runtime_resume(const void *runtime);
 void tokamak_runtime_stop(void *runtime);
+int32_t tokamak_runtime_dispatch(const void *runtime, const char *event,
+                              const char *payload, uint64_t timeout_ms,
+                              TokamakBytes *result, char *error,
+                              size_t error_len);
 
 int32_t tokamak_runtime_server_authority(const void *runtime, const char *host,
                                       TokamakBytes *authority);

package/ios-simulator-arm64/native-shell/TokamakHost.swift

@@ -0,0 +1,372 @@
+import Foundation
+import TokamakRuntime
+
+private let startupErrorFile = "startup-error.log"
+
+/// The tokamak runtime and native plugins of this process. Both outlive any
+/// WebView, so plugins receive app events before a page loads and a Worker
+/// event can run while no page is loaded.
+final class TokamakHost {
+  private(set) var plugins: [any TokamakPlugin] = []
+  private var runtime: Result<RuntimeHandle, Error>?
+  private var waiting: [(Result<RuntimeHandle, Error>) -> Void] = []
+
+  /// Creates the plugins and starts the runtime in the background. Call it
+  /// before launch finishes.
+  init() {
+    plugins = tokamakPlugins(host: self)
+    DispatchQueue.global(qos: .userInitiated).async {
+      let result = Result { try RuntimeHandle() }
+      DispatchQueue.main.async { self.started(result) }
+    }
+  }
+
+  /// Calls `completion` on the main thread once the runtime has started or
+  /// failed to start.
+  func whenStarted(_ completion: @escaping (Result<RuntimeHandle, Error>) -> Void) {
+    dispatchPrecondition(condition: .onQueue(.main))
+    if let runtime {
+      completion(runtime)
+    } else {
+      waiting.append(completion)
+    }
+  }
+
+  /// Runs the Worker's `event` handler with a JSON-serialisable `payload`,
+  /// including work it passes to `ctx.waitUntil`, and stops it after
+  /// `timeout`. Call it on the main thread; `completion` runs on the main
+  /// thread.
+  func dispatch(
+    event: String,
+    payload: Any,
+    timeout: TimeInterval,
+    completion: @escaping (Result<TokamakEventOutcome, Error>) -> Void
+  ) {
+    whenStarted { result in
+      switch result {
+      case .failure(let error):
+        completion(.failure(error))
+      case .success(let runtime):
+        DispatchQueue.global(qos: .userInitiated).async {
+          let outcome = Result {
+            try runtime.dispatch(event: event, payload: payload, timeout: timeout)
+          }
+          DispatchQueue.main.async { completion(outcome) }
+        }
+      }
+    }
+  }
+
+  func didRegisterForRemoteNotifications(deviceToken: Data) {
+    for plugin in plugins {
+      plugin.didRegisterForRemoteNotifications(deviceToken: deviceToken)
+    }
+  }
+
+  func didFailToRegisterForRemoteNotifications(error: Error) {
+    for plugin in plugins {
+      plugin.didFailToRegisterForRemoteNotifications(error: error)
+    }
+  }
+
+  /// Delivers a remote notification to every plugin, calling `completion` on
+  /// the main thread once each has finished with it.
+  func didReceiveRemoteNotification(
+    _ userInfo: [AnyHashable: Any],
+    completion: @escaping (TokamakBackgroundResult) -> Void
+  ) {
+    let group = DispatchGroup()
+    var results: [TokamakBackgroundResult] = []
+    for plugin in plugins {
+      group.enter()
+      plugin.didReceiveRemoteNotification(userInfo) { result in
+        DispatchQueue.main.async {
+          results.append(result)
+          group.leave()
+        }
+      }
+    }
+    group.notify(queue: .main) {
+      completion(TokamakBackgroundResult(combining: results))
+    }
+  }
+
+  private func started(_ result: Result<RuntimeHandle, Error>) {
+    if case .failure(let error) = result {
+      RuntimeHandle.recordStartupFailure(error)
+    }
+    runtime = result
+    let callbacks = waiting
+    waiting.removeAll()
+    for callback in callbacks {
+      callback(result)
+    }
+  }
+}
+
+/// What a Worker event handler did.
+enum TokamakEventOutcome {
+  /// The handler's result, decoded from JSON; `NSNull` when it returned nothing.
+  case handled(Any)
+  /// The Worker has no handler for the event.
+  case unhandled
+}
+
+/// What a plugin did with a background event, reported to the system.
+enum TokamakBackgroundResult {
+  case newData
+  case noData
+  case failed
+
+  /// New data when any plugin fetched some, otherwise a failure when any
+  /// plugin failed.
+  init(combining results: [Self]) {
+    if results.contains(.newData) {
+      self = .newData
+    } else if results.contains(.failed) {
+      self = .failed
+    } else {
+      self = .noData
+    }
+  }
+}
+
+enum RuntimeError: Error, CustomStringConvertible {
+  case configuration(String)
+  case runtime(String)
+
+  var description: String {
+    switch self {
+    case .configuration(let message), .runtime(let message):
+      return message
+    }
+  }
+}
+
+enum AuthenticationMaterial<Value> {
+  case defaultHandling
+  case cancel
+  case use(Value)
+}
+
+/// A started tokamak runtime, stopped when released.
+final class RuntimeHandle {
+  let appHost: String
+  private var handle: UnsafeMutableRawPointer?
+
+  init() throws {
+    guard
+      let appHost = Bundle.main.object(forInfoDictionaryKey: "TokamakHost") as? String,
+      !appHost.isEmpty
+    else {
+      throw RuntimeError.configuration("TokamakHost is required")
+    }
+    self.appHost = appHost
+
+    let state = try Self.stateDirectory()
+    var error = [CChar](repeating: 0, count: 512)
+    if let endpoint = Bundle.main.object(forInfoDictionaryKey: "TokamakDevEndpoint") as? String,
+      let sessionToken = Bundle.main.object(forInfoDictionaryKey: "TokamakDevSessionToken")
+        as? String
+    {
+      handle = state.path.withCString { statePath in
+        appHost.withCString { appHost in
+          endpoint.withCString { endpoint in
+            sessionToken.withCString { sessionToken in
+              error.withUnsafeMutableBufferPointer { error in
+                tokamak_runtime_start_development(
+                  statePath,
+                  appHost,
+                  endpoint,
+                  sessionToken,
+                  error.baseAddress,
+                  error.count
+                )
+              }
+            }
+          }
+        }
+      }
+    } else {
+      let bundle = Bundle.main.resourceURL?.appendingPathComponent("app")
+      guard let bundle else {
+        throw RuntimeError.configuration("app bundle resources are unavailable")
+      }
+      handle = bundle.path.withCString { bundlePath in
+        state.path.withCString { statePath in
+          appHost.withCString { appHost in
+            error.withUnsafeMutableBufferPointer { error in
+              tokamak_runtime_start(
+                bundlePath,
+                statePath,
+                appHost,
+                error.baseAddress,
+                error.count
+              )
+            }
+          }
+        }
+      }
+    }
+    guard handle != nil else {
+      throw RuntimeError.runtime(String(cString: error))
+    }
+    try? FileManager.default.removeItem(
+      at: state.appendingPathComponent(startupErrorFile)
+    )
+  }
+
+  deinit {
+    if let handle {
+      tokamak_runtime_stop(handle)
+    }
+  }
+
+  var port: UInt16 {
+    tokamak_runtime_port(handle)
+  }
+
+  func restoreGateway() throws -> UInt16 {
+    var error = [CChar](repeating: 0, count: 512)
+    let port = error.withUnsafeMutableBufferPointer { error in
+      tokamak_runtime_restore_gateway(
+        handle,
+        error.baseAddress,
+        error.count
+      )
+    }
+    guard port != 0 else {
+      throw RuntimeError.runtime(String(cString: error))
+    }
+    return port
+  }
+
+  /// Runs the Worker's `event` handler, blocking until it settles or
+  /// `timeout` passes.
+  func dispatch(event: String, payload: Any, timeout: TimeInterval) throws -> TokamakEventOutcome {
+    guard JSONSerialization.isValidJSONObject([payload]) else {
+      throw RuntimeError.runtime("the \(event) payload is not JSON")
+    }
+    let payload = String(
+      decoding: try JSONSerialization.data(withJSONObject: payload, options: .fragmentsAllowed),
+      as: UTF8.self
+    )
+    var result = TokamakBytes(data: nil, len: 0)
+    var error = [CChar](repeating: 0, count: 1024)
+    let status = event.withCString { event in
+      payload.withCString { payload in
+        error.withUnsafeMutableBufferPointer { error in
+          tokamak_runtime_dispatch(
+            handle,
+            event,
+            payload,
+            UInt64(timeout * 1000),
+            &result,
+            error.baseAddress,
+            error.count
+          )
+        }
+      }
+    }
+    defer { tokamak_bytes_free(result) }
+    switch status {
+    case Int32(TOKAMAK_DISPATCH_HANDLED):
+      guard let bytes = result.data else {
+        throw RuntimeError.runtime("the Worker event result is missing")
+      }
+      return .handled(
+        try JSONSerialization.jsonObject(
+          with: Data(bytes: bytes, count: result.len),
+          options: .fragmentsAllowed
+        ))
+    case Int32(TOKAMAK_DISPATCH_UNHANDLED):
+      return .unhandled
+    default:
+      throw RuntimeError.runtime(String(cString: error))
+    }
+  }
+
+  func serverAuthority(
+    host: String
+  ) -> AuthenticationMaterial<Data> {
+    var bytes = TokamakBytes(data: nil, len: 0)
+    let decision = host.withCString {
+      tokamak_runtime_server_authority(handle, $0, &bytes)
+    }
+    switch decision {
+    case Int32(TOKAMAK_DECISION_DEFAULT):
+      return .defaultHandling
+    case Int32(TOKAMAK_DECISION_USE):
+      defer { tokamak_bytes_free(bytes) }
+      guard let data = bytes.data else { return .cancel }
+      return .use(Data(bytes: data, count: bytes.len))
+    default:
+      return .cancel
+    }
+  }
+
+  func clientIdentity(
+    host: String,
+    previousFailures: Int
+  ) -> AuthenticationMaterial<(Data, Data)> {
+    var identity = TokamakIdentity(
+      certificate: TokamakBytes(data: nil, len: 0),
+      private_key: TokamakBytes(data: nil, len: 0)
+    )
+    let decision = host.withCString {
+      tokamak_runtime_client_identity(
+        handle,
+        $0,
+        max(previousFailures, 0),
+        &identity
+      )
+    }
+    switch decision {
+    case Int32(TOKAMAK_DECISION_DEFAULT):
+      return .defaultHandling
+    case Int32(TOKAMAK_DECISION_USE):
+      defer { tokamak_identity_free(identity) }
+      guard
+        let certificate = identity.certificate.data,
+        let privateKey = identity.private_key.data
+      else {
+        return .cancel
+      }
+      return .use(
+        (
+          Data(bytes: certificate, count: identity.certificate.len),
+          Data(bytes: privateKey, count: identity.private_key.len)
+        ))
+    default:
+      return .cancel
+    }
+  }
+
+  static func recordStartupFailure(_ error: Error) {
+    print("tokamak runtime startup failed: \(error)")
+    guard let state = try? stateDirectory() else { return }
+    try? String(describing: error).write(
+      to: state.appendingPathComponent(startupErrorFile),
+      atomically: true,
+      encoding: .utf8
+    )
+  }
+
+  private static func stateDirectory() throws -> URL {
+    guard let identifier = Bundle.main.bundleIdentifier else {
+      throw RuntimeError.configuration("CFBundleIdentifier is required")
+    }
+    let root = try FileManager.default.url(
+      for: .cachesDirectory,
+      in: .userDomainMask,
+      appropriateFor: nil,
+      create: true
+    )
+    let state = root.appendingPathComponent(identifier, isDirectory: true)
+    try FileManager.default.createDirectory(
+      at: state,
+      withIntermediateDirectories: true
+    )
+    return state
+  }
+}

package/ios-simulator-arm64/native-shell/TokamakPlugins.swift

@@ -12,9 +12,12 @@ struct TokamakPluginError: Error {
 
 typealias TokamakPluginReply = (Result<Any?, TokamakPluginError>) -> Void
 
+/// A native plugin, created once per process when the app launches.
 protocol TokamakPlugin: AnyObject {
   var id: String { get }
 
+  init(host: TokamakHost)
+
   func call(
     method: String,
     arguments: Any,
@@ -26,6 +29,17 @@ protocol TokamakPlugin: AnyObject {
     arguments: Any,
     reply: @escaping TokamakPluginReply
   ) -> (() -> Void)
+
+  func didRegisterForRemoteNotifications(deviceToken: Data)
+
+  func didFailToRegisterForRemoteNotifications(error: Error)
+
+  /// Handles a remote notification delivered to the app, calling `completion`
+  /// once when finished with it.
+  func didReceiveRemoteNotification(
+    _ userInfo: [AnyHashable: Any],
+    completion: @escaping (TokamakBackgroundResult) -> Void
+  )
 }
 
 extension TokamakPlugin {
@@ -45,6 +59,17 @@ extension TokamakPlugin {
     reply(.failure(.notSupported("\(id).\(method) is not supported")))
     return {}
   }
+
+  func didRegisterForRemoteNotifications(deviceToken: Data) {}
+
+  func didFailToRegisterForRemoteNotifications(error: Error) {}
+
+  func didReceiveRemoteNotification(
+    _ userInfo: [AnyHashable: Any],
+    completion: @escaping (TokamakBackgroundResult) -> Void
+  ) {
+    completion(.noData)
+  }
 }
 
 final class TokamakPluginBridge: NSObject, WKScriptMessageHandler {

package/ios-simulator-arm64/native-shell/TokamakShell.swift

@@ -1,7 +1,6 @@
 import Foundation
 import Network
 import Security
-import TokamakRuntime
 import WebKit
 
 #if os(macOS)
@@ -10,209 +9,14 @@ import WebKit
   import UIKit
 #endif
 
-private let startupErrorFile = "startup-error.log"
 private let failurePage =
   "<h1>App failed to start</h1><p>Check startup-error.log for details.</p>"
 
-private enum ShellError: Error, CustomStringConvertible {
-  case configuration(String)
-  case runtime(String)
-
-  var description: String {
-    switch self {
-    case .configuration(let message), .runtime(let message):
-      return message
-    }
-  }
-}
-
-private enum AuthenticationMaterial<Value> {
-  case defaultHandling
-  case cancel
-  case use(Value)
-}
-
-private final class RuntimeHost {
-  let host: String
-  private var handle: UnsafeMutableRawPointer?
-
-  init() throws {
-    guard
-      let host = Bundle.main.object(forInfoDictionaryKey: "TokamakHost") as? String,
-      !host.isEmpty
-    else {
-      throw ShellError.configuration("TokamakHost is required")
-    }
-    self.host = host
-
-    let state = try Self.stateDirectory()
-    var error = [CChar](repeating: 0, count: 512)
-    if let endpoint = Bundle.main.object(forInfoDictionaryKey: "TokamakDevEndpoint") as? String,
-      let sessionToken = Bundle.main.object(forInfoDictionaryKey: "TokamakDevSessionToken")
-        as? String
-    {
-      handle = state.path.withCString { statePath in
-        host.withCString { host in
-          endpoint.withCString { endpoint in
-            sessionToken.withCString { sessionToken in
-              error.withUnsafeMutableBufferPointer { error in
-                tokamak_runtime_start_development(
-                  statePath,
-                  host,
-                  endpoint,
-                  sessionToken,
-                  error.baseAddress,
-                  error.count
-                )
-              }
-            }
-          }
-        }
-      }
-    } else {
-      let bundle = Bundle.main.resourceURL?.appendingPathComponent("app")
-      guard let bundle else {
-        throw ShellError.configuration("app bundle resources are unavailable")
-      }
-      handle = bundle.path.withCString { bundlePath in
-        state.path.withCString { statePath in
-          host.withCString { host in
-            error.withUnsafeMutableBufferPointer { error in
-              tokamak_runtime_start(
-                bundlePath,
-                statePath,
-                host,
-                error.baseAddress,
-                error.count
-              )
-            }
-          }
-        }
-      }
-    }
-    guard handle != nil else {
-      throw ShellError.runtime(String(cString: error))
-    }
-    try? FileManager.default.removeItem(
-      at: state.appendingPathComponent(startupErrorFile)
-    )
-  }
-
-  deinit {
-    if let handle {
-      tokamak_runtime_stop(handle)
-    }
-  }
-
-  var port: UInt16 {
-    tokamak_runtime_port(handle)
-  }
-
-  func restoreGateway() throws -> UInt16 {
-    var error = [CChar](repeating: 0, count: 512)
-    let port = error.withUnsafeMutableBufferPointer { error in
-      tokamak_runtime_restore_gateway(
-        handle,
-        error.baseAddress,
-        error.count
-      )
-    }
-    guard port != 0 else {
-      throw ShellError.runtime(String(cString: error))
-    }
-    return port
-  }
-
-  func serverAuthority(
-    host: String
-  ) -> AuthenticationMaterial<Data> {
-    var bytes = TokamakBytes(data: nil, len: 0)
-    let decision = host.withCString {
-      tokamak_runtime_server_authority(handle, $0, &bytes)
-    }
-    switch decision {
-    case Int32(TOKAMAK_DECISION_DEFAULT):
-      return .defaultHandling
-    case Int32(TOKAMAK_DECISION_USE):
-      defer { tokamak_bytes_free(bytes) }
-      guard let data = bytes.data else { return .cancel }
-      return .use(Data(bytes: data, count: bytes.len))
-    default:
-      return .cancel
-    }
-  }
-
-  func clientIdentity(
-    host: String,
-    previousFailures: Int
-  ) -> AuthenticationMaterial<(Data, Data)> {
-    var identity = TokamakIdentity(
-      certificate: TokamakBytes(data: nil, len: 0),
-      private_key: TokamakBytes(data: nil, len: 0)
-    )
-    let decision = host.withCString {
-      tokamak_runtime_client_identity(
-        handle,
-        $0,
-        max(previousFailures, 0),
-        &identity
-      )
-    }
-    switch decision {
-    case Int32(TOKAMAK_DECISION_DEFAULT):
-      return .defaultHandling
-    case Int32(TOKAMAK_DECISION_USE):
-      defer { tokamak_identity_free(identity) }
-      guard
-        let certificate = identity.certificate.data,
-        let privateKey = identity.private_key.data
-      else {
-        return .cancel
-      }
-      return .use(
-        (
-          Data(bytes: certificate, count: identity.certificate.len),
-          Data(bytes: privateKey, count: identity.private_key.len)
-        ))
-    default:
-      return .cancel
-    }
-  }
-
-  static func recordStartupFailure(_ error: Error) {
-    print("tokamak runtime startup failed: \(error)")
-    guard let state = try? stateDirectory() else { return }
-    try? String(describing: error).write(
-      to: state.appendingPathComponent(startupErrorFile),
-      atomically: true,
-      encoding: .utf8
-    )
-  }
-
-  private static func stateDirectory() throws -> URL {
-    guard let identifier = Bundle.main.bundleIdentifier else {
-      throw ShellError.configuration("CFBundleIdentifier is required")
-    }
-    let root = try FileManager.default.url(
-      for: .cachesDirectory,
-      in: .userDomainMask,
-      appropriateFor: nil,
-      create: true
-    )
-    let state = root.appendingPathComponent(identifier, isDirectory: true)
-    try FileManager.default.createDirectory(
-      at: state,
-      withIntermediateDirectories: true
-    )
-    return state
-  }
-}
-
 private final class NavigationDelegate: NSObject, WKNavigationDelegate, WKUIDelegate {
-  private let runtime: RuntimeHost
+  private let runtime: RuntimeHandle
   private let pluginBridge: TokamakPluginBridge
 
-  init(runtime: RuntimeHost, pluginBridge: TokamakPluginBridge) {
+  init(runtime: RuntimeHandle, pluginBridge: TokamakPluginBridge) {
     self.runtime = runtime
     self.pluginBridge = pluginBridge
   }
@@ -239,7 +43,7 @@ private final class NavigationDelegate: NSObject, WKNavigationDelegate, WKUIDele
       return
     }
 
-    if url.isAppOrigin(runtime.host) {
+    if url.isAppOrigin(runtime.appHost) {
       if navigationAction.targetFrame == nil {
         webView.load(navigationAction.request)
         decisionHandler(.cancel)
@@ -266,7 +70,7 @@ private final class NavigationDelegate: NSObject, WKNavigationDelegate, WKUIDele
       return
     }
 
-    if url.isAppOrigin(runtime.host) {
+    if url.isAppOrigin(runtime.appHost) {
       decisionHandler(.allow)
     } else {
       openExternal(url)
@@ -282,7 +86,7 @@ private final class NavigationDelegate: NSObject, WKNavigationDelegate, WKUIDele
   ) -> WKWebView? {
     _ = (configuration, windowFeatures)
     guard let url = navigationAction.request.url else { return nil }
-    if url.isAppOrigin(runtime.host) {
+    if url.isAppOrigin(runtime.appHost) {
       webView.load(navigationAction.request)
     } else {
       openExternal(url)
@@ -299,7 +103,7 @@ private final class NavigationDelegate: NSObject, WKNavigationDelegate, WKUIDele
     type: WKMediaCaptureType,
     decisionHandler: @escaping (WKPermissionDecision) -> Void
   ) {
-    decisionHandler(origin.isAppOrigin(runtime.host) ? .grant : .prompt)
+    decisionHandler(origin.isAppOrigin(runtime.appHost) ? .grant : .prompt)
   }
 
   func webView(
@@ -457,28 +261,29 @@ private final class NavigationDelegate: NSObject, WKNavigationDelegate, WKUIDele
 }
 
 private final class TokamakController {
-  private var runtime: RuntimeHost?
+  private let host: TokamakHost
+  private var runtime: RuntimeHandle?
   private var navigation: NavigationDelegate?
   private var pluginBridge: TokamakPluginBridge?
   private weak var activeWebView: WKWebView?
   private var dataStore: WKWebsiteDataStore?
   private var proxyPort: UInt16?
 
+  init(host: TokamakHost) {
+    self.host = host
+  }
+
   func start(
     frame: CGRect,
     completion: @escaping (WKWebView) -> Void
   ) {
-    DispatchQueue.global(qos: .userInitiated).async {
-      let result = Result { try RuntimeHost() }
-      DispatchQueue.main.async {
-        switch result {
-        case .success(let runtime):
-          self.runtime = runtime
-          completion(self.webView(frame: frame, runtime: runtime))
-        case .failure(let error):
-          RuntimeHost.recordStartupFailure(error)
-          completion(self.failureWebView(frame: frame))
-        }
+    host.whenStarted { result in
+      switch result {
+      case .success(let runtime):
+        self.runtime = runtime
+        completion(self.webView(frame: frame, runtime: runtime))
+      case .failure:
+        completion(self.failureWebView(frame: frame))
       }
     }
   }
@@ -488,7 +293,7 @@ private final class TokamakController {
     do {
       let port = try runtime.restoreGateway()
       guard port != proxyPort else { return }
-      setProxy(port: port, host: runtime.host, dataStore: dataStore)
+      setProxy(port: port, host: runtime.appHost, dataStore: dataStore)
       proxyPort = port
       activeWebView?.reload()
     } catch {
@@ -496,11 +301,11 @@ private final class TokamakController {
     }
   }
 
-  private func webView(frame: CGRect, runtime: RuntimeHost) -> WKWebView {
+  private func webView(frame: CGRect, runtime: RuntimeHandle) -> WKWebView {
     let configuration = WKWebViewConfiguration()
     let dataStore = WKWebsiteDataStore.default()
     let port = runtime.port
-    setProxy(port: port, host: runtime.host, dataStore: dataStore)
+    setProxy(port: port, host: runtime.appHost, dataStore: dataStore)
     self.dataStore = dataStore
     self.proxyPort = port
     configuration.websiteDataStore = dataStore
@@ -511,8 +316,8 @@ private final class TokamakController {
     configuration.mediaTypesRequiringUserActionForPlayback = []
 
     let pluginBridge = TokamakPluginBridge(
-      host: runtime.host,
-      plugins: tokamakPlugins()
+      host: runtime.appHost,
+      plugins: host.plugins
     )
     pluginBridge.install(in: configuration.userContentController)
     let navigation = NavigationDelegate(
@@ -530,7 +335,7 @@ private final class TokamakController {
     self.pluginBridge = pluginBridge
     webView.navigationDelegate = navigation
     webView.uiDelegate = navigation
-    webView.load(URLRequest(url: URL(string: "https://\(runtime.host)/")!))
+    webView.load(URLRequest(url: URL(string: "https://\(runtime.appHost)/")!))
     return webView
   }
 
@@ -559,7 +364,8 @@ private final class TokamakController {
 
 #if os(macOS)
   private final class TokamakMacApplicationDelegate: NSObject, NSApplicationDelegate {
-    private let controller = TokamakController()
+    private lazy var host = TokamakHost()
+    private lazy var controller = TokamakController(host: host)
     private var window: NSWindow?
 
     func applicationDidFinishLaunching(_ notification: Notification) {
@@ -595,6 +401,27 @@ private final class TokamakController {
     ) -> Bool {
       true
     }
+
+    func application(
+      _ application: NSApplication,
+      didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
+    ) {
+      host.didRegisterForRemoteNotifications(deviceToken: deviceToken)
+    }
+
+    func application(
+      _ application: NSApplication,
+      didFailToRegisterForRemoteNotificationsWithError error: Error
+    ) {
+      host.didFailToRegisterForRemoteNotifications(error: error)
+    }
+
+    func application(
+      _ application: NSApplication,
+      didReceiveRemoteNotification userInfo: [String: Any]
+    ) {
+      host.didReceiveRemoteNotification(userInfo) { _ in }
+    }
   }
 
   @main
@@ -609,7 +436,8 @@ private final class TokamakController {
   }
 #else
   private final class TokamakIOSApplicationDelegate: UIResponder, UIApplicationDelegate {
-    private let controller = TokamakController()
+    private lazy var host = TokamakHost()
+    private lazy var controller = TokamakController(host: host)
     var window: UIWindow?
 
     func application(
@@ -636,6 +464,33 @@ private final class TokamakController {
       controller.restoreGateway()
     }
 
+    func application(
+      _ application: UIApplication,
+      didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
+    ) {
+      host.didRegisterForRemoteNotifications(deviceToken: deviceToken)
+    }
+
+    func application(
+      _ application: UIApplication,
+      didFailToRegisterForRemoteNotificationsWithError error: Error
+    ) {
+      host.didFailToRegisterForRemoteNotifications(error: error)
+    }
+
+    func application(
+      _ application: UIApplication,
+      didReceiveRemoteNotification userInfo: [AnyHashable: Any],
+      fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void
+    ) {
+      host.didReceiveRemoteNotification(userInfo) { result in
+        switch result {
+        case .newData: completionHandler(.newData)
+        case .noData: completionHandler(.noData)
+        case .failed: completionHandler(.failed)
+        }
+      }
+    }
   }
 
   @main

package/ios-simulator-arm64/platform-pack.json

@@ -17,5 +17,31 @@
   ],
   "requiredTools": [
     "xcrun"
-  ]
+  ],
+  "variables": {
+    "build-number": {
+      "kind": "string",
+      "description": "CFBundleVersion, one to three period-separated integers; defaults to the app version"
+    },
+    "entitlements": {
+      "kind": "path",
+      "description": "Entitlements plist layered over the provisioning profile's entitlements at signing"
+    },
+    "plist": {
+      "kind": "path",
+      "description": "Info.plist whose values take precedence over generated and plugin values"
+    },
+    "provisioning-profile": {
+      "kind": "path",
+      "description": "Provisioning profile for manual signing, used with signing-identity"
+    },
+    "signing-identity": {
+      "kind": "string",
+      "description": "SHA-1 of the signing identity for manual signing, used with provisioning-profile"
+    },
+    "team-id": {
+      "kind": "string",
+      "description": "Apple Development team for automatic signing"
+    }
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokamakdev/platform-ios-simulator-arm64",
-  "version": "0.1.1-beta.48",
+  "version": "0.1.1-beta.50",
   "description": "The tokamak platform pack for ios-simulator-arm64",
   "repository": {
     "type": "git",