@appium/coresim 1.0.0

package/src/native/sim_device.h

@@ -0,0 +1,143 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+namespace coresim {
+
+// -[SimDevice UDID] / -[SimDevice name] / -[SimDevice state] / -[SimDevice deviceType] /
+// -[SimDevice runtime]. `state` is the raw SimDeviceState enum value (0=Creating, 1=Shutdown,
+// 2=Booting, 3=Booted, 4=ShuttingDown).
+NSUUID* DeviceUDID(id device);
+NSString* DeviceName(id device);
+unsigned long long DeviceState(id device);
+id DeviceDeviceType(id device);
+id DeviceRuntime(id device);
+
+// -[SimDevice dataPath] -> the device's `data` directory
+// (~/Library/Developer/CoreSimulator/Devices/<udid>/data), the root of everything the guest OS
+// considers its own filesystem (app containers, Library, etc.) — used to locate TCC.db for
+// privacy-permission access (see tcc_privacy.h).
+NSString* DeviceDataPath(id device);
+
+// -[SimDevice bootWithOptions:error:]
+BOOL Boot(id device, NSDictionary* options, NSError** error);
+
+// -[SimDevice bootAsyncWithOptions:completionQueue:completionHandler:]. `handler` runs on `queue`
+// exactly once with the resulting NSError (nil on success) — this is what replaces the CLI's
+// bootstatus poll-until-timeout race.
+void BootAsync(id device, NSDictionary* options, dispatch_queue_t queue, void (^handler)(NSError*));
+
+// -[SimDevice bootStatus] -> SimDeviceBootInfo* describing the most recent boot attempt's
+// progress, or nil if the device has never been booted. This is the same underlying mechanism
+// `simctl bootstatus` itself uses — a separate, far more granular signal than SimDeviceState,
+// tracking post-boot data migration and system-app readiness that `state` knows nothing about
+// (see CLAUDE.md).
+//
+// Confirmed empirically NOT reset on shutdown: after `shutdownWithError:`, this still returns the
+// *previous* boot session's terminal SimDeviceBootInfo rather than nil — callers must also check
+// SimDevice.state to tell "genuinely mid-boot" from "shut down, remembering an old boot".
+id DeviceBootStatus(id device);
+
+// -[SimDeviceBootInfo status] -> raw status code. Confirmed values (see CLAUDE.md): 0 = Booting,
+// 2 = WaitingOnDataMigration, 4 = WaitingOnSystemApp, 0xFFFFFFFF = Finished (the only terminal
+// value observed). `simctl bootstatus`'s own output also names a WaitingOnBackboard phase whose
+// numeric value wasn't observed in testing (not every boot passes through it) — treat any value other than
+// the four confirmed above as "not yet terminal, keep waiting" rather than an error.
+unsigned int BootInfoStatus(id bootInfo);
+
+// -[SimDeviceBootInfo isTerminalStatus] -> whether this boot attempt has fully settled. Confirmed
+// empirically to stay YES after shutdown, reflecting the previous session — see DeviceBootStatus.
+BOOL BootInfoIsTerminal(id bootInfo);
+
+// -[SimDevice shutdownWithError:]
+BOOL Shutdown(id device, NSError** error);
+
+// -[SimDevice eraseContentsAndSettingsWithError:]
+BOOL Erase(id device, NSError** error);
+
+// -[SimDevice getenv:error:]
+NSString* Getenv(id device, NSString* name, NSError** error);
+
+// -[SimDevice lookup:error:] -> a Mach port (0/MACH_PORT_NULL on failure), resolved within the
+// device's own launchd_sim bootstrap namespace by name. Confirmed empirically (see CLAUDE.md) to
+// need no special entitlement — used to reach the pasteboard sync service (sim_pasteboard.h),
+// the same way Apple's own Simulator.app does.
+unsigned int LookupMachPort(id device, NSString* serviceName, NSError** error);
+
+// -[SimDevice installApplication:withOptions:error:]
+BOOL InstallApp(id device, NSURL* appURL, NSDictionary* options, NSError** error);
+
+// -[SimDevice uninstallApplication:withOptions:error:]
+BOOL UninstallApp(id device, NSString* bundleID, NSDictionary* options, NSError** error);
+
+// -[SimDevice launchApplicationWithID:options:error:]. Returns the launched pid.
+int LaunchApp(id device, NSString* bundleID, NSDictionary* options, NSError** error);
+
+// -[SimDevice terminateApplicationWithID:error:]
+BOOL TerminateApp(id device, NSString* bundleID, NSError** error);
+
+// -[SimDevice propertiesOfApplication:error:]
+NSDictionary* PropertiesOfApplication(id device, NSString* bundleID, NSError** error);
+
+// -[SimDevice installedAppsWithError:]
+NSDictionary* InstalledApps(id device, NSError** error);
+
+// -[SimDevice openURL:error:]
+BOOL OpenURL(id device, NSURL* url, NSError** error);
+
+// -[SimDevice(SimLocation) setLocationWithLatitude:andLongitude:error:]
+BOOL SetLocation(id device, double latitude, double longitude, NSError** error);
+
+// -[SimDevice(SimLocation) clearSimulatedLocationWithError:]
+BOOL ClearLocation(id device, NSError** error);
+
+// -[SimDevice(SimPushNotification) sendPushNotificationForBundleID:jsonPayload:error:] — despite
+// the selector's "json" naming, the real parameter type is NSDictionary*, not NSData* (confirmed
+// empirically: ObjC type encoding can't distinguish object *classes*, only that a parameter is
+// some object pointer, so the original signature recovery guessed wrong; passing NSData crashes
+// with "-[NSConcreteData objectForKeyedSubscript:]: unrecognized selector" regardless of whether
+// the NSData holds JSON text or a serialized plist — see CLAUDE.md).
+BOOL SendPushNotification(id device, NSString* bundleID, NSDictionary* payload, NSError** error);
+
+// -[SimDevice(SimDeviceKeychain) addCertificateAtURL:trustAsRoot:error:]
+BOOL AddCertificate(id device, NSURL* certURL, BOOL trustAsRoot, NSError** error);
+
+// -[SimDevice(SimDeviceKeychain) resetKeychainWithError:]
+BOOL ResetKeychain(id device, NSError** error);
+
+// -[SimDevice(SimUIInterfaceStyle) currentUIInterfaceStyle] / setUIInterfaceStyle:error:
+long long CurrentUIInterfaceStyle(id device);
+BOOL SetUIInterfaceStyle(id device, long long style, NSError** error);
+
+// -[SimDevice(Accessibility) currentIncreaseContrastMode] / setIncreaseContrastEnabled:error:
+long long CurrentIncreaseContrastMode(id device);
+BOOL SetIncreaseContrastEnabled(id device, BOOL enabled, NSError** error);
+
+// -[SimDevice(Accessibility) currentContentSizeCategory] / setContentSizeCategory:error:
+long long CurrentContentSizeCategory(id device);
+BOOL SetContentSizeCategory(id device, long long category, NSError** error);
+
+// -[SimDevice darwinNotificationGetState:name:error:]
+BOOL DarwinNotificationGetState(id device, unsigned long long* outState, NSString* name, NSError** error);
+
+// -[SimDevice darwinNotificationSetState:name:error:]
+BOOL DarwinNotificationSetState(id device, unsigned long long state, NSString* name, NSError** error);
+
+// -[SimDevice postDarwinNotification:error:]
+BOOL PostDarwinNotification(id device, NSString* name, NSError** error);
+
+// -[SimDevice spawnWithPath:options:terminationQueue:terminationHandler:error:]. Returns the
+// spawned pid; `terminationHandler` runs on `terminationQueue` once with the exit status.
+int Spawn(id device, NSString* path, NSDictionary* options, dispatch_queue_t terminationQueue,
+          void (^terminationHandler)(int), NSError** error);
+
+// -[SimDevice addMedia:error:] — takes an array of file URLs (photos/videos), auto-detected by
+// type; this is what `simctl addmedia`'s multi-path form calls into.
+BOOL AddMedia(id device, NSArray<NSURL*>* fileURLs, NSError** error);
+
+// -[SimDevice addPhoto:error:] / -[SimDevice addVideo:error:] — single-file convenience variants
+// alongside AddMedia, for a caller that already knows which kind it's adding.
+BOOL AddPhoto(id device, NSURL* fileURL, NSError** error);
+BOOL AddVideo(id device, NSURL* fileURL, NSError** error);
+
+}  // namespace coresim

