@tokamakdev/platform-ios-simulator-x64 0.1.1-beta.89 → 0.1.1-beta.90

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

@@ -49,6 +49,9 @@ void tokamak_runtime_stop(void *runtime);
 bool tokamak_runtime_emit(const void *runtime, const char *name,
                           const char *event, uint64_t timeout_ms,
                           TokamakBytes *reply, char *error, size_t error_len);
+bool tokamak_runtime_fetch(const void *runtime, const char *path,
+                           uint64_t timeout_ms, TokamakBytes *body, char *error,
+                           size_t error_len);
 bool tokamak_runtime_set_foreground(const void *runtime, bool foreground);
 bool tokamak_runtime_is_foreground(const void *runtime);
 void tokamak_runtime_reply(const void *runtime, uint64_t id, const char *result);

package/ios-simulator-x64/native-shell/TokamakApp.swift

@@ -117,15 +117,39 @@ final class TokamakApp {
     completion: @escaping (Result<Any?, Error>) -> Void
   ) {
     let deadline = Date() + timeout
+    withRuntime(on: queue, completion: completion) { runtime in
+      try runtime.emit(name, event: event, timeout: deadline.timeIntervalSinceNow)
+    }
+  }
+
+  /// Fetches what the app serves at `path` and calls `completion` on the main
+  /// thread with the body. Fails unless it arrives within `timeout`, which
+  /// includes runtime startup. Call it on the main thread.
+  func fetch(
+    _ path: String,
+    timeout: TimeInterval,
+    completion: @escaping (Result<Data, Error>) -> Void
+  ) {
+    let deadline = Date() + timeout
+    withRuntime(on: .global(qos: .userInitiated), completion: completion) { runtime in
+      try runtime.fetch(path, timeout: deadline.timeIntervalSinceNow)
+    }
+  }
+
+  /// Runs `work` with the started runtime on `queue`, and calls `completion`
+  /// on the main thread with its result.
+  private func withRuntime<Value>(
+    on queue: DispatchQueue,
+    completion: @escaping (Result<Value, Error>) -> Void,
+    work: @escaping (RuntimeHandle) throws -> Value
+  ) {
     whenStarted { result in
       switch result {
       case .failure(let error):
         completion(.failure(error))
       case .success(let runtime):
         queue.async {
-          let outcome = Result {
-            try runtime.emit(name, event: event, timeout: deadline.timeIntervalSinceNow)
-          }
+          let outcome = Result { try work(runtime) }
           DispatchQueue.main.async { completion(outcome) }
         }
       }
@@ -416,6 +440,30 @@ final class RuntimeHandle {
     return value is NSNull ? nil : value
   }
 
+  /// What the app serves at `path`, blocking until it arrives or `timeout`
+  /// passes.
+  func fetch(_ path: String, timeout: TimeInterval) throws -> Data {
+    var body = TokamakBytes()
+    var error = [CChar](repeating: 0, count: 1024)
+    let succeeded = path.withCString { path in
+      error.withUnsafeMutableBufferPointer { error in
+        tokamak_runtime_fetch(
+          handle,
+          path,
+          UInt64(max(timeout, 0) * 1000),
+          &body,
+          error.baseAddress,
+          error.count
+        )
+      }
+    }
+    defer { tokamak_bytes_free(body) }
+    guard succeeded else {
+      throw RuntimeError.runtime(String(cString: error))
+    }
+    return body.contents ?? Data()
+  }
+
   /// Records whether the app is in the foreground, which the Worker's
   /// `getLifecycleStage()` reports from then on, and returns whether that
   /// changed.

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

@@ -51,6 +51,18 @@ final class TokamakHost {
   ) {
     app.emit("\(plugin).\(name)", event: event, timeout: timeout, completion: completion)
   }
+
+  /// Fetches what the app serves at `path`, as its WebView would load it: a
+  /// file the app ships or the Worker's response. Calls `completion` on the
+  /// main thread with the body. Fails unless it arrives within `timeout`,
+  /// which includes runtime startup. Call it on the main thread.
+  func fetch(
+    _ path: String,
+    timeout: TimeInterval,
+    completion: @escaping (Result<Data, Error>) -> Void
+  ) {
+    app.fetch(path, timeout: timeout, completion: completion)
+  }
 }
 
 /// A native plugin, created once per process when the app launches. The page

package/package.json

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