How connect parallel machines without root with common action?

[NikitaIT]

I want create FSM1, FSM2, FSM3.
And declare all transitions. But I can send event only to parent or children or actor(but actor ref in context and have same constraint).
How do this:

// root FSM
entry: {
 spawn(FSM1, "FSM1"),
 spawn(FSM2, "FSM2"),
 spawn(FSM3, "FSM3"),
}
// FSM3
{
 on: { 
   update: {
     actions: (ctxOfFSM3, event) => send(event, { to: "FSM1" }) // Unable to send event to child 'FSM1' from service 'FSM3'
   }
 }
}

Or in one machine:

// root FSM same as computed state for FSM3 from FSM{1,2}
type: "parallel",
states: {
 FSM1: FSM1,
 FSM2: FSM2,
 FSM3: FSM3,
}
// FSM{1,2}
{
  id: "FSM1",
  steates: { idle: { on: { update: { 
              actions: actions.respond({
                  type: idle, // to FSM3
                  value: 1, // like FSM1 say what FSM1 in state "1"
                }),
  } } } }
}
// FSM3
{
 on: {
   idle: {}, // from FSM1 and swich FSM3 to FSM* state
   update: [{ // like ask FSM* about states
     actions: (ctxOfFSM3, event) => send(event, { to: "#FSM1.idle" }) // but 'to' not FSM3 parent or children
   }]
 }
}

But i can create common action in root FSM, and resend all events down. But how can i send events from FSM3 to FSM1 and FSM2 and toggle FSM3 if FSM1 and FSM2 respond with same value(without context)?

[davidkpiano]

If I understand correctly, you're asking about sibling communication. The way to do this would be to go hierarchically - send an event to the parent which should (with custom logic) route it to the correct child.

Is there any problem with going through the parent first?

[NikitaIT]

@davidkpiano I tried to do it through a parent, but I still don't understand why I can't address children for send.

createMachine({
  id: "root",
  type: "parallel",
  on: {
    redirect: {
      target: ["." + "FSM1" + ".on"], // works
      actions: actions.pure((context, event) => {
        return send(event.rawValue, { to: "." + event.redirect + ".on" }); // Unable to send event to child ".FSM1.on" from service "root"
      }),
    },
  },
  states: {
  FSM1: createFSM(...), // FSM1 in state on has path #root.FSM1.on,
  FSM2: createFSM(...), // FSM2 in state on has path #root.FSM2.on,
  FSM3: /* do */ send({
              type: "redirect",
              redirect: "FSM1",
              rawValue: {
                type: "NAME_FOR_REDIRECT",
                ...event,
              }, }) 
     

 }, 
})


export function createFSM<TContext, TEvent extends EventObject>(
  cond: Condition<TContext, TEvent>
) {
  const on = Path.toSelf(BooleanStateName.on);
  const off = Path.toSelf(BooleanStateName.off);
  return {
    initial: BooleanStateName.on,
    on: {
      "NAME_FOR_REDIRECT": [
        {
          target: on,
          cond,
          actions: [
            actions.respond({...}),
          ],
        },
        {
          target: off,
          actions: [
            actions.respond({...}),
          ],
        },
      ],
    },
    states: staticPartOfConstraint,
  };
}

// avoid too many memory alloc
const staticPartOfConstraint = {
  [BooleanStateName.on]: {
    on: {
      [ConstraintEventName.update]: [
        {
          target: BooleanStateName.off,
        },
      ],
    },
  },
  [BooleanStateName.off]: {
    on: {
      [ConstraintEventName.update]: [
        {
          target: BooleanStateName.on,
        },
      ],
    },
  },
};

[NikitaIT]

With actors send(event.rawValue, { to: "." + event.redirect + ".on" }) works. But viz not works, and redirect looks like an anti-patern.
It also leads to problems, like: i cannot call respond 2 times, so i need to explicitly pass the path to the real sender.

Ok, i can spawn the actors at the request of the parent, but then i need a context, in order to get rid of the state in the context, i need to be able to work with the state of the machine as with data, and not as with the metadata of the framework, but for this i need to keep the actors alive. Vicious circle.

[Andarist]

Your given example doesn't contain multiple machines - it has a single machine with nested states, so there are no children and thus targeted send fails.

[NikitaIT]

Yes, you are right, I think I realized that I was doing everything wrong. This new HAL article about supervisory control
theory helped me a lot. I just didn't have to do what I was going to do.

[NikitaIT]

Parallel states must be independent but may be partially polymorphic. The problem in which two parallel states interact can be solved either by introducing a supervisor of a blocking event or by constraints on variables. Variables are chosen to break such transitions. Don't use redirect for this.