@tokamakdev/platform-macos-arm64 0.1.1-beta.50 → 0.1.1-beta.52

package/macos-arm64/frameworks/TokamakRuntime.framework/Headers/TokamakRuntime.h

@@ -11,12 +11,6 @@ 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;
@@ -28,7 +22,8 @@ typedef struct {
 } TokamakIdentity;
 
 void *tokamak_runtime_start(const char *packaged_dir, const char *state_dir,
-                         const char *host, char *error, size_t error_len);
+                            const char *storage_dir, const char *host,
+                            char *error, size_t error_len);
 void *tokamak_runtime_start_development(const char *state_dir, const char *host,
                                      const char *endpoint,
                                      const char *session_token, char *error,
@@ -39,10 +34,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);
+bool tokamak_runtime_call(const void *runtime, const char *name,
+                          const char *body, uint64_t timeout_ms,
+                          TokamakBytes *response, char *error,
+                          size_t error_len);
 
 int32_t tokamak_runtime_server_authority(const void *runtime, const char *host,
                                       TokamakBytes *authority);

package/macos-arm64/native-shell/TokamakHost.swift

@@ -32,15 +32,15 @@ final class TokamakHost {
     }
   }
 
-  /// 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,
+  /// Posts `body`, JSON-serialisable, to the Worker's `/tokamak/<name>`
+  /// endpoint and returns the response body. Fails unless the Worker responds
+  /// 200 within `timeout`. Call it on the main thread; `completion` runs on
+  /// the main thread.
+  func call(
+    _ name: String,
+    body: Any,
     timeout: TimeInterval,
-    completion: @escaping (Result<TokamakEventOutcome, Error>) -> Void
+    completion: @escaping (Result<Data, Error>) -> Void
   ) {
     whenStarted { result in
       switch result {
@@ -48,9 +48,7 @@ final class TokamakHost {
         completion(.failure(error))
       case .success(let runtime):
         DispatchQueue.global(qos: .userInitiated).async {
-          let outcome = Result {
-            try runtime.dispatch(event: event, payload: payload, timeout: timeout)
-          }
+          let outcome = Result { try runtime.call(name, body: body, timeout: timeout) }
           DispatchQueue.main.async { completion(outcome) }
         }
       }
@@ -104,14 +102,6 @@ final class TokamakHost {
   }
 }
 
-/// 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
@@ -192,17 +182,21 @@ final class RuntimeHandle {
       guard let bundle else {
         throw RuntimeError.configuration("app bundle resources are unavailable")
       }
+      let storage = try Self.storageDirectory()
       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
-              )
+          storage.path.withCString { storagePath in
+            appHost.withCString { appHost in
+              error.withUnsafeMutableBufferPointer { error in
+                tokamak_runtime_start(
+                  bundlePath,
+                  statePath,
+                  storagePath,
+                  appHost,
+                  error.baseAddress,
+                  error.count
+                )
+              }
             }
           }
         }
@@ -241,49 +235,39 @@ final class RuntimeHandle {
     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")
+  /// Posts `body` to the Worker's `/tokamak/<name>` endpoint, blocking until
+  /// it responds 200 or `timeout` passes.
+  func call(_ name: String, body: Any, timeout: TimeInterval) throws -> Data {
+    guard JSONSerialization.isValidJSONObject([body]) else {
+      throw RuntimeError.runtime("the \(name) call body is not JSON")
     }
-    let payload = String(
-      decoding: try JSONSerialization.data(withJSONObject: payload, options: .fragmentsAllowed),
+    let body = String(
+      decoding: try JSONSerialization.data(withJSONObject: body, options: .fragmentsAllowed),
       as: UTF8.self
     )
-    var result = TokamakBytes(data: nil, len: 0)
+    var response = TokamakBytes(data: nil, len: 0)
     var error = [CChar](repeating: 0, count: 1024)
-    let status = event.withCString { event in
-      payload.withCString { payload in
+    let succeeded = name.withCString { name in
+      body.withCString { body in
         error.withUnsafeMutableBufferPointer { error in
-          tokamak_runtime_dispatch(
+          tokamak_runtime_call(
             handle,
-            event,
-            payload,
+            name,
+            body,
             UInt64(timeout * 1000),
-            &result,
+            &response,
             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:
+    defer { tokamak_bytes_free(response) }
+    guard succeeded else {
       throw RuntimeError.runtime(String(cString: error))
     }
+    guard let bytes = response.data else { return Data() }
+    return Data(bytes: bytes, count: response.len)
   }
 
   func serverAuthority(
@@ -352,21 +336,31 @@ final class RuntimeHandle {
     )
   }
 
+  /// Stores behind storage bindings, which device backups include.
+  private static func storageDirectory() throws -> URL {
+    let storage = try appDirectory(.applicationSupportDirectory)
+      .appendingPathComponent("tokamak/storage", isDirectory: true)
+    try FileManager.default.createDirectory(at: storage, withIntermediateDirectories: true)
+    return storage
+  }
+
   private static func stateDirectory() throws -> URL {
+    let state = try appDirectory(.cachesDirectory)
+    try FileManager.default.createDirectory(at: state, withIntermediateDirectories: true)
+    return state
+  }
+
+  /// This app's folder in the user's `directory`.
+  private static func appDirectory(_ directory: FileManager.SearchPathDirectory) throws -> URL {
     guard let identifier = Bundle.main.bundleIdentifier else {
       throw RuntimeError.configuration("CFBundleIdentifier is required")
     }
-    let root = try FileManager.default.url(
-      for: .cachesDirectory,
+    return try FileManager.default.url(
+      for: directory,
       in: .userDomainMask,
       appropriateFor: nil,
       create: true
     )
-    let state = root.appendingPathComponent(identifier, isDirectory: true)
-    try FileManager.default.createDirectory(
-      at: state,
-      withIntermediateDirectories: true
-    )
-    return state
+    .appendingPathComponent(identifier, isDirectory: true)
   }
 }

package/package.json

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