These tests only verify basic data structure properties and don't test actual state machine behavior. Consider adding integration tests that:

1. Create an actor instance and verify the state transitions when focus.node is sent with autoUnfocus flag
2. Test that focus.autoUnfocus event transitions from focused to idle state
3. Test that the autoUnfocusTimer context property is correctly set/cleared
4. Test the guard 'focus.node: autoUnfocus' works correctly

The current tests are essentially type checks disguised as unit tests and don't provide meaningful coverage of the feature's behavior.

The tests for findNodeByElementFqn are good, but the tests for navigation behavior (lines 67-115) don't actually test state machine behavior. They only verify that event objects can be created with certain properties. Consider adding integration tests that:

1. Test the actual navigation flow with focusOnElement parameter
2. Verify that findNodeByElementFqn is called with the correct parameters during navigation
3. Test that focus.node event is raised with autoUnfocus=true when a matching node is found
4. Test that raiseFitDiagram is called when no focusOnElement is provided

Current tests provide coverage for the utility function but not the feature integration.

The logic for finding a node by element FQN is duplicated here and in machine.state.navigating.ts (line 16-22). Consider extracting the findNodeByElementFqn function to a shared location (e.g., utils.ts) and reusing it here:

focusOnElement: (elementFqn: Fqn<A>) => {
  const context = actorRef.current.getSnapshot().context
  const nodeId = findNodeByElementFqn(context.xynodes, elementFqn)
  if (nodeId) {
    actorRef.current.send({ type: 'focus.node', nodeId, autoUnfocus: true })
  }
},

This improves maintainability and ensures consistency across the codebase.

With AUTO_UNFOCUS_DELAY set to 0, the auto-unfocus timer is effectively disabled and the condition on line 777 will never be true. This means:

1. The startAutoUnfocusTimer action does nothing
2. The focus.autoUnfocus event will never be raised
3. The focused state will never automatically return to idle

This creates dead code. Either:

• Remove the auto-unfocus timer feature entirely if it's not needed
• Set a non-zero delay if auto-unfocus is intended
• Add a comment explaining why this is intentionally disabled

The documentation comment suggests this is configurable, but having it disabled by default in production code is confusing.

[nitpick] The delay when focusing a node (150ms) is longer than the default fit diagram delay (100ms). This inconsistency could lead to unpredictable UI behavior. Consider:

1. Using a consistent delay value, perhaps extracted as a constant:

const NAVIGATION_DELAY = 150 // or 100

2. Or documenting why focus needs a longer delay than fit diagram. The longer delay might be intentional to allow the view to settle, but it's not clear from the code.

Additionally, consider if these hardcoded delays could be replaced with proper event sequencing or state transitions instead of relying on setTimeout-based timing.

The comment says "Focus was initialed by the user searching" but "initialed" should be "initiated".