package/src/native/sim_device.mm

@@ -0,0 +1,355 @@
+#include "sim_device.h"
+
+#import <objc/message.h>
+
+#include "objc_runtime.h"
+#include "safe_dispatch.h"
+
+namespace coresim {
+
+namespace {
+
+// Shared shapes reused across the many identical-signature getters/setters below.
+id IdGetter(id target, const std::string& selectorName) {
+  RequireSelector(target, selectorName);
+  SEL selector = SelectorNamed(selectorName);
+  return SafeInvoke([&] {
+    using Fn = id (*)(id, SEL);
+    return ((Fn)objc_msgSend)(target, selector);
+  });
+}
+
+BOOL BoolWithError(id target, const std::string& selectorName, NSError** error) {
+  RequireSelector(target, selectorName);
+  SEL selector = SelectorNamed(selectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSError**);
+    return ((Fn)objc_msgSend)(target, selector, error);
+  });
+}
+
+BOOL BoolGetter(id target, const std::string& selectorName) {
+  RequireSelector(target, selectorName);
+  SEL selector = SelectorNamed(selectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL);
+    return ((Fn)objc_msgSend)(target, selector);
+  });
+}
+
+unsigned int UIntGetter(id target, const std::string& selectorName) {
+  RequireSelector(target, selectorName);
+  SEL selector = SelectorNamed(selectorName);
+  return SafeInvoke([&] {
+    using Fn = unsigned int (*)(id, SEL);
+    return ((Fn)objc_msgSend)(target, selector);
+  });
+}
+
+}  // namespace
+
+NSUUID* DeviceUDID(id device) { return IdGetter(device, "UDID"); }
+NSString* DeviceName(id device) { return IdGetter(device, "name"); }
+id DeviceDeviceType(id device) { return IdGetter(device, "deviceType"); }
+id DeviceRuntime(id device) { return IdGetter(device, "runtime"); }
+NSString* DeviceDataPath(id device) { return IdGetter(device, "dataPath"); }
+
+unsigned long long DeviceState(id device) {
+  static const std::string kSelectorName = "state";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = unsigned long long (*)(id, SEL);
+    return ((Fn)objc_msgSend)(device, selector);
+  });
+}
+
+BOOL Boot(id device, NSDictionary* options, NSError** error) {
+  static const std::string kSelectorName = "bootWithOptions:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSDictionary*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, options, error);
+  });
+}
+
+void BootAsync(id device, NSDictionary* options, dispatch_queue_t queue, void (^handler)(NSError*)) {
+  static const std::string kSelectorName = "bootAsyncWithOptions:completionQueue:completionHandler:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  SafeInvoke([&] {
+    using Fn = void (*)(id, SEL, NSDictionary*, dispatch_queue_t, void (^)(NSError*));
+    ((Fn)objc_msgSend)(device, selector, options, queue, handler);
+    return true;
+  });
+}
+
+id DeviceBootStatus(id device) { return IdGetter(device, "bootStatus"); }
+
+unsigned int BootInfoStatus(id bootInfo) { return UIntGetter(bootInfo, "status"); }
+
+BOOL BootInfoIsTerminal(id bootInfo) { return BoolGetter(bootInfo, "isTerminalStatus"); }
+
+BOOL Shutdown(id device, NSError** error) { return BoolWithError(device, "shutdownWithError:", error); }
+
+BOOL Erase(id device, NSError** error) { return BoolWithError(device, "eraseContentsAndSettingsWithError:", error); }
+
+NSString* Getenv(id device, NSString* name, NSError** error) {
+  static const std::string kSelectorName = "getenv:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = NSString* (*)(id, SEL, NSString*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, name, error);
+  });
+}
+
+unsigned int LookupMachPort(id device, NSString* serviceName, NSError** error) {
+  static const std::string kSelectorName = "lookup:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = unsigned int (*)(id, SEL, NSString*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, serviceName, error);
+  });
+}
+
+BOOL InstallApp(id device, NSURL* appURL, NSDictionary* options, NSError** error) {
+  static const std::string kSelectorName = "installApplication:withOptions:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSURL*, NSDictionary*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, appURL, options, error);
+  });
+}
+
+BOOL UninstallApp(id device, NSString* bundleID, NSDictionary* options, NSError** error) {
+  static const std::string kSelectorName = "uninstallApplication:withOptions:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSString*, NSDictionary*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, bundleID, options, error);
+  });
+}
+
+int LaunchApp(id device, NSString* bundleID, NSDictionary* options, NSError** error) {
+  static const std::string kSelectorName = "launchApplicationWithID:options:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = int (*)(id, SEL, NSString*, NSDictionary*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, bundleID, options, error);
+  });
+}
+
+BOOL TerminateApp(id device, NSString* bundleID, NSError** error) {
+  static const std::string kSelectorName = "terminateApplicationWithID:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSString*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, bundleID, error);
+  });
+}
+
+NSDictionary* PropertiesOfApplication(id device, NSString* bundleID, NSError** error) {
+  static const std::string kSelectorName = "propertiesOfApplication:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = NSDictionary* (*)(id, SEL, NSString*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, bundleID, error);
+  });
+}
+
+NSDictionary* InstalledApps(id device, NSError** error) {
+  static const std::string kSelectorName = "installedAppsWithError:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = NSDictionary* (*)(id, SEL, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, error);
+  });
+}
+
+BOOL OpenURL(id device, NSURL* url, NSError** error) {
+  static const std::string kSelectorName = "openURL:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSURL*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, url, error);
+  });
+}
+
+BOOL SetLocation(id device, double latitude, double longitude, NSError** error) {
+  static const std::string kSelectorName = "setLocationWithLatitude:andLongitude:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, double, double, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, latitude, longitude, error);
+  });
+}
+
+BOOL ClearLocation(id device, NSError** error) {
+  return BoolWithError(device, "clearSimulatedLocationWithError:", error);
+}
+
+BOOL SendPushNotification(id device, NSString* bundleID, NSDictionary* payload, NSError** error) {
+  static const std::string kSelectorName = "sendPushNotificationForBundleID:jsonPayload:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSString*, NSDictionary*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, bundleID, payload, error);
+  });
+}
+
+BOOL AddCertificate(id device, NSURL* certURL, BOOL trustAsRoot, NSError** error) {
+  static const std::string kSelectorName = "addCertificateAtURL:trustAsRoot:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSURL*, BOOL, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, certURL, trustAsRoot, error);
+  });
+}
+
+BOOL ResetKeychain(id device, NSError** error) { return BoolWithError(device, "resetKeychainWithError:", error); }
+
+long long CurrentUIInterfaceStyle(id device) {
+  static const std::string kSelectorName = "currentUIInterfaceStyle";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = long long (*)(id, SEL);
+    return ((Fn)objc_msgSend)(device, selector);
+  });
+}
+
+BOOL SetUIInterfaceStyle(id device, long long style, NSError** error) {
+  static const std::string kSelectorName = "setUIInterfaceStyle:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, long long, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, style, error);
+  });
+}
+
+long long CurrentIncreaseContrastMode(id device) {
+  static const std::string kSelectorName = "currentIncreaseContrastMode";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = long long (*)(id, SEL);
+    return ((Fn)objc_msgSend)(device, selector);
+  });
+}
+
+BOOL SetIncreaseContrastEnabled(id device, BOOL enabled, NSError** error) {
+  static const std::string kSelectorName = "setIncreaseContrastEnabled:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, BOOL, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, enabled, error);
+  });
+}
+
+long long CurrentContentSizeCategory(id device) {
+  static const std::string kSelectorName = "currentContentSizeCategory";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = long long (*)(id, SEL);
+    return ((Fn)objc_msgSend)(device, selector);
+  });
+}
+
+BOOL SetContentSizeCategory(id device, long long category, NSError** error) {
+  static const std::string kSelectorName = "setContentSizeCategory:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, long long, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, category, error);
+  });
+}
+
+BOOL DarwinNotificationGetState(id device, unsigned long long* outState, NSString* name, NSError** error) {
+  static const std::string kSelectorName = "darwinNotificationGetState:name:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, unsigned long long*, NSString*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, outState, name, error);
+  });
+}
+
+BOOL DarwinNotificationSetState(id device, unsigned long long state, NSString* name, NSError** error) {
+  static const std::string kSelectorName = "darwinNotificationSetState:name:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, unsigned long long, NSString*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, state, name, error);
+  });
+}
+
+BOOL PostDarwinNotification(id device, NSString* name, NSError** error) {
+  static const std::string kSelectorName = "postDarwinNotification:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSString*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, name, error);
+  });
+}
+
+int Spawn(id device, NSString* path, NSDictionary* options, dispatch_queue_t terminationQueue,
+          void (^terminationHandler)(int), NSError** error) {
+  static const std::string kSelectorName = "spawnWithPath:options:terminationQueue:terminationHandler:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = int (*)(id, SEL, NSString*, NSDictionary*, dispatch_queue_t, void (^)(int), NSError**);
+    return ((Fn)objc_msgSend)(device, selector, path, options, terminationQueue, terminationHandler, error);
+  });
+}
+
+BOOL AddMedia(id device, NSArray<NSURL*>* fileURLs, NSError** error) {
+  static const std::string kSelectorName = "addMedia:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSArray<NSURL*>*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, fileURLs, error);
+  });
+}
+
+BOOL AddPhoto(id device, NSURL* fileURL, NSError** error) {
+  static const std::string kSelectorName = "addPhoto:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSURL*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, fileURL, error);
+  });
+}
+
+BOOL AddVideo(id device, NSURL* fileURL, NSError** error) {
+  static const std::string kSelectorName = "addVideo:error:";
+  RequireSelector(device, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, NSURL*, NSError**);
+    return ((Fn)objc_msgSend)(device, selector, fileURL, error);
+  });
+}
+
+}  // namespace coresim

