WIP SCXML

Author: davidkpiano

packages/core/src/createMachineFromConfig.ts

@@ -60,6 +60,14 @@ export interface ScxmlRaiseJSON {
   delay?: number;
   /** Expression for delay */
   delayexpr?: string;
+  /** Expression for target */
+  targetexpr?: string;
+}
+
+export interface ScxmlScriptJSON {
+  type: 'scxml.script';
+  /** The script code to execute */
+  code: string;
 }
 
 export type BuiltInActionJSON =
@@ -82,7 +90,8 @@ export type ActionJSON =
   | EmitJSON
   | AssignJSON
   | ScxmlAssignJSON
-  | ScxmlRaiseJSON;
+  | ScxmlRaiseJSON
+  | ScxmlScriptJSON;
 
 export interface GuardJSON {
   type: string;
@@ -136,16 +145,59 @@ function evaluateExpr(
   expr: string,
   event: AnyEventObject | null
 ): unknown {
-  const scope = 'const _sessionid = "NOT_IMPLEMENTED";';
+  const scope =
+    'const _sessionid = "NOT_IMPLEMENTED"; const _ioprocessors = "NOT_IMPLEMENTED";';
   const fnBody = `
 ${scope}
 with (context) {
   return (${expr});
 }
-  `;
+  `.trim();
   // eslint-disable-next-line @typescript-eslint/no-implied-eval
   const fn = new Function('context', '_event', fnBody);
-  return fn(context, event ? { name: event.type, data: event } : undefined);
+  // SCXML _event has: name, data, origin, origintype, etc.
+  // For self-raised events, origin is #_internal
+  const result = fn(
+    context,
+    event
+      ? {
+          name: event.type,
+          data: event,
+          origin: '#_internal',
+          origintype: 'http://www.w3.org/TR/scxml/#SCXMLEventProcessor'
+        }
+      : undefined
+  );
+
+  return result;
+}
+
+/** Executes an SCXML script block and returns updated context values. */
+function executeScript(
+  context: MachineContext,
+  code: string
+): Record<string, unknown> {
+  // Create a proxy to track which properties are modified
+  const updates: Record<string, unknown> = {};
+  const contextKeys = Object.keys(context);
+
+  // Build variable declarations and reassignment capture
+  const varDeclarations = contextKeys
+    .map((k) => `let ${k} = context.${k};`)
+    .join('\n');
+  const captureUpdates = contextKeys
+    .map((k) => `updates.${k} = ${k};`)
+    .join('\n');
+
+  const fnBody = `
+${varDeclarations}
+${code}
+${captureUpdates}
+return updates;
+  `;
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  const fn = new Function('context', 'updates', fnBody);
+  return fn(context, updates);
 }
 
 export function createMachineFromConfig(json: MachineJSON): AnyStateMachine {
@@ -305,19 +357,40 @@ export function createMachineFromConfig(json: MachineJSON): AnyStateMachine {
             }
           }
 
-          // Evaluate delay if expression
+          // Evaluate target if expression
+          const target = scxmlAction.targetexpr
+            ? (evaluateExpr(
+                mergedContext,
+                scxmlAction.targetexpr,
+                x.event
+              ) as string)
+            : undefined;
+
+          // If target is #_internal, use internal queue (no delay)
+          // Otherwise use the specified delay or default external queue delay
+          const isInternalTarget = target === '#_internal';
           const delay = scxmlAction.delayexpr
             ? (evaluateExpr(
                 mergedContext,
                 scxmlAction.delayexpr,
                 x.event
               ) as number)
-            : scxmlAction.delay;
+            : isInternalTarget
+              ? undefined
+              : scxmlAction.delay;
 
           enq.raise(eventData as AnyEventObject, {
             id: scxmlAction.id,
             delay
           });
+        } else if (action.type === 'scxml.script') {
+          // SCXML script - execute code that can modify context
+          context ??= {};
+          const scxmlAction = action as ScxmlScriptJSON;
+          const mergedContext = { ...x.context, ...context };
+          // Execute script with context variables in scope
+          const updatedContext = executeScript(mergedContext, scxmlAction.code);
+          Object.assign(context, updatedContext);
         } else {
           enq(x.actions[action.type], (action as CustomActionJSON).params);
         }

packages/core/src/scxml.ts

@@ -108,7 +108,7 @@ function mapAction(element: XMLElement): ActionJSON {
       };
     }
     case 'send': {
-      const { event, eventexpr, target, id, delay, delayexpr } =
+      const { event, eventexpr, target, targetexpr, id, delay, delayexpr } =
         element.attributes!;
 
       // Extract params from child elements
@@ -128,23 +128,22 @@ function mapAction(element: XMLElement): ActionJSON {
         }
       }
 
-      // If no params and no expressions, use simple RaiseJSON
-      if (!params.length && !eventexpr && !delayexpr) {
-        if (target === SpecialTargets.Internal) {
-          const action: RaiseJSON = {
-            type: '@xstate.raise',
-            event: { type: event as string },
-            id: id as string | undefined,
-            delay: delay ? delayToMs(delay) : undefined
-          };
-          return action;
-        }
+      const isInternal = target === SpecialTargets.Internal;
+      // External events (non-internal) go to external queue via delay:0
+      // This ensures internal events are processed first within a macrostep
+      const resolvedDelay = delay
+        ? delayToMs(delay)
+        : isInternal
+          ? undefined
+          : 0;
 
+      // If no params and no expressions, use simple RaiseJSON
+      if (!params.length && !eventexpr && !delayexpr && !targetexpr) {
         const action: RaiseJSON = {
           type: '@xstate.raise',
           event: { type: (event as string) || 'unknown' },
           id: id as string | undefined,
-          delay: delay ? delayToMs(delay) : undefined
+          delay: resolvedDelay
         };
         return action;
       }
@@ -156,8 +155,9 @@ function mapAction(element: XMLElement): ActionJSON {
         eventexpr: eventexpr as string | undefined,
         params: params.length ? params : undefined,
         id: id as string | undefined,
-        delay: delay ? delayToMs(delay) : undefined,
-        delayexpr: delayexpr as string | undefined
+        delay: resolvedDelay,
+        delayexpr: delayexpr as string | undefined,
+        targetexpr: targetexpr as string | undefined
       };
       return action;
     }
@@ -176,6 +176,12 @@ function mapAction(element: XMLElement): ActionJSON {
       // The full implementation would require runtime conditional logic
       return { type: 'scxml.if', params: { element } };
     }
+    case 'script': {
+      // Get the script text content
+      const textElement = element.elements?.find((el) => el.type === 'text');
+      const code = (textElement?.text as string) || '';
+      return { type: 'scxml.script', code: code.trim() };
+    }
     default:
       throw new Error(
         `Conversion of "${element.name}" elements is not implemented yet.`
@@ -340,13 +346,16 @@ function toStateNodeJSON(
         guard = createGuard(value.attributes.cond as string);
       }
 
+      // Only set reenter:true for external transitions WITH a target
+      // Targetless transitions should not reenter (they just execute actions)
+      const hasTarget = targets !== undefined;
       const transitionConfig: TransitionJSON = {
         target: getTargets(targets),
         ...(value.elements?.length
           ? { actions: mapActions(value.elements) }
           : undefined),
         ...(guard ? { guard } : undefined),
-        ...(!internal && { reenter: true })
+        ...(hasTarget && !internal && { reenter: true })
       };
 
       if (eventType === NULL_EVENT || eventType === '') {

packages/core/src/stateUtils.ts

@@ -1241,7 +1241,7 @@ function enterStates(
  * transition.
  */
 export function getTransitionResult(
-  transition: Pick<AnyTransitionDefinition, 'target' | 'fn' | 'source'> & {
+  transition: Pick<AnyTransitionDefinition, 'target' | 'to' | 'source'> & {
     reenter?: AnyTransitionDefinition['reenter'];
   },
   snapshot: AnyMachineSnapshot,

packages/core/test/scxml.test.ts

@@ -164,7 +164,7 @@ const testGroups: Record<string, string[]> = {
     // 'test198.txml', // origintype not implemented yet
     // 'test199.txml', // send type not checked
     'test200.txml',
-    'test201.txml',
+    // 'test201.txml', // optional
     'test205.txml',
     // 'test207.txml', // delayexpr
     'test208.txml',
@@ -354,25 +354,46 @@ interface SCIONTest {
 
 async function runW3TestToCompletion(
   name: string,
-  machine: AnyStateMachine
+  scxmlDefinition: string,
+  test: SCIONTest
 ): Promise<void> {
+  const machine = toMachine(scxmlDefinition);
+
   const { resolve, reject, promise } = Promise.withResolvers<void>();
   let nextState: AnyMachineSnapshot;
   let prevState: AnyMachineSnapshot;
 
+  const transitions: string[] = [];
+
   const actor = createActor(machine, {
     logger: () => void 0
   });
+  actor.system.inspect((e) => {
+    console.log({
+      type: e.type,
+      microsteps: e.microsteps.map((m) => ({
+        type: m.eventType,
+        state: m.target
+      }))
+    });
+  });
   actor.subscribe({
     next: (state) => {
       prevState = nextState;
       nextState = state;
+      transitions.push(
+        `${JSON.stringify(state.value)} ${JSON.stringify(state.context)}`
+      );
     },
     complete: () => {
       // Add 'final' for test230.txml which does not have a 'pass' state
       if (['final', 'pass'].includes(nextState.value as string)) {
         resolve();
       } else {
+        console.log(transitions.join('\n'));
+        console.log(scxmlDefinition);
+        console.log(toMachineJSON(scxmlDefinition));
+        console.log(JSON.stringify(test, null, 2));
         reject(
           new Error(
             `${name}: Reached "fail" state from state ${JSON.stringify(
@@ -397,7 +418,7 @@ async function runTestToCompletion(
   const machine = toMachine(scxmlDefinition);
 
   if (!test.events.length && test.initialConfiguration[0] === 'pass') {
-    await runW3TestToCompletion(name, machine);
+    await runW3TestToCompletion(name, scxmlDefinition, test);
     return;
   }
 
@@ -440,6 +461,7 @@ async function runTestToCompletion(
   });
   actor.start();
 
+  const transitions: string[] = [];
   test.events.forEach(({ event, nextConfiguration, after }) => {
     if (done) {
       return;
@@ -448,19 +470,29 @@ async function runTestToCompletion(
       (actor.clock as SimulatedClock).increment(after);
     }
     actor.send({ type: event.name });
+    transitions.push(
+      `${event.name} -> ${JSON.stringify(actor.getSnapshot().value)} ${JSON.stringify(actor.getSnapshot().context)}`
+    );
 
     const stateIds = getStateNodes(machine.root, nextState.value).map(
       (stateNode) => stateNode.id
     );
 
+    if (!stateIds.includes(sanitizeStateId(nextConfiguration[0]))) {
+      console.log(transitions.join('\n'));
+      console.log(scxmlDefinition);
+      console.log(JSON.stringify(machineJSON, null, 2));
+      console.log(JSON.stringify(test, null, 2));
+    }
+
     expect(stateIds).toContain(sanitizeStateId(nextConfiguration[0]));
   });
 }
 
-describe('scxml', () => {
+describe.skip('scxml', () => {
   const onlyTests: string[] = [
     // e.g., 'test399.txml'
-    // 'test560.txml'
+    'test147.txml'
   ];
   const testGroupKeys = Object.keys(testGroups);
 
@@ -469,7 +501,8 @@ describe('scxml', () => {
 
     testNames.forEach((testName) => {
       const execTest = onlyTests.length
-        ? onlyTests.includes(testName)
+        ? onlyTests.includes(testName) ||
+          onlyTests.includes(`${testGroupName}/${testName}`)
           ? it.only
           : it.skip
         : it;