simtap 0.0.0-stage → 0.6.1

package/vendor/axe/Frameworks/FBControlCore.framework/Versions/A/Headers/FBFutureContextManager.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class FBFuture<T>;
+@class FBFutureContext<T>;
+
+@protocol FBControlCoreLogger;
+@protocol FBFutureContextManagerDelegate;
+
+/**
+ Manages an asynchronous context that can only be used by a single consumer
+ */
+@interface FBFutureContextManager <ContextType : id> : NSObject
+
+#pragma mark Initializers.
+
+/**
+ The Designated Initializer.
+
+ @param queue the queue to use.
+ @param delegate the delegate to use.
+ @param logger the logger to use.
+ @return a new FBFutureContextManager Instance.
+ */
++ (nonnull instancetype)managerWithQueue:(nonnull dispatch_queue_t)queue delegate:(nonnull id<FBFutureContextManagerDelegate>)delegate logger:(nonnull id<FBControlCoreLogger>)logger;
+
+#pragma mark Public Methods.
+
+/**
+ Aquire the Resource.
+
+ @param purpose the purpose for utilization.
+ @return a context that is available at some point in the future.
+ */
+- (nonnull FBFutureContext<ContextType> *)utilizeWithPurpose:(nonnull NSString *)purpose;
+
+/**
+ Synchronously attempt to utilize the context.
+
+ @param purpose the purpose for utilization.
+ @param error an error out for any error that occurs.
+ @return the context if one could be synchronously used.
+ */
+- (nullable ContextType)utilizeNowWithPurpose:(nonnull NSString *)purpose error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Synchronously attempt to return the context.
+
+ @param purpose the purpose for utilization.
+ @param error an error out for any error that occurs.
+ @return the context if one could be synchronously returned.
+ */
+- (BOOL)returnNowWithPurpose:(nonnull NSString *)purpose error:(NSError * _Nullable * _Nullable)error;
+
+@end

package/vendor/axe/Frameworks/FBControlCore.framework/Versions/A/Headers/FBInstalledApplication.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+/**
+ The Installed Type of the Application.
+ */
+typedef NS_ENUM(NSUInteger, FBApplicationInstallType) {
+  FBApplicationInstallTypeUnknown = 0, /** The Application is unknown */
+  FBApplicationInstallTypeSystem = 1, /** The Application is part of the Operating System */
+  FBApplicationInstallTypeMac = 2, /** The Application is part of macOS */
+  FBApplicationInstallTypeUser = 3, /** The Application has been installed by the user */
+  FBApplicationInstallTypeUserEnterprise = 4, /** The Application has been installed by the user and signed with a distribution certificate */
+  FBApplicationInstallTypeUserDevelopment = 5, /** The Application has been installed by the user and signed with a development certificate */
+};
+
+/**
+ Keys from UserInfo about Applications
+ */
+typedef NSString *FBApplicationInstallInfoKey NS_EXTENSIBLE_STRING_ENUM;
+extern FBApplicationInstallInfoKey _Nonnull const FBApplicationInstallInfoKeyApplicationType;
+extern FBApplicationInstallInfoKey _Nonnull const FBApplicationInstallInfoKeyBundleIdentifier;
+extern FBApplicationInstallInfoKey _Nonnull const FBApplicationInstallInfoKeyBundleName;
+extern FBApplicationInstallInfoKey _Nonnull const FBApplicationInstallInfoKeyPath;
+extern FBApplicationInstallInfoKey _Nonnull const FBApplicationInstallInfoKeySignerIdentity;

