I have domain concept of `Product`.

`Product` have some `GeneralDetails`, lets say: `sku, name, description`.
At the same time, `Product` have some `ProductCalculations` part where accountants can put different values like `purchasePrice, stockLevelExpenses, wholeSalesPrice, retailPrice`.

So, so far, `Product` would look something like:

```
class Product{
   GeneralDetails Details;
   ProductCalculations Calculations;

   ChangeDetails(GeneralDetails details){}
   Recalculate(ProductCalculations calculations{}

}

```

This setup would make `Product` an aggregate root. But now, i want to split it in a way that Product manager can input/update product details but then that accountant can step in and intependently change calculations for given product without concurrency issues.
That would suggest splitting it into 2 separate aggregate roots.

But then, deleting `ProductDetails` aggregate must mean deleting `ProductCalculations` too and it should happen in transactional way.

Assuming they are 2 aggregate roots, meaning they have 2 separate repositories with corresponding `Delete` methods, how to implement this as an atomic transaction?

The only thing i can think about is to raise event when `ProductDetails` gets deleted, have a handler (`DomainService`) that uses some special repository that handles transactions over multiple aggregate roots.

Is there some problem with that approach and/or is there some better way to handle it?

PS.
I cannot allow eventual consistency when `ProductDetails` is deleted.

PS2.
Based on comments from @Jon, `Details` and `Calculations` create&delete should be synced in a way that when `Details` are created/deleted, `Calculations` should also be created/deleted.
On the other hand, their updates should be completely independent.