package/src/native/sim_device_set.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+namespace coresim {
+
+// -[SimDeviceSet devices] -> NSArray<SimDevice*>
+NSArray* Devices(id deviceSet);
+
+// -[SimDeviceSet createDeviceWithType:runtime:name:error:]
+id CreateDevice(id deviceSet, id deviceType, id runtime, NSString* name, NSError** error);
+
+// -[SimDeviceSet deleteDevice:error:]
+BOOL DeleteDevice(id deviceSet, id device, NSError** error);
+
+}  // namespace coresim

package/src/native/sim_device_set.mm

@@ -0,0 +1,40 @@
+#include "sim_device_set.h"
+
+#import <objc/message.h>
+
+#include "objc_runtime.h"
+#include "safe_dispatch.h"
+
+namespace coresim {
+
+NSArray* Devices(id deviceSet) {
+  static const std::string kSelectorName = "devices";
+  RequireSelector(deviceSet, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = NSArray* (*)(id, SEL);
+    return ((Fn)objc_msgSend)(deviceSet, selector);
+  });
+}
+
+id CreateDevice(id deviceSet, id deviceType, id runtime, NSString* name, NSError** error) {
+  static const std::string kSelectorName = "createDeviceWithType:runtime:name:error:";
+  RequireSelector(deviceSet, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = id (*)(id, SEL, id, id, NSString*, NSError**);
+    return ((Fn)objc_msgSend)(deviceSet, selector, deviceType, runtime, name, error);
+  });
+}
+
+BOOL DeleteDevice(id deviceSet, id device, NSError** error) {
+  static const std::string kSelectorName = "deleteDevice:error:";
+  RequireSelector(deviceSet, kSelectorName);
+  SEL selector = SelectorNamed(kSelectorName);
+  return SafeInvoke([&] {
+    using Fn = BOOL (*)(id, SEL, id, NSError**);
+    return ((Fn)objc_msgSend)(deviceSet, selector, device, error);
+  });
+}
+
+}  // namespace coresim

package/src/native/sim_pasteboard.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+namespace coresim {
+
+// Reads the device's current pasteboard content, picking between two private mechanisms at
+// runtime depending on which one's classes actually exist (see sim_pasteboard.mm). Throws
+// NativeSimUnavailableError if neither is present. Returns "" (not nil) for an empty pasteboard,
+// matching `simctl pbpaste`.
+NSString* PullPasteboardString(id device, NSError** error);
+
+// Writes `content` as the device's pasteboard content, via the same mechanism selection.
+BOOL PushPasteboardString(id device, NSString* content, NSError** error);
+
+}  // namespace coresim