package/vendor/axe/Frameworks/FBControlCore.framework/Versions/A/Headers/FBInstrumentsCommands.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <FBControlCore/FBFuture.h>
+
+@protocol FBiOSTarget;
+@protocol FBControlCoreLogger;
+
+@class FBInstrumentsConfiguration;
+@class FBInstrumentsOperation;
+
+/**
+ Concrete instruments command implementation, target-bound.
+ */
+// @lint-ignore FBOBJCDEPRECATEDCHECK
+@interface FBInstrumentsCommands : NSObject
+
+@property (nonnull, nonatomic, readonly, strong) id<FBiOSTarget> target;
+
++ (nonnull instancetype)commandsWithTarget:(nonnull id<FBiOSTarget>)target;
+- (nonnull FBFuture<FBInstrumentsOperation *> *)startInstruments:(nonnull FBInstrumentsConfiguration *)configuration logger:(nonnull id<FBControlCoreLogger>)logger;
+
+@end

package/vendor/axe/Frameworks/FBControlCore.framework/Versions/A/Headers/FBInstrumentsOperation.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <FBControlCore/FBSubprocess.h>
+#import <FBControlCore/FBiOSTargetOperation.h>
+
+extern const NSTimeInterval DefaultInstrumentsOperationDuration; // Operation duration
+extern const NSTimeInterval DefaultInstrumentsTerminateTimeout; // When stopping instruments with SIGINT, wait this long before SIGKILLing it
+extern const NSTimeInterval DefaultInstrumentsLaunchRetryTimeout;  // Wait this long to ensure instruments started properly
+extern const NSTimeInterval DefaultInstrumentsLaunchErrorTimeout; // Fail instruments if the launch error message appears within this timeout
+
+@class FBInstrumentsConfiguration;
+
+@protocol FBControlCoreLogger;
+@protocol FBiOSTarget;
+
+/**
+ Represents an operation of the instruments command-line.
+ */
+@interface FBInstrumentsOperation : NSObject
+
+#pragma mark Initializers
+
+/**
+ Constructs an 'instruments' operation, of indefinite length.
+
+ @param target the target to run against.
+ @param configuration the configuration to use.
+ @param logger the logger to log to.
+ @return a running instruments operation.
+ */
++ (nonnull FBFuture<FBInstrumentsOperation *> *)operationWithTarget:(nonnull id<FBiOSTarget>)target configuration:(nonnull FBInstrumentsConfiguration *)configuration logger:(nonnull id<FBControlCoreLogger>)logger;
+
+- (nonnull instancetype)initWithTask:(nonnull FBSubprocess *)task traceFile:(nonnull NSURL *)traceFile configuration:(nonnull FBInstrumentsConfiguration *)configuration queue:(nonnull dispatch_queue_t)queue logger:(nonnull id<FBControlCoreLogger>)logger;
+
+#pragma mark Properties
+
+@property (nonnull, nonatomic, readonly, strong) FBSubprocess *task;
+@property (nonnull, nonatomic, readonly, strong) dispatch_queue_t queue;
+
+/**
+ Trace output file path.
+ */
+@property (nonnull, nonatomic, readonly, copy) NSURL *traceFile;
+
+/**
+ The configuration of the operation.
+ */
+@property (nonnull, nonatomic, readonly, strong) FBInstrumentsConfiguration *configuration;
+
+/**
+ The logger to use.
+ */
+@property (nonnull, nonatomic, readonly, strong) id<FBControlCoreLogger> logger;
+
+#pragma mark Public Methods
+
+/**
+ Stops the Operation.
+ Waits for the trace file to be written out to disk.
+
+ @return a Future that returns the trace file if successful.
+ */
+- (nonnull FBFuture<NSURL *> *)stop;
+
+/**
+ Post-process an instruments trace.
+
+ @param arguments the arguments to post-process with, if relevant.
+ @param traceFile Location of the trace file.
+ @param queue the queue to serialize on.
+ @param logger the logger to log to.
+ @return a delta that post-processes.
+ */
++ (nonnull FBFuture<NSURL *> *)postProcess:(nullable NSArray<NSString *> *)arguments traceFile:(nonnull NSURL *)traceFile queue:(nonnull dispatch_queue_t)queue logger:(nullable id<FBControlCoreLogger>)logger;
+
+@end

