anchor.diff:  /// when sent.
   abstract class SendPort implements Capability {
     /// Sends an asynchronous [message] through this send port, to its
  -  /// corresponding `ReceivePort`.
  -  ///
  -  /// The content of [message] can be:
  +  /// corresponding [ReceivePort].
  +  ///
  +  /// The transitive object graph of [message] can contain the following
  +  /// objects:
     ///   - [Null]
     ///   - [bool]
     ///   - [int]
  
positive.code:   /// This operation is potentially dangerous and should be used judiciously.
    /// The isolate stops operating *immediately*. It throws if the optional
    /// [message] does not adhere to the limitations on what can be sent from one
    /// isolate to another. It also throws if a [finalMessagePort] is associated
    /// with an isolate spawned outside of current isolate group, spawned via
    /// [spawnUri].
    ///
    /// If successful, a call to this method does not return. Pending `finally`
    /// blocks are not executed, control flow will not go back to the event loop,
  
negative.code:   ///   - [SendPort]
    ///   - [Capability]
    ///
    /// If the sender and receiver isolate share the same code (e.g. isolates
    /// created via [Isolate.spawn]), the transitive object graph of [message] can
    /// contain any object, with the following exceptions:
    ///
    ///   - Objects with native resources (subclasses of e.g.
    ///     `NativeFieldWrapperClass1`). A [Socket] object for example referrs
    ///     internally to objects that have native resources attached and can
    ///     therefore not be sent.
    ///   - [ReceivePort]
    ///   - [DynamicLibrary]
    ///   - [Pointer]
    ///   - [UserTag]
    ///   - `MirrorReference`
    ///
    /// Apart from those exceptions any object can be sent. Objects that are
    /// identified as immutable (e.g. strings) will be shared whereas all other
    /// objects will be copied.
    ///
    /// The send happens immediately and may have a linear time cost to copy the
    /// transtive object graph. The send itself doesn't block (i.e. doesn't wait
    /// until the receiver has received the message). The corresponding receive
    /// port can receive the message as soon as its isolate's event loop is ready
    /// to deliver it, independently of what the sending isolate is doing.
    ///
    /// Note: Due to an implementation choice the Dart VM made for how closures
    /// represent captured state, closures can currently capture more state than
    /// they need, which can cause the transitive closure to be larger than
    /// needed. Open bug to address this: http://dartbug.com/36983
    void send(Object? message);
  
    /// Tests whether [other] is a [SendPort] pointing to the same
  