How to consume parent machine's actor from child?

[alita-moore]

I would like to use the parent of a child machine's actor from the child. See a rough example below:

const someOtherMachine = setup({
  types: {} as {
    events: { type: "example" };
  }
}).createMachine({
  id: "someOtherMachine",
  initial: "Idle",
  states: {
    Idle: {
      invoke: {
        src: "#someMachine.example",
        onDone: "Done"
      }
    },
    Done: {
      type: "final"
    }
  }
});

export const someMachine = setup({
  types: {} as {
    context: {
      volume: number;
    };
    events: { type: "setVolume"; volume: number };
  },
  actors: {
    otherMachine: someOtherMachine,
    example: fromCallback(() => console.log("example"))
  }
}).createMachine({
  id: "someMachine",
  context: initialContext,
  initial: "Idle",
  states: {
    Idle: {
      on: {
        setVolume: {
          target: "SetVolume",
          actions: () => console.log(1)
        },
        
      }
    },
    SetVolume: {
      invoke: {
        src: "otherMachine",
        onDone: "Idle"
      }
    }
  }
});

note that this does not work.

This would be useful because I want to call an actor with some stateful side-effect in react. The alternative is that I pass the "otherMachine" as an actor instance when instantiating the "someMachine" in react. I.e. something along the lines of:

const SomeComponent = () => {
  ... machine.provide({
    otherMachine: otherMachine.provide({
      example: () => console.log("example")
    })
  })
}

vs. what I want to do which is

const SomeComponent = () => {
  ... machine.provide({
    example: () => console.log("example")
  })
}

Edit:
I'm realizing now that it appears that if you pass in the actor after providing the actor to the machine, it will generate a new actor. i.e.

import { setup, fromPromise } from "xstate";

const initialContext = {
  volume: 50,
};

const someOtherMachine = setup({
  actors: {} as {
    example: ReturnType<typeof fromPromise>;
  },
}).createMachine({
  id: "someOtherMachine",
  initial: "Idle",
  states: {
    Idle: {
      invoke: {
        src: "example",
        onDone: "Done",
      },
    },
    Done: {
      entry: () => console.log("Done"),
      type: "final",
    },
  },
});

const actor = someOtherMachine.provide({
  actors: {
    example: fromPromise(async () => console.log("example")),
  },
});

export const someMachine = setup({
  types: {} as {
    context: {
      volume: number;
    };
    events: { type: "setVolume"; volume: number };
  },
  actors: {
    otherMachine: actor,
  },
}).createMachine({
  id: "someMachine",
  context: initialContext,
  initial: "Idle",
  states: {
    Idle: {
      entry: () => console.log("Idle"),
      on: {
        setVolume: {
          target: "SetVolume",
          actions: () => console.log(1),
        },
      },
    },
    SetVolume: {
      invoke: {
        src: "otherMachine",
        onDone: "Idle",
      },
    },
  },
});

Generates a new actor instance each time it enters the SetVolume state, and that actor has access to the provided actor when providing to the someOtherMachine machine. Therefore, it seems that accessing the parent's actor is not required.