package/vendor/axe/Frameworks/FBControlCore.framework/Versions/A/Headers/FBObjCExceptionGuard.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Error domain for NSException -> NSError conversions performed by FBObjCExceptionGuard.
+extern NSString *const FBObjCExceptionGuardErrorDomain;
+
+/// Keys added to the converted NSError's userInfo.
+extern NSString *const FBObjCExceptionGuardExceptionNameKey;
+extern NSString *const FBObjCExceptionGuardExceptionUserInfoKey;
+extern NSString *const FBObjCExceptionGuardCallStackSymbolsKey;
+
+/**
+ Bridges Objective-C `NSException` raises into a form Swift can handle.
+
+ Swift's `do/catch` only handles types conforming to `Swift.Error`. An
+ uncaught `NSException` crossing a Swift frame goes straight to `libc++abi`
+ and terminates the process. Any Swift call site that messages an
+ Objective-C API which may raise (private framework forwarders,
+ `NSProxy`-based remote proxies, anything where the receiver does not
+ strictly implement every selector its declared protocols claim) should
+ funnel the call through this guard.
+
+ The guard wraps a block in `@try`/`@catch (NSException *)`. If the block
+ raises, the exception is converted to an `NSError` in the
+ `FBObjCExceptionGuardErrorDomain`. The error's `localizedDescription`
+ carries the exception's `reason`; the original `name`, `userInfo`, and
+ `callStackSymbols` are preserved under the keys above.
+
+ Only one ObjC entry point is provided. The Swift extension on this class
+ (`FBObjCExceptionGuard.guarded`) wraps it into a generic throwing API
+ that captures the closure's return value via local state. That is the
+ form Swift call sites should normally use.
+ */
+@interface FBObjCExceptionGuard : NSObject
+
+/**
+ Run a block under @try/@catch (NSException *).
+
+ In Swift this is auto-bridged to a throwing form:
+   `try FBObjCExceptionGuard.tryBlock { … }`
+
+ @param block The block to invoke.
+ @param error On failure, populated with an NSError describing the caught NSException.
+ @return YES on success, NO if the block raised an NSException.
+ */
++ (BOOL)tryBlock:(NS_NOESCAPE void (^)(void))block error:(NSError *_Nullable *_Nullable)error
+  NS_SWIFT_NAME(run(_:));
+
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/axe/Frameworks/FBControlCore.framework/Versions/A/Headers/FBProcessBuilder.h

