 
 distributed actor Throwy {
   init(system: FakeActorSystem, doThrow: Bool) throws {
+    self.actorSystem = system
     if doThrow {
       throw MyError.test
     }

}

distributed actor PickATransport1 {
  init(kappa system: FakeActorSystem, other: Int) {}
}

distributed actor PickATransport2 {
  init(other: Int, thesystem: FakeActorSystem) async {}
}

distributed actor LocalWorker {
  init(system: FakeActorSystem) {}
}

distributed actor Bug_CallsReadyTwice {
  var x: Int
  init(system: FakeActorSystem, wantBug: Bool) async {
    if wantBug {
      self.x = 1
    }

  func remoteCall<Act, Err, Res>(
      on actor: Act,
      target: RemoteCallTarget,
      invocation: inout InvocationEncoder,
      throwing: Err.Type,
      returning: Res.Type
  ) async throws -> Res
    where Act: DistributedActor,
          Act.ID == ActorID,
          Err: Error,
          Res: SerializationRequirement {
    throw ExecuteDistributedTargetError(message: "Not implemented")
  }

  func remoteCallVoid<Act, Err>(
      on actor: Act,
      target: RemoteCallTarget,
      invocation: inout InvocationEncoder,
      throwing: Err.Type
  ) async throws
    where Act: DistributedActor,
          Act.ID == ActorID,
          Err: Error {
    throw ExecuteDistributedTargetError(message: "Not implemented")
  }

