@tokamakdev/platform-macos-x64 0.1.1-beta.127 → 0.1.1-beta.129

package/macos-x64/build/entrypoint

@@ -11,8 +11,71 @@ fi
 if [[ $# -eq 1 && $1 == certs ]]; then
   exec "$apple_tool" inventory
 fi
+
+# Describes the methods PLUGIN/apple/Exports.swift exports on each PLATFORM
+# into OUTPUT/description.json, with the dispatch that serves them,
+# OUTPUT/Exports.generated.swift. The compiler's symbol graph of the plugin,
+# built with the shell for each platform, gives the methods' types.
+describe() {
+  local plugin=$1 output=$2
+  shift 2
+  if ! xcrun --sdk iphonesimulator --show-sdk-path > /dev/null 2>&1; then
+    echo "Describing an Apple plugin needs Xcode" >&2
+    exit 69
+  fi
+  # Global, for the exit trap.
+  temporary=$(mktemp -d "${TMPDIR:-/tmp}/tokamak-describe.XXXXXX")
+  trap 'rm -rf "$temporary"' EXIT
+  printf '%s\n' 'func tokamakPlugins(app: TokamakApp) -> [any TokamakPlugin] { [] }' > "$temporary/registry.swift"
+  local sources=("$pack/native-shell"/*.swift "$temporary/registry.swift") source
+  while IFS= read -r -d '' source; do
+    [[ ${source##*/} == Exports.generated.swift ]] || sources+=("$source")
+  done < <(find "$plugin/apple" -name '*.swift' -print0 | sort -z)
+  local graphs=() compiles=() platform sdk triple
+  for platform in "$@"; do
+    case "$platform" in
+      ios)
+        sdk=iphonesimulator
+        triple=$(uname -m)-apple-ios$(<"$pack/build/ios-deployment-target")-simulator
+        ;;
+      macos)
+        sdk=macosx
+        triple=$(uname -m)-apple-macos$(<"$pack/build/macos-deployment-target")
+        ;;
+      *)
+        echo "Apple plugins run on ios and macos, not $platform" >&2
+        exit 2
+        ;;
+    esac
+    mkdir "$temporary/$platform"
+    # The platforms compile at once, each into its own log.
+    xcrun --sdk "$sdk" swiftc -emit-module -module-name TokamakDescribed -swift-version 5 \
+      -target "$triple" -F "$pack/frameworks" -module-cache-path "$temporary/cache" \
+      -emit-module-path "$temporary/$platform/TokamakDescribed.swiftmodule" \
+      -emit-symbol-graph -emit-symbol-graph-dir "$temporary/$platform" \
+      -symbol-graph-minimum-access-level private "${sources[@]}" > "$temporary/$platform.log" 2>&1 &
+    compiles+=("$!")
+    graphs+=("$platform=$temporary/$platform/TokamakDescribed.symbols.json")
+  done
+  # The platforms report the same diagnostics, so only the first failure's
+  # show, or else the first platform's warnings.
+  local platforms=("$@") index failed=
+  for index in "${!compiles[@]}"; do
+    if ! wait "${compiles[index]}" && [[ -z $failed ]]; then
+      failed=$index
+    fi
+  done
+  cat "$temporary/${platforms[${failed:-0}]}.log" >&2
+  [[ -z $failed ]] || exit 1
+  "$pack/tools/tokamak-swift-describe" "$plugin/apple/Exports.swift" "$output" "${graphs[@]}"
+}
+if [[ $# -ge 4 && $1 == describe ]]; then
+  describe "${@:2}"
+  exit
+fi
+
 if [[ $# -ne 3 || $1 != build ]]; then
-  echo "usage: entrypoint build INPUT OUTPUT | entrypoint certs" >&2
+  echo "usage: entrypoint build INPUT OUTPUT | entrypoint describe PLUGIN OUTPUT PLATFORM... | entrypoint certs" >&2
   exit 2
 fi
 
@@ -169,46 +232,33 @@ if [[ ! -f "$pack/native-shell/TokamakShell.swift" ]]; then
 fi
 
 # A plugin's class is a Swift type name, which the registry creates, and its
-# sources are Swift.
+# sources are the Swift files in its native directory.
 swift_type='^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$'
-# Swift requires unique file names in a module, so the source staged as
-# <plugin>/<key>/<name> compiles as <plugin>-<key>-<name>.
+# Swift requires unique file names in a module, so a plugin's source
+# <directory>/<name> compiles as <plugin>-<directory>-<name>.
 plugin_sources=$temporary/plugin-sources
 mkdir "$plugin_sources"
-add_plugin_source() {
-  local plugin_id=$1 source=$2
-  local key=${source%/*}
-  local named=$plugin_sources/$plugin_id-${key##*/}-${source##*/}
-  cp "$source" "$named"
-  swift_sources+=("$named")
-}
 registry=$temporary/TokamakPluginRegistry.swift
 printf '%s\n\n%s\n%s\n' 'import Foundation' 'func tokamakPlugins(app: TokamakApp) -> [any TokamakPlugin] {' '  [' > "$registry"
 for plugin in "$input/plugins"/*/; do
   plugin_id=$(basename "$plugin")
   class=$(cat "$plugin/class" 2>/dev/null || true)
-  # A plugin whose native code is its generated bindings alone has no class.
-  if [[ -n "$class" || ! -d "$plugin/bindings" ]]; then
-    if [[ ! "$class" =~ $swift_type ]]; then
-      echo "plugin '$plugin_id' has invalid $platform class '$class'" >&2
+  if [[ ! "$class" =~ $swift_type ]]; then
+    echo "plugin '$plugin_id' has invalid $platform class '$class'" >&2
+    exit 1
+  fi
+  printf '    %s(host: TokamakHost(app: app, plugin: "%s")),\n' "$class" "$plugin_id" >> "$registry"
+  [[ -d "$plugin/native" ]] || continue
+  while IFS= read -r -d '' source; do
+    relative=${source#"$plugin/native/"}
+    named=$plugin_sources/$plugin_id-${relative//\//-}
+    if [[ -e "$named" ]]; then
+      echo "plugin '$plugin_id' source $relative stages as ${named##*/}, as another source does; rename one" >&2
       exit 1
     fi
-    printf '    %s(host: TokamakHost(app: app, plugin: "%s")),\n' "$class" "$plugin_id" >> "$registry"
-  fi
-  # `tok bindings` names the generated class TokamakBindings_<id>, with - as _.
-  for source in "$plugin/bindings"/*.swift; do
-    printf '    TokamakBindings_%s(host: TokamakHost(app: app, plugin: "%s")),\n' "${plugin_id//-/_}" "$plugin_id" >> "$registry"
-    add_plugin_source "$plugin_id" "$source"
-  done
-  for source in "$plugin/sources"/*; do
-    case "$source" in
-      *.swift) add_plugin_source "$plugin_id" "$source" ;;
-      *)
-        echo "Apple plugin source must be Swift: $source" >&2
-        exit 1
-        ;;
-    esac
-  done
+    cp "$source" "$named"
+    swift_sources+=("$named")
+  done < <(find "$plugin/native" -name '*.swift' -print0 | sort -z)
 done
 printf '%s\n' '  ]' '}' >> "$registry"
 

package/macos-x64/native-shell/TokamakControls.swift

@@ -9,10 +9,9 @@ final class TokamakCorePlugin: TokamakPlugin {
 
   init(host: TokamakHost) { self.host = host }
 
-  /// WebView operations and the presenter run on the main thread, which
-  /// WebKit and UIKit require.
+  /// WebView operations run on the main thread, which WebKit requires.
   func executor(for method: String) -> DispatchQueue {
-    method.hasPrefix("webview.") || method == "resource.root" ? .main : queue
+    method.hasPrefix("webview.") ? .main : queue
   }
 
   func call(method: String, arguments: Any, reply: @escaping TokamakPluginReply) -> (() -> Void)? {
@@ -22,11 +21,6 @@ final class TokamakCorePlugin: TokamakPlugin {
         Result { () throws(TokamakPluginError) -> Any? in
           try host.resources.get(arguments, as: Data.self)
         })
-    case "resource.release":
-      host.resources.release(arguments)
-      reply(.success(nil))
-    case "resource.root":
-      reply(Result { () throws(TokamakPluginError) -> Any? in try root(arguments) })
     case "webview.getCurrentPage":
       reply(.success(host.webView?.url?.absoluteString))
     case "webview.navigate":
@@ -39,28 +33,6 @@ final class TokamakCorePlugin: TokamakPlugin {
     return nil
   }
 
-  /// `resource.scope` opens a scope for the objects an invocation receives,
-  /// which ends with the subscription.
-  func subscribe(method: String, arguments: Any, reply: @escaping TokamakPluginReply)
-    throws(TokamakPluginError) -> () -> Void
-  {
-    guard method == "resource.scope" else {
-      throw .notSupported("\(id).\(method) is not supported")
-    }
-    let scope = host.resources.open()
-    reply(.success(scope))
-    return { [host] in host.resources.end(scope) }
-  }
-
-  /// Retains the app object `name` in `scope` and returns its ID: the
-  /// `presenter` a native screen is presented from.
-  private func root(_ arguments: Any) throws(TokamakPluginError) -> String {
-    let arguments = arguments as? [String: Any]
-    guard let scope = arguments?["scope"] as? String, arguments?["name"] as? String == "presenter"
-    else { throw .notSupported("\(id).resource.root has no such object") }
-    return try host.resources.retain(host.presenter(), in: scope)
-  }
-
   /// Starts navigation to the app URL `path`, relative to the current page or
   /// the app origin.
   private func navigate(to path: Any) -> Result<Void, TokamakPluginError> {

package/macos-x64/native-shell/TokamakExports.swift

@@ -0,0 +1,561 @@
+import Foundation
+
+/// A plugin whose `apple/Exports.swift` lists the methods the Worker calls
+/// and the events it receives. `tok plugin generate apple` reads it and writes
+/// the plugin's dispatch and TypeScript API.
+protocol TokamakExports: TokamakPlugin {
+  /// The plugin's host, whose resources hold the native references methods take.
+  var host: TokamakHost { get }
+
+  /// Lists the exported methods and events. The app never calls it.
+  static func exports(_ e: inout TokamakExporter<Self>)
+
+  /// `event` as the JSON data of the event `name`, which the registration lists.
+  func eventPayload(_ name: String, _ event: Any) throws(TokamakPluginError) -> Data
+
+  /// The listeners' JSON `reply` to the event `name`, which the registration
+  /// lists with a reply, as its type, or nil for null.
+  func eventReply(_ name: String, _ reply: Data) throws(TokamakPluginError) -> Any?
+}
+
+extension TokamakExports {
+  func eventPayload(_ name: String, _ event: Any) throws(TokamakPluginError) -> Data {
+    throw .unlistedEvent(name)
+  }
+
+  func eventReply(_ name: String, _ reply: Data) throws(TokamakPluginError) -> Any? {
+    throw .unlistedReply(name)
+  }
+}
+
+/// What a stream does with values a slow reader has not taken.
+enum TokamakOverflow {
+  /// Ends the stream with `QuotaExceededError`.
+  case error
+  /// Drops the oldest values, for samples where only recent ones matter.
+  case dropOldest
+}
+
+/// Lists a plugin's exported methods and events: method parameters and event
+/// replies are `Decodable`, method results and events `Encodable`, and options
+/// literal values.
+struct TokamakExporter<Plugin> {
+  /// Lists the event `name`, whose listeners receive an `E`.
+  mutating func event<E: Encodable>(_ name: String, _ type: E.Type, doc: String = "") {}
+
+  /// Lists the event `name`, whose listeners receive an `E` and may reply with an `R`.
+  mutating func event<E: Encodable, R: Decodable>(
+    _ name: String, _ type: E.Type, reply: R.Type, doc: String = ""
+  ) {}
+
+  /// Exports `method`, which returns once.
+  mutating func call<each A: Decodable, R: Encodable>(
+    _ method: (Plugin) -> (repeat each A) async throws -> R, doc: String = ""
+  ) {}
+
+  mutating func call<each A: Decodable>(
+    _ method: (Plugin) -> (repeat each A) async throws -> Void, doc: String = ""
+  ) {}
+
+  /// Exports `method`, whose last parameter reads the bytes the Worker streams.
+  mutating func call<each A: Decodable, R: Encodable>(
+    _ method: (Plugin) -> (repeat each A, TokamakPluginBody) async throws -> R, doc: String = ""
+  ) {}
+
+  mutating func call<each A: Decodable>(
+    _ method: (Plugin) -> (repeat each A, TokamakPluginBody) async throws -> Void, doc: String = ""
+  ) {}
+
+  /// Exports `method`, which returns the values it sends until the Worker cancels.
+  mutating func stream<each A: Decodable, S: AsyncSequence>(
+    _ method: (Plugin) -> (repeat each A) throws -> S, overflow: TokamakOverflow = .error,
+    doc: String = ""
+  ) where S.Element: Encodable {}
+
+  /// Exports `method`, which returns a native object the Worker holds as a
+  /// `NativeReference`.
+  mutating func resource<each A: Decodable, R>(
+    _ method: (Plugin) -> (repeat each A) async throws -> R, doc: String = ""
+  ) {}
+}
+
+/// A native object the Worker passes as a `NativeReference`, which another
+/// plugin retained.
+struct TokamakReference<Object>: Decodable {
+  let object: Object
+
+  init(from decoder: any Decoder) throws {
+    let id = try decoder.singleValueContainer().decode(String.self)
+    guard let resources = decoder.userInfo[.tokamakResources] as? TokamakResources else {
+      throw TokamakPluginError(name: "InvalidStateError", message: "No native references here")
+    }
+    object = try resources.get(id, as: Object.self)
+  }
+}
+
+/// Any JSON value, for data a plugin passes through or reads itself.
+enum TokamakJSON: Codable, Equatable {
+  case null
+  case bool(Bool)
+  case number(Double)
+  case string(String)
+  case array([TokamakJSON])
+  case object([String: TokamakJSON])
+
+  init(from decoder: any Decoder) throws {
+    // Each failed attempt throws, so the commonest kinds of value come first.
+    let container = try decoder.singleValueContainer()
+    if container.decodeNil() {
+      self = .null
+    } else if let string = try? container.decode(String.self) {
+      self = .string(string)
+    } else if let number = try? container.decode(Double.self) {
+      self = .number(number)
+    } else if let bool = try? container.decode(Bool.self) {
+      self = .bool(bool)
+    } else if let object = try? container.decode([String: TokamakJSON].self) {
+      self = .object(object)
+    } else {
+      self = .array(try container.decode([TokamakJSON].self))
+    }
+  }
+
+  func encode(to encoder: any Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .null: try container.encodeNil()
+    case .bool(let bool): try container.encode(bool)
+    case .number(let number): try container.encode(number)
+    case .string(let string): try container.encode(string)
+    case .array(let array): try container.encode(array)
+    case .object(let object): try container.encode(object)
+    }
+  }
+
+  /// `value` as JSON, which `JSONSerialization` writes it as, or nil when it is not JSON.
+  init?(_ value: Any) {
+    switch value {
+    case is NSNull: self = .null
+    case let number as NSNumber where CFGetTypeID(number) == CFBooleanGetTypeID():
+      self = .bool(number.boolValue)
+    case let number as NSNumber: self = .number(number.doubleValue)
+    case let string as String: self = .string(string)
+    case let array as [Any]:
+      let elements = array.compactMap(TokamakJSON.init)
+      guard elements.count == array.count else { return nil }
+      self = .array(elements)
+    case let object as [String: Any]:
+      let entries = object.compactMapValues(TokamakJSON.init)
+      guard entries.count == object.count else { return nil }
+      self = .object(entries)
+    default: return nil
+    }
+  }
+
+  /// The value as `JSONSerialization` reads it: `NSNull`, an `NSNumber` for a boolean or a
+  /// number, which `as? Int` reads when whole, `String`, arrays and dictionaries.
+  var value: Any {
+    switch self {
+    case .null: NSNull()
+    case .bool(let bool): NSNumber(value: bool)
+    case .number(let number): NSNumber(value: number)
+    case .string(let string): string
+    case .array(let array): array.map(\.value)
+    case .object(let object): object.mapValues(\.value)
+    }
+  }
+}
+
+/// An enum whose cases are the forms its values take: a case without an associated value is
+/// the string of its name, and a case with one unlabeled associated value is that value.
+/// `tok plugin generate apple` writes its coding in place of these defaults, which throw.
+protocol TokamakUnion: Codable {}
+
+/// A `TokamakUnion` whose values are objects that name their case in the field `tag`, with a
+/// struct case's fields.
+protocol TokamakTaggedUnion: TokamakUnion {
+  /// The tag field's name, as a string literal, which `tok plugin generate apple` reads.
+  static var tag: String { get }
+}
+
+extension TokamakUnion {
+  init(from decoder: any Decoder) throws {
+    throw TokamakPluginError.ungenerated(Self.self)
+  }
+
+  func encode(to encoder: any Encoder) throws {
+    throw TokamakPluginError.ungenerated(Self.self)
+  }
+}
+
+/// The JSON value whose kind a union's generated decoder chooses its case by.
+struct TokamakUnionValue {
+  enum Kind {
+    case null, boolean, number, array
+    case string(String)
+    /// An object, with its keys.
+    case object(Set<String>)
+  }
+
+  let kind: Kind
+  private let decoder: any Decoder
+
+  init(_ decoder: any Decoder) throws {
+    self.decoder = decoder
+    let value = try decoder.singleValueContainer()
+    if value.decodeNil() {
+      kind = .null
+    } else if let string = try? value.decode(String.self) {
+      kind = .string(string)
+    } else if (try? value.decode(Bool.self)) != nil {
+      kind = .boolean
+    } else if (try? value.decode(Double.self)) != nil {
+      kind = .number
+    } else if let object = try? decoder.container(keyedBy: TokamakUnionKey.self) {
+      kind = .object(Set(object.allKeys.map(\.stringValue)))
+    } else {
+      kind = .array
+    }
+  }
+
+  /// The value as a `T`.
+  func decode<T: Decodable>(_ type: T.Type) throws -> T {
+    try decoder.singleValueContainer().decode(type)
+  }
+
+  /// The string in the object's field `tag`.
+  func tag(_ tag: String) throws -> String {
+    try decoder.container(keyedBy: TokamakUnionKey.self).decode(String.self, forKey: .init(tag))
+  }
+
+  /// The error of a value that is none of the union `name`'s forms.
+  func mismatch(_ name: String) -> DecodingError {
+    .dataCorrupted(
+      .init(codingPath: decoder.codingPath, debugDescription: "must be one of \(name)'s forms"))
+  }
+}
+
+/// Encodes the case `name` of a tagged union as an object with `value`'s fields, if any, and the
+/// field `tag` naming the case.
+func tokamakEncode(
+  tag: String, _ name: String, _ value: (any Encodable)? = nil, to encoder: any Encoder
+) throws {
+  try value?.encode(to: encoder)
+  var container = encoder.container(keyedBy: TokamakUnionKey.self)
+  try container.encode(name, forKey: .init(tag))
+}
+
+/// A JSON object's key, as a union's coding reads and writes it.
+struct TokamakUnionKey: CodingKey {
+  let stringValue: String
+  var intValue: Int? { nil }
+
+  init(_ stringValue: String) {
+    self.stringValue = stringValue
+  }
+
+  init?(stringValue: String) {
+    self.stringValue = stringValue
+  }
+
+  init?(intValue: Int) {
+    nil
+  }
+}
+
+extension CodingUserInfoKey {
+  /// The resources a `TokamakReference` finds its object in.
+  fileprivate static let tokamakResources = CodingUserInfoKey(rawValue: "tokamak.resources")!
+}
+
+extension TokamakPluginError {
+  /// A `TypeError` naming where the `root` value, such as a call's
+  /// arguments, fails to decode.
+  init(decoding error: DecodingError, in root: String = "arguments") {
+    let (path, problem): ([any CodingKey], String) =
+      switch error {
+      case .keyNotFound(let key, let context): (context.codingPath + [key], "is missing")
+      case .typeMismatch(_, let context), .valueNotFound(_, let context),
+        .dataCorrupted(let context):
+        (context.codingPath, context.debugDescription)
+      @unknown default: ([], "\(error)")
+      }
+    let location = path.reduce("") { location, key in
+      if let index = key.intValue { return "\(location)[\(index)]" }
+      return location.isEmpty ? key.stringValue : "\(location).\(key.stringValue)"
+    }
+    self.init(name: "TypeError", message: "\(location.isEmpty ? root : location) \(problem)")
+  }
+
+  /// A `TokamakUnion` without the coding `tok plugin generate apple` writes.
+  static func ungenerated(_ union: Any.Type) -> Self {
+    Self(name: "TypeError", message: "run tok plugin generate apple to code \(union)")
+  }
+
+  /// The plugin emitted an event its registration does not list.
+  static func unlistedEvent(_ name: String) -> Self {
+    Self(name: "TypeError", message: "apple/Exports.swift lists no event \(name)")
+  }
+
+  /// The plugin asked for the reply to an event its registration lists without one.
+  static func unlistedReply(_ name: String) -> Self {
+    Self(name: "TypeError", message: "apple/Exports.swift lists no reply to event \(name)")
+  }
+}
+
+/// Decodes a call's JSON arguments, or another `root` value, finding the
+/// native references they name in `resources`.
+func tokamakDecode<T: Decodable>(
+  _ type: T.Type, from payload: Data, resources: TokamakResources? = nil,
+  in root: String = "arguments"
+) throws(TokamakPluginError) -> T {
+  let decoder = JSONDecoder()
+  decoder.userInfo[.tokamakResources] = resources
+  do {
+    return try decoder.decode(type, from: payload)
+  } catch let error as DecodingError {
+    throw TokamakPluginError(decoding: error, in: root)
+  } catch {
+    throw TokamakPluginError(error)
+  }
+}
+
+/// `value` as a reply's payload: `Data` as it is, and any other value as the
+/// JSON `encoder` writes.
+func tokamakEncode<T: Encodable>(
+  _ value: T, with encoder: JSONEncoder = JSONEncoder()
+) throws(TokamakPluginError) -> Data {
+  if let data = value as? Data { return data }
+  do {
+    return try encoder.encode(value)
+  } catch {
+    throw TokamakPluginError(name: "DataCloneError", message: "\(error)")
+  }
+}
+
+/// `event` as the JSON data of the event `name`, whose listeners receive a `T`.
+func tokamakEvent<T: Encodable>(
+  _ name: String, _ event: Any, as type: T.Type
+) throws(TokamakPluginError) -> Data {
+  guard let event = event as? T else {
+    throw TokamakPluginError(
+      name: "TypeError", message: "event \(name) takes \(T.self), not \(Swift.type(of: event))")
+  }
+  return try tokamakEncode(event)
+}
+
+/// Replies with what `method` returns. A synchronous method runs on the
+/// call's executor and has nothing to cancel.
+func tokamakCall<T: Encodable>(
+  _ reply: TokamakPluginBytesReply, _ method: () throws -> T
+) -> (() -> Void)? {
+  reply(result { try tokamakEncode(try method()) })
+  return nil
+}
+
+func tokamakCall(_ reply: TokamakPluginBytesReply, _ method: () throws -> Void) -> (() -> Void)? {
+  reply(
+    result {
+      try method()
+      return null
+    })
+  return nil
+}
+
+/// Runs `method` in a task, replying with what it returns. Cancelling the
+/// call cancels the task.
+func tokamakCall<T: Encodable>(
+  _ reply: @escaping TokamakPluginBytesReply, _ method: @escaping () async throws -> T
+) -> (() -> Void)? {
+  task { reply(await awaitResult { try tokamakEncode(try await method()) }) }
+}
+
+func tokamakCall(
+  _ reply: @escaping TokamakPluginBytesReply, _ method: @escaping () async throws -> Void
+) -> (() -> Void)? {
+  task {
+    reply(
+      await awaitResult {
+        try await method()
+        return null
+      })
+  }
+}
+
+/// Replies with each value `method`'s sequence sends, until it ends or the
+/// subscription is cancelled. A synchronous method runs on the
+/// subscription's executor.
+func tokamakStream<S: AsyncSequence>(
+  _ reply: @escaping TokamakPluginBytesReply, _ method: () throws -> S
+) throws(TokamakPluginError) -> () -> Void where S.Element: Encodable {
+  let values = try catching(method)
+  return task { await send(values, reply) }
+}
+
+func tokamakStream<S: AsyncSequence>(
+  _ reply: @escaping TokamakPluginBytesReply, _ method: @escaping () async throws -> S
+) -> () -> Void where S.Element: Encodable {
+  task {
+    do {
+      await send(try await method(), reply)
+    } catch {
+      reply(TokamakPluginResult(.failure(TokamakPluginError(error)), done: true))
+    }
+  }
+}
+
+/// Retains the object `method` returns in `resources`, replying with its
+/// ID, until the subscription is cancelled. A synchronous method runs on the
+/// subscription's executor.
+func tokamakResource(
+  _ resources: TokamakResources, _ reply: @escaping TokamakPluginBytesReply,
+  _ method: () throws -> Any
+) throws(TokamakPluginError) -> () -> Void {
+  resources.retain(try catching(method)) {
+    reply(TokamakPluginResult($0.flatMap(encodePluginValue), done: false))
+  }
+}
+
+func tokamakResource(
+  _ resources: TokamakResources, _ reply: @escaping TokamakPluginBytesReply,
+  _ method: @escaping () async throws -> Any
+) -> () -> Void {
+  let retained = Retained()
+  let cancel = task {
+    do {
+      let object = try await method()
+      retained.hold(
+        resources.retain(object) {
+          reply(TokamakPluginResult($0.flatMap(encodePluginValue), done: false))
+        })
+    } catch {
+      reply(TokamakPluginResult(.failure(TokamakPluginError(error)), done: true))
+    }
+  }
+  return {
+    cancel()
+    retained.end()
+  }
+}
+
+/// How many values listeners keep: those a slow reader has not taken, or those
+/// held for the first.
+private let listenerCapacity = 64
+
+/// The streams of an event's listeners, such as a page's, each of which
+/// receives every value `send` delivers until it ends, keeping the newest 64
+/// that a slow reader has not taken. When `holding`, the newest 64 values sent
+/// while none listen wait for the first listener.
+final class TokamakListeners<Value>: @unchecked Sendable {
+  private let lock = NSLock()
+  private let holding: Bool
+  private var continuations: [UUID: AsyncStream<Value>.Continuation] = [:]
+  private var held: [Value] = []
+
+  init(holding: Bool = false) {
+    self.holding = holding
+  }
+
+  /// A new listener's stream.
+  // Values are yielded under the lock, so one sent while a listener starts
+  // follows the held ones. Yielding only buffers.
+  func stream() -> AsyncStream<Value> {
+    let (stream, continuation) = AsyncStream.makeStream(
+      of: Value.self, bufferingPolicy: .bufferingNewest(listenerCapacity))
+    let key = UUID()
+    continuation.onTermination = { [weak self] _ in
+      self?.lock.withLock { _ = self?.continuations.removeValue(forKey: key) }
+    }
+    lock.withLock {
+      continuations[key] = continuation
+      for value in held {
+        continuation.yield(value)
+      }
+      held = []
+    }
+    return stream
+  }
+
+  func send(_ value: Value) {
+    lock.withLock {
+      if holding && continuations.isEmpty {
+        held.append(value)
+        if held.count > listenerCapacity { held.removeFirst() }
+      }
+      for continuation in continuations.values {
+        continuation.yield(value)
+      }
+    }
+  }
+}
+
+/// The JSON payload of a method that returns nothing.
+private let null = Data("null".utf8)
+
+/// A call's last reply: `payload`'s bytes, or its failure.
+private func result(_ payload: () throws -> Data) -> TokamakPluginResult {
+  TokamakPluginResult(Result { () throws(TokamakPluginError) in try catching(payload) }, done: true)
+}
+
+private func awaitResult(_ payload: () async throws -> Data) async -> TokamakPluginResult {
+  do {
+    return TokamakPluginResult(.success(try await payload()), done: true)
+  } catch {
+    return TokamakPluginResult(.failure(TokamakPluginError(error)), done: true)
+  }
+}
+
+/// What `body` returns, with what it throws as a `TokamakPluginError`.
+private func catching<T>(_ body: () throws -> T) throws(TokamakPluginError) -> T {
+  do {
+    return try body()
+  } catch {
+    throw TokamakPluginError(error)
+  }
+}
+
+/// Runs `body` in a task, returning its cancellation.
+private func task(_ body: @escaping () async -> Void) -> () -> Void {
+  Task { await body() }.cancel
+}
+
+/// Replies with each of `values`, then with the end of the subscription.
+private func send<S: AsyncSequence>(
+  _ values: S, _ reply: TokamakPluginBytesReply
+) async where S.Element: Encodable {
+  // One encoder serves the stream, whose values it encodes one at a time.
+  let encoder = JSONEncoder()
+  do {
+    for try await value in values {
+      reply(TokamakPluginResult(.success(try tokamakEncode(value, with: encoder)), done: false))
+    }
+    reply(TokamakPluginResult(payload: Data(), failed: false, done: true))
+  } catch {
+    reply(TokamakPluginResult(.failure(TokamakPluginError(error)), done: true))
+  }
+}
+
+/// The release of an object a subscription retains, which runs once the
+/// subscription ends, whether the object is retained before or after.
+private final class Retained {
+  private let lock = NSLock()
+  private var release: (() -> Void)?
+  private var ended = false
+
+  func hold(_ release: @escaping () -> Void) {
+    let ended = lock.withLock {
+      if !self.ended { self.release = release }
+      return self.ended
+    }
+    if ended { release() }
+  }
+
+  func end() {
+    let release = lock.withLock {
+      ended = true
+      defer { self.release = nil }
+      return self.release
+    }
+    release?()
+  }
+}

package/macos-x64/native-shell/TokamakPlugins.swift

@@ -140,7 +140,7 @@ final class TokamakHost {
   #endif
 
   /// Delivers the plugin's event `name`, which the Worker's listeners
-  /// receive as `<plugin>.<name>`, with its encoded `payload`, and calls
+  /// receive as `<plugin>.apple.<name>`, with its encoded `payload`, and calls
   /// `completion` on the main thread with their encoded reply, which is empty
   /// when none replied. Fails unless they return within `timeout`, which
   /// includes runtime startup. Call it on the main thread.
@@ -150,33 +150,75 @@ final class TokamakHost {
     timeout: TimeInterval,
     completion: @escaping (Result<Data, Error>) -> Void
   ) {
-    app.emit("\(plugin).\(name)", payload: payload, timeout: timeout, completion: completion)
+    app.emit("\(plugin).apple.\(name)", payload: payload, timeout: timeout, completion: completion)
   }
 
-  /// `emitBytes` with `event` encoded as JSON, calling `completion` with the
-  /// reply parsed from JSON, or nil when none replied.
+  /// Delivers `event` to the Worker's listeners of the plugin's event `name`,
+  /// which `apple/Exports.swift` lists, then calls `completion` on the main
+  /// thread. Fails unless they return within `timeout`, which includes runtime
+  /// startup. Call it on the main thread.
   func emit(
     _ name: String,
-    event: Any,
+    event: some Encodable,
     timeout: TimeInterval,
-    completion: @escaping (Result<Any?, Error>) -> Void
+    completion: @escaping (Result<Void, Error>) -> Void
   ) {
-    let payload: Data
-    switch encodePluginValue(event) {
-    case .success(let encoded): payload = encoded
-    case .failure(let error): return completion(.failure(error))
-    }
-    emitBytes(name, payload: payload, timeout: timeout) { result in
+    send(name, event, timeout: timeout) { completion($0.map { _ in }) }
+  }
+
+  /// `emit` of an event whose listeners may reply, calling `completion` with
+  /// the reply as the plugin's generated dispatch decodes it, which is a
+  /// `Reply`, or nil when none replied.
+  func emit<Reply>(
+    _ name: String,
+    event: some Encodable,
+    reply: Reply.Type,
+    timeout: TimeInterval,
+    completion: @escaping (Result<Reply?, Error>) -> Void
+  ) {
+    send(name, event, timeout: timeout) { result in
       completion(
         result.flatMap { reply in
-          Result { () throws(TokamakPluginError) -> Any? in
-            let value = reply.isEmpty ? NSNull() : try decodePluginValue(reply)
-            return value is NSNull ? nil : value
-          }.mapError { $0 }
+          Result<Reply?, Error> { try self.decoded(reply, to: name, as: Reply.self) }
         })
     }
   }
 
+  /// Delivers `event` as the plugin's generated dispatch encodes it.
+  private func send(
+    _ name: String, _ event: Any, timeout: TimeInterval,
+    completion: @escaping (Result<Data, Error>) -> Void
+  ) {
+    let payload: Data
+    do throws(TokamakPluginError) {
+      payload = try exports(name).eventPayload(name, event)
+    } catch {
+      return completion(.failure(error))
+    }
+    emitBytes(name, payload: payload, timeout: timeout, completion: completion)
+  }
+
+  /// The listeners' `reply` to the event `name` as a `Reply`, or nil when none replied.
+  private func decoded<Reply>(
+    _ reply: Data, to name: String, as type: Reply.Type
+  ) throws(TokamakPluginError) -> Reply? {
+    guard !reply.isEmpty, let value = try exports(name).eventReply(name, reply) else { return nil }
+    guard let reply = value as? Reply else {
+      throw TokamakPluginError(
+        name: "TypeError",
+        message: "event \(name) replies with \(Swift.type(of: value)), not \(Reply.self)")
+    }
+    return reply
+  }
+
+  /// The plugin, whose generated dispatch encodes the event `name`.
+  private func exports(_ name: String) throws(TokamakPluginError) -> any TokamakExports {
+    guard let exports = app.plugins[plugin] as? any TokamakExports else {
+      throw .unlistedEvent(name)
+    }
+    return exports
+  }
+
   /// 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`,

package/macos-x64/native-shell/TokamakResources.swift

@@ -1,61 +1,23 @@
 import Foundation
 
-/// Native objects that plugins share by ID. Each belongs to a scope and is
-/// kept until it is released or its scope ends.
+/// Native objects that plugins share by ID. Each is kept until the
+/// subscription that retained it ends.
 final class TokamakResources {
   private let lock = NSLock()
-  private var objects: [String: (object: Any, scope: String)] = [:]
-  private var scopes: [String: Set<String>] = [:]
+  private var objects: [String: Any] = [:]
 
-  /// Starts a scope and returns its ID.
-  func open() -> String {
-    let scope = UUID().uuidString
-    lock.withLock { scopes[scope] = [] }
-    return scope
-  }
-
-  /// Keeps `object` in `scope` and returns its ID. An ended scope keeps
-  /// nothing, so the ID finds no object.
-  func retain(_ object: Any, in scope: String) -> String {
-    let id = UUID().uuidString
-    lock.withLock {
-      guard scopes[scope]?.insert(id) != nil else { return }
-      objects[id] = (object, scope)
-    }
-    return id
-  }
-
-  /// Keeps `object` in a scope of its own, replies with its ID, and returns
-  /// the release to return from `subscribe`.
+  /// Keeps `object`, replies with its ID, and returns the release to return
+  /// from `subscribe`.
   func retain(_ object: Any, reply: TokamakPluginReply) -> () -> Void {
-    let scope = open()
-    reply(.success(retain(object, in: scope)))
-    return { [self] in end(scope) }
-  }
-
-  /// Releases the object retained as `id`, if it is still kept.
-  func release(_ id: Any) {
-    let removed = lock.withLock { () -> Any? in
-      guard let id = id as? String, let entry = objects.removeValue(forKey: id) else { return nil }
-      scopes[entry.scope]?.remove(id)
-      return entry.object
-    }
-    drop(removed)
-  }
-
-  /// Releases every object `scope` keeps, and keeps nothing in it later.
-  func end(_ scope: String) {
-    let removed = lock.withLock { () -> [Any] in
-      (scopes.removeValue(forKey: scope) ?? []).compactMap {
-        objects.removeValue(forKey: $0)?.object
-      }
-    }
-    drop(removed)
+    let id = UUID().uuidString
+    lock.withLock { objects[id] = object }
+    reply(.success(id))
+    return { [self] in drop(lock.withLock { objects.removeValue(forKey: id) }) }
   }
 
   /// The object retained as `id`.
   func get<Object>(_ id: Any, as type: Object.Type) throws(TokamakPluginError) -> Object {
-    guard let id = id as? String, let object = lock.withLock({ objects[id]?.object }) else {
+    guard let id = id as? String, let object = lock.withLock({ objects[id] }) else {
       throw TokamakPluginError(name: "InvalidStateError", message: "The native reference is closed")
     }
     guard let typed = object as? Object else {
@@ -65,10 +27,10 @@ final class TokamakResources {
     return typed
   }
 
-  /// Lets go of released objects on the main thread, where UI and run loop
+  /// Lets go of a released object on the main thread, where UI and run loop
   /// objects expect to be deallocated.
-  private func drop(_ objects: Any?) {
-    guard let objects else { return }
-    DispatchQueue.main.async { withExtendedLifetime(objects) {} }
+  private func drop(_ object: Any?) {
+    guard let object else { return }
+    DispatchQueue.main.async { withExtendedLifetime(object) {} }
   }
 }

package/macos-x64/platform-pack.json

@@ -20,10 +20,8 @@
     }
   },
   "pluginKeys": {
-    "bindings": "paths",
     "class": "string",
     "plist": "path",
-    "resources": "paths",
-    "sources": "paths"
+    "resources": "paths"
   }
 }

package/macos-x64/tools/tokamak-swift-describe

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: package/macos-x64/tools/tokamak-swift-describe
+size: 34569672 bytes
+sha256: 131a2a07b15017bbce0064d2eb2bcf22eb1240493d15b85d43e46d69330c6ecc

package/package.json

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

package/macos-x64/native-shell/TokamakBindings.swift

@@ -1,324 +0,0 @@
-import Foundation
-
-/// One call or subscription of a generated platform binding. It decodes the
-/// Worker's JSON into native values and encodes native values back, keeping
-/// the native objects it returns in the receiving invocation's scope.
-///
-/// JSON objects tagged `#` carry what JSON lacks: native objects, dates,
-/// bytes, errors, non-finite numbers, and records whose keys include `#`.
-struct TokamakBinding {
-  private let resources: TokamakResources
-  private let request: [String: Any]
-  private let reply: TokamakPluginBytesReply
-
-  init(
-    _ payload: Data, resources: TokamakResources, reply: @escaping TokamakPluginBytesReply
-  ) throws(TokamakPluginError) {
-    guard let request = try decodePluginValue(payload) as? [String: Any] else {
-      throw typeError("A binding request is an object")
-    }
-    self.resources = resources
-    self.request = request
-    self.reply = reply
-  }
-
-  /// The rejection of a member the running OS version lacks.
-  static let unavailable = TokamakPluginError.notSupported(
-    "The API is unavailable on this OS version")
-
-  /// Argument `index` as JSON.
-  subscript(index: Int) -> Any {
-    let arguments = request["arguments"] as? [Any] ?? []
-    return arguments.indices.contains(index) ? arguments[index] : NSNull()
-  }
-
-  /// The object the call is made on.
-  func target<T>(_ type: T.Type) throws -> T {
-    try object(request["target"] as Any, as: type)
-  }
-
-  /// The handlers an implementation calls.
-  var methods: Set<String> {
-    Set(request["methods"] as? [String] ?? [])
-  }
-
-  private var scope: String {
-    request["scope"] as? String ?? ""
-  }
-
-  // MARK: Decoding
-
-  func decode(_ value: Any, as type: Bool.Type) throws -> Bool {
-    guard let value = value as? Bool else { throw mismatch(value, type) }
-    return value
-  }
-
-  func decode<T: BinaryInteger>(_ value: Any, as type: T.Type) throws -> T {
-    guard let number = value as? NSNumber, let value = T(exactly: number.doubleValue) else {
-      throw mismatch(value, type)
-    }
-    return value
-  }
-
-  func decode<T: BinaryFloatingPoint>(_ value: Any, as type: T.Type) throws -> T {
-    if let number = value as? NSNumber { return T(number.doubleValue) }
-    guard let number = try Double(decode(tagged(value, "number"), as: String.self)) else {
-      throw mismatch(value, type)
-    }
-    return T(number)
-  }
-
-  func decode(_ value: Any, as type: String.Type) throws -> String {
-    guard let value = value as? String else { throw mismatch(value, type) }
-    return value
-  }
-
-  func decode(_ value: Any, as type: NSNumber.Type) throws -> NSNumber {
-    guard let value = value as? NSNumber else { throw mismatch(value, type) }
-    return value
-  }
-
-  func decode(_ value: Any, as type: Locale.Type) throws -> Locale {
-    Locale(identifier: try decode(value, as: String.self))
-  }
-
-  func decode(_ value: Any, as type: TimeZone.Type) throws -> TimeZone {
-    guard let zone = TimeZone(identifier: try decode(value, as: String.self)) else {
-      throw mismatch(value, type)
-    }
-    return zone
-  }
-
-  func decode(_ value: Any, as type: Date.Type) throws -> Date {
-    Date(timeIntervalSince1970: try decode(tagged(value, "date"), as: Double.self) / 1000)
-  }
-
-  func decode(_ value: Any, as type: Data.Type) throws -> Data {
-    guard let data = Data(base64Encoded: try decode(tagged(value, "bytes"), as: String.self)) else {
-      throw mismatch(value, type)
-    }
-    return data
-  }
-
-  func decode(_ value: Any, as type: URL.Type) throws -> URL {
-    guard let url = URL(string: try decode(value, as: String.self)) else {
-      throw mismatch(value, type)
-    }
-    return url
-  }
-
-  func decode(_ value: Any, as type: UUID.Type) throws -> UUID {
-    guard let uuid = UUID(uuidString: try decode(value, as: String.self)) else {
-      throw mismatch(value, type)
-    }
-    return uuid
-  }
-
-  /// The field `name` of the struct `value`.
-  func field(_ value: Any, _ name: String) throws -> Any {
-    guard let fields = value as? [String: Any] else { throw mismatch(value, [String: Any].self) }
-    return fields[name] ?? NSNull()
-  }
-
-  /// The native object `value` refers to.
-  func object<T>(_ value: Any, as type: T.Type) throws -> T {
-    try resources.get(tagged(value, "object", key: "id"), as: type)
-  }
-
-  func optional<T>(_ value: Any, _ decode: (Any) throws -> T) rethrows -> T? {
-    value is NSNull ? nil : try decode(value)
-  }
-
-  func array<T>(_ value: Any, _ decode: (Any) throws -> T) throws -> [T] {
-    guard let values = value as? [Any] else { throw mismatch(value, [T].self) }
-    return try values.map(decode)
-  }
-
-  func record<T>(_ value: Any, _ decode: (Any) throws -> T) throws -> [String: T] {
-    let fields = (try? tagged(value, "record")) ?? value
-    guard let fields = fields as? [String: Any] else { throw mismatch(value, [String: T].self) }
-    return try fields.mapValues(decode)
-  }
-
-  // MARK: Encoding
-
-  func encode(_ value: Bool) -> Any { value }
-
-  func encode<T: BinaryInteger>(_ value: T) -> Any {
-    Int64(exactly: value).map { NSNumber(value: $0) } ?? NSNumber(value: Double(value))
-  }
-
-  func encode<T: BinaryFloatingPoint>(_ value: T) -> Any {
-    let number = Double(value)
-    if number.isFinite { return number }
-    return ["#": "number", "value": number.isNaN ? "NaN" : number > 0 ? "Infinity" : "-Infinity"]
-  }
-
-  func encode(_ value: String) -> Any { value }
-
-  func encode(_ value: NSNumber) -> Any { encode(value.doubleValue) }
-
-  func encode(_ value: Locale) -> Any { value.identifier }
-
-  func encode(_ value: TimeZone) -> Any { value.identifier }
-
-  func encode(_ value: Date) -> Any { ["#": "date", "value": value.timeIntervalSince1970 * 1000] }
-
-  func encode(_ value: Data) -> Any { ["#": "bytes", "value": value.base64EncodedString()] }
-
-  func encode(_ value: URL) -> Any { value.absoluteString }
-
-  func encode(_ value: UUID) -> Any { value.uuidString }
-
-  func encode(_ value: any Error) -> Any {
-    TokamakPluginError(value).json.merging(["#": "error"]) { $1 }
-  }
-
-  /// Keeps `value` in the invocation's scope and refers to it, with the
-  /// names of its class and superclasses.
-  func encode(object value: Any) -> Any {
-    ["#": "object", "id": resources.retain(value, in: scope), "types": types(of: value)]
-  }
-
-  func encode<T>(optional value: T?, _ encode: (T) -> Any) -> Any {
-    value.map(encode) ?? NSNull()
-  }
-
-  func encode<S: Sequence>(array values: S, _ encode: (S.Element) -> Any) -> Any {
-    values.map(encode)
-  }
-
-  func encode<T>(record fields: [String: T], _ encode: (T) -> Any) -> Any {
-    let encoded = fields.mapValues(encode)
-    return encoded["#"] == nil ? encoded : ["#": "record", "value": encoded]
-  }
-
-  // MARK: Replies
-
-  /// Replies with the JSON `body` returns, or the error it throws.
-  func run(_ body: () throws -> Any?) -> (() -> Void)? {
-    do { send(try body(), done: true) } catch { fail(error) }
-    return nil
-  }
-
-  /// Replies with the JSON `body` resolves to on the main actor, or the
-  /// error it throws. The returned function cancels its task.
-  func task(_ body: @escaping @MainActor () async throws -> Any?) -> () -> Void {
-    let task = Task { @MainActor in
-      do { send(try await body(), done: true) } catch { fail(error) }
-    }
-    return { task.cancel() }
-  }
-
-  /// Replies with each element of the sequence `body` returns on the main
-  /// actor, encoded, then ends. The returned function cancels its task.
-  func stream<S: AsyncSequence>(
-    _ body: @escaping @MainActor () async throws -> S,
-    encode: @escaping (S.Element) -> Any
-  ) -> () -> Void {
-    let task = Task {
-      do {
-        for try await element in try await body() { send(encode(element), done: false) }
-        reply(TokamakPluginResult(payload: Data(), failed: false, done: true))
-      } catch { fail(error) }
-    }
-    return { task.cancel() }
-  }
-
-  /// Keeps `type`'s implementation while the subscription lasts, and replies
-  /// with its ID.
-  func implement(_ type: TokamakBindingImplementation.Type) -> () -> Void {
-    let scope = resources.open()
-    send(resources.retain(type.init(self), in: scope), done: false)
-    return { [resources] in resources.end(scope) }
-  }
-
-  func send(_ value: Any?, done: Bool) {
-    reply(TokamakPluginResult(encodePluginValue(value), done: done))
-  }
-
-  private func fail(_ error: any Error) {
-    reply(TokamakPluginResult(.failure(TokamakPluginError(error)), done: true))
-  }
-
-  /// The field `key` of `value` tagged `tag`.
-  private func tagged(_ value: Any, _ tag: String, key: String = "value") throws -> Any {
-    guard let fields = value as? [String: Any], fields["#"] as? String == tag,
-      let field = fields[key]
-    else { throw typeError("Expected a tagged \(tag)") }
-    return field
-  }
-
-  /// The error of `value`, which is not a `type`.
-  func mismatch(_ value: Any, _ type: Any.Type) -> TokamakPluginError {
-    typeError("\(Swift.type(of: value)) is not \(type)")
-  }
-
-  /// The names of `value`'s class and superclasses, then of the Objective-C
-  /// protocols they adopt, or of its type: Objective-C names, and
-  /// module-qualified Swift names.
-  private func types(of value: Any) -> [String] {
-    let name = { (type: Any.Type) in
-      let name = String(reflecting: type)
-      return name.hasPrefix("__C.") ? String(name.dropFirst(4)) : name
-    }
-    guard let type = Swift.type(of: value) as? AnyClass else {
-      return [name(Swift.type(of: value))]
-    }
-    let classes = Array(sequence(first: type, next: class_getSuperclass))
-    let protocols = classes.flatMap(adopted).map(NSStringFromProtocol)
-    var seen = Set<String>()
-    return (classes.map(name) + protocols).filter { seen.insert($0).inserted }
-  }
-}
-
-/// The Objective-C protocols `type` adopts, each followed by those it inherits.
-private func adopted(by type: AnyClass) -> [Protocol] {
-  protocols { class_copyProtocolList(type, $0) }.flatMap { [$0] + inherited(by: $0) }
-}
-
-private func inherited(by parent: Protocol) -> [Protocol] {
-  protocols { protocol_copyProtocolList(parent, $0) }.flatMap { [$0] + inherited(by: $0) }
-}
-
-/// The protocols a runtime `copy` function lists.
-private func protocols(
-  _ copy: (UnsafeMutablePointer<UInt32>) -> AutoreleasingUnsafeMutablePointer<Protocol>?
-) -> [Protocol] {
-  var count: UInt32 = 0
-  guard let list = copy(&count) else { return [] }
-  defer { free(UnsafeMutableRawPointer(list)) }
-  return (0..<Int(count)).map { list[$0] }
-}
-
-/// A native object that implements a protocol by calling the JavaScript
-/// handlers of an implementation subscription. A method without a handler
-/// keeps the platform's default.
-class TokamakBindingImplementation: NSObject {
-  private let binding: TokamakBinding
-  private let handled: Set<String>
-
-  required init(_ binding: TokamakBinding) {
-    self.binding = binding
-    handled = binding.methods
-  }
-
-  /// The handler each optional Objective-C method calls, by selector.
-  class var selectors: [Selector: String] { [:] }
-
-  override func responds(to selector: Selector!) -> Bool {
-    guard let method = Self.selectors[selector] else { return super.responds(to: selector) }
-    return handled.contains(method)
-  }
-
-  /// Calls the handler `method`, when it has one, with the `arguments` it
-  /// encodes.
-  func call(_ method: String, _ arguments: (TokamakBinding) -> [Any]) {
-    guard handled.contains(method) else { return }
-    binding.send(["method": method, "arguments": arguments(binding)], done: false)
-  }
-}
-
-private func typeError(_ message: String) -> TokamakPluginError {
-  TokamakPluginError(name: "TypeError", message: message)
-}