@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <FBControlCore/FBSubprocess.h>
+
+@protocol FBAccumulatingBuffer;
+@protocol FBControlCoreLogger;
+@protocol FBDataConsumer;
+
+@class FBFuture;
+@class FBProcessInput;
+
+/**
+ An interface to building FBProcess instances.
+ */
+@interface FBProcessBuilder <StdInType : id, StdOutType : id, StdErrType : id> : NSObject
+
+#pragma mark Initializers
+
+/**
+ Creates a new Process Builder with the provided launch path.
+ stdin is not not connected.
+ stdout is written to NSData.
+ stderr is written to NSData.
+
+ @param launchPath the launch path to use. Must not be nil.
+ @return a new Process Builder.
+ */
++ (nonnull FBProcessBuilder<NSNull *, NSData *, NSData *> *)withLaunchPath:(nonnull NSString *)launchPath;
+
+/**
+ Creates a new Process Builder with the provided launch path.
+ stdin is not not connected.
+ stdout is written to NSData.
+ stderr is written to NSData.
+
+ @param launchPath the launch path to use. Must not be nil.
+ @param arguments the arguments to launch with.
+ @return a new Process Builder.
+ */
++ (nonnull FBProcessBuilder<NSNull *, NSData *, NSData *> *)withLaunchPath:(nonnull NSString *)launchPath arguments:(nonnull NSArray<NSString *> *)arguments;
+
+#pragma mark Spawn Configuration
+
+/**
+ The Launch Path of the Proces
+
+ @param launchPath the Launch Path. Will remove shellCommand.
+ @return the receiver, for chaining.
+ */
+- (nonnull instancetype)withLaunchPath:(nonnull NSString *)launchPath;
+
+/**
+ The Arguments of the Process..
+
+ @param arguments the arguments for the launch path.
+ @return the receiver, for chaining.
+ */
+- (nonnull instancetype)withArguments:(nonnull NSArray<NSString *> *)arguments;
+
+/**
+ Replaces the environment with the provided environment dictionary.
+
+ @param environment an Environment Dictionary. Must not be nil.
+ @return the receiver, for chaining.
+ */
+- (nonnull instancetype)withEnvironment:(nonnull NSDictionary<NSString *, NSString *> *)environment;
+
+/**
+ Adds the provided dictionary to the environment of the built process.
+
+ @param environment an Environment Dictionary. Must not be nil.
+ @return the receiver, for chaining.
+ */
+- (nonnull instancetype)withEnvironmentAdditions:(nonnull NSDictionary<NSString *, NSString *> *)environment;
+
+#pragma mark stdin
+
+/**
+ Passes an process input to stdin.
+
+ @param input the input to pass
+ @return the reciver, for chaining.
+ */
+- (nonnull FBProcessBuilder<id, StdOutType, StdErrType> *)withStdIn:(nonnull FBProcessInput *)input;
+
+/**
+ Creates a Data Consumer for stdin.
+
+ @return the reciver, for chaining.
+ */
+- (nonnull FBProcessBuilder<id<FBDataConsumer>, StdOutType, StdErrType> *)withStdInConnected;
+
+/**
+ Creates a Data Consumer for stdin.
+
+ @param data the data to send.
+ @return the reciver, for chaining.
+ */
+- (nonnull FBProcessBuilder<NSData *, StdOutType, StdErrType> *)withStdInFromData:(nonnull NSData *)data;
+
+#pragma mark stdout
+
+/**
+ Reads stdout into memory, as a Data.
+
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, NSData *, StdErrType> *)withStdOutInMemoryAsData;
+
+/**
+ Reads stdout into memory, as a String.
+
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, NSString *, StdErrType> *)withStdOutInMemoryAsString;
+
+/**
+ Assigns a path to write stdout to.
+
+ @param stdOutPath the path to write stdout to. Must not be nil.
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, NSString *, StdErrType> *)withStdOutPath:(nonnull NSString *)stdOutPath;
+
+/**
+ Redirects stdout to /dev/null
+
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, NSNull *, StdErrType> *)withStdOutToDevNull;
+
+/**
+ Redirects stdout to an input stream.
+
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, NSInputStream *, StdErrType> *)withStdOutToInputStream;
+
+/**
+ Redirects stdout data to the consumer.
+
+ @param consumer the consumer to consume the data.
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, id<FBDataConsumer>, StdErrType> *)withStdOutConsumer:(nonnull id<FBDataConsumer>)consumer;
+
+/**
+ Redirects stdout to the reader block, on a per line basis.
+
+ @param reader the block to use for reading lines
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, id<FBDataConsumer>, StdErrType> *)withStdOutLineReader:(nonnull void (^)(NSString * _Nonnull))reader;
+
+/**
+ Redirects stdout to the provided logger, on a per line basis.
+
+ @param logger the logger to use for logging lines.
+ @return the reciver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, id<FBControlCoreLogger>, StdErrType> *)withStdOutToLogger:(nonnull id<FBControlCoreLogger>)logger;
+
+/**
+ Redirects stdout to the provided logger and prints the output in any error message that occurs.
+
+ @param logger the logger to use for logging lines.
+ @return the reciver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, id<FBAccumulatingBuffer>, StdErrType> *)withStdOutToLoggerAndErrorMessage:(nonnull id<FBControlCoreLogger>)logger;
+
+#pragma mark stderr
+
+/**
+ Reads stderr into memory, as a Data.
+
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, StdInType, NSData *> *)withStdErrInMemoryAsData;
+
+/**
+ Reads stderr into memory, as a String.
+
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, StdOutType, NSString *> *)withStdErrInMemoryAsString;
+
+/**
+ Assigns a path to write stderr to.
+
+ @param stdErrPath the path to write stderr to. Must not be nil.
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, StdOutType, NSString *> *)withStdErrPath:(nonnull NSString *)stdErrPath;
+
+/**
+ Redirects stderr to /dev/null
+
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, StdOutType, NSNull *> *)withStdErrToDevNull;
+
+/**
+ Redirects stderr data to the consumer.
+
+ @param consumer the consumer to consume the data.
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, StdOutType, id<FBDataConsumer>> *)withStdErrConsumer:(nonnull id<FBDataConsumer>)consumer;
+
+/**
+ Redirects stderr to the reader block, on a per line basis.
+
+ @param reader the block to use for reading lines
+ @return the receiver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, StdOutType, id<FBDataConsumer>> *)withStdErrLineReader:(nonnull void (^)(NSString * _Nonnull))reader;
+
+/**
+ Redirects stderr to the provided logger, on a per line basis.
+
+ @param logger the logger to use for logging lines.
+ @return the reciver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, StdOutType, id<FBControlCoreLogger>> *)withStdErrToLogger:(nonnull id<FBControlCoreLogger>)logger;
+
+/**
+ Redirects stderr to the provided logger and prints the output in any error message that occurs.
+
+ @param logger the logger to use for logging lines.
+ @return the reciver, for chaining.
+ */
+- (nonnull FBProcessBuilder<StdInType, StdOutType, id<FBAccumulatingBuffer>> *)withStdErrToLoggerAndErrorMessage:(nonnull id<FBControlCoreLogger>)logger;
+
+#pragma mark Logging
+
+/**
+ Enables logging of the process lifecycle to the provided logger.
+ By default the task will be constructed without this logging.
+ To get detailed information, pass a logger to this method.
+ Logging can be disabled by passing nil.
+
+ @param logger the logger to log to. Nil may be passed to disable task lifecycle logging, which is the default.
+ @return the receiver for chaining.
+ */
+- (nonnull instancetype)withTaskLifecycleLoggingTo:(nullable id<FBControlCoreLogger>)logger;
+
+#pragma mark Building
+
+/**
+ Builds and starts the process.
+
+ @return A future that resolves with the started process..
+ */
+- (nonnull FBFuture<FBSubprocess<StdInType, StdOutType, StdErrType> *> *)start;
+
+/**
+ Builds and starts the process, then waits for it to complete with the provided exit codes.
+ The future will resolve when the process has finished executing.
+ Cancelling the process will cancel the task.
+
+ @return a Future, encapsulating the process on completion.
+ */
+- (nonnull FBFuture<FBSubprocess<StdInType, StdOutType, StdErrType> *> *)runUntilCompletionWithAcceptableExitCodes:(nullable NSSet<NSNumber *> *)exitCodes;
+
+@end

package/vendor/axe/Frameworks/FBControlCore.framework/Versions/A/Headers/FBProcessFetcher.h

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <sys/sysctl.h>
+
+#import <Foundation/Foundation.h>
+
+@class FBProcessInfo;
+
+@class FBFuture<T>;
+
+/**
+ Queries for Processes running on the Host.
+ Should not be called from multiple threads since buffers are re-used internally.
+
+ Sharing a Query object and guaranteeing serialization of method calls
+ can be an effective way to reduce the number of allocations that are required.
+ */
+@interface FBProcessFetcher : NSObject
+
+/**
+ A Query for obtaining all of the process information for a given processIdentifier.
+
+ @param processIdentifier the Process Identifier to obtain process info for.
+ @return an FBProcessInfo object if a process with the given identifier could be found, nil otherwise.
+ */
+- (nullable FBProcessInfo *)processInfoFor:(pid_t)processIdentifier;
+
+/**
+ Obtain process info for child processes.
+
+ @param parent the Process Identifier to obtain the subprocesses of
+ @return an NSArray<FBProcessInfo> of the parent's child processes.
+ */
+- (nonnull NSArray<FBProcessInfo *> *)subprocessesOf:(pid_t)parent;
+
+/**
+ A Query for returning the processes with a given name.
+
+ @param processName the name of the processes to fetch.
+ @return an NSArray<FBProcessInfo> of the found processes.
+ */
+- (nonnull NSArray<FBProcessInfo *> *)processesWithProcessName:(nonnull NSString *)processName;
+
+/**
+ A Query for returning the first named child process of the provided parent.
+
+ @param parent the Process Identifier of the parent process.
+ @param name the name of the child process.
+ @return a Process Identifier of the child process if one could be found, -1 otherwise.
+ */
+- (pid_t)subprocessOf:(pid_t)parent withName:(nonnull NSString *)name;
+
+/**
+ A Query for returning the parent of the provided child process
+
+ @param child the Process Identifier of the child process.
+ @return a Process Identifier of the parent process if one could be found, -1 otherwise.
+ */
+- (pid_t)parentOf:(pid_t)child;
+
+/**
+ A Query for returning the process identifier of the first found process with an open file of filename.
+ This is a operation is generally more expensive than the others.
+
+ @param filePath the path to the file.
+ @return a Process Identifier for the first process with an open file to the path, -1 otherwise.
+ */
+- (pid_t)processWithOpenFileTo:(nonnull const char *)filePath;
+
+/**
+ Verify if process is running
+
+ @param processIdentifier process to check.
+ @param error an error out for any error that occurs.
+ @return YES if process is Runnig and error is NOT set. False if process isn't running or error is set.
+ */
+- (BOOL)isProcessRunning:(pid_t)processIdentifier error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Verify if process is stopped
+
+ @param processIdentifier process to check.
+ @param error an error out for any error that occurs.
+ @return YES if process is Stopped and error is NOT set. False if process isn't stopped or error is set.
+ */
+- (BOOL)isProcessStopped:(pid_t)processIdentifier error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Verify if process has a debugger attached to it.
+
+ @param processIdentifier process to check.
+ @param error an error out for any error that occurs.
+ @return YES if process is has a debugger attached and error is NOT set.. False if process doesn't have a debugger attached  or error is set.
+ */
+- (BOOL)isDebuggerAttachedTo:(pid_t)processIdentifier error:(NSError * _Nullable * _Nullable)error;
+
+/**
+ Wait for a debugger to attach to the process and the process to be up running again.
+
+ @param processIdentifier the Process Identifier of the process.
+ @return A future waitting for the debugger and process up running again.
+ */
++ (nonnull FBFuture<NSNull *> *)waitForDebuggerToAttachAndContinueFor:(pid_t)processIdentifier;
+
+/**
+ Wait for process to receive SIGSTOP.
+
+ @param processIdentifier the Process Identifier of the process.
+ @return A future waitting for the process to be in SSTOP state.
+ */
++ (nonnull FBFuture<NSNull *> *)waitStopSignalForProcess:(pid_t)processIdentifier;
+
+/**
+ Performs a stackshot on the provided process id.
+ Does not terminate the process after performing the stackshot.
+ Returns a future to a string containing the stackshot.
+
+ @param processIdentifier the process identifier of the process to stackshot.
+ @param queue the queue to use.
+*/
++ (nonnull FBFuture<id> *)performSampleStackshotForProcessIdentifier:(pid_t)processIdentifier queue:(nonnull dispatch_queue_t)queue;
+
+@end