# State Initialization Issue Investigation

## Issue Description
The test "should handle execution directives correctly" in `api/api.test.ts` fails with "Failed to get state ID - state not properly initialized". This appears to be a fundamental issue with state initialization that is causing several other test failures.

## Related Code

### Code Files
- `services/StateService/StateService.ts`: Main state service implementation
- `services/StateService/StateFactory.ts`: Factory for creating state nodes
- `services/StateService/types.ts`: State type definitions
- `tests/utils/TestContext.ts`: Test context that initializes services
- `api/api.test.ts`: The failing test

### Test Files
- `api/api.test.ts`: Contains the failing test case

## Evidence

### Test Expectations
The test expects:
1. A properly initialized state with a valid state ID
2. The state to be configured for execution directives
3. The state to be properly integrated with tracking and event services

### Current Behavior
1. `getStateId()` returns undefined
2. The state tracking service shows "All tracked states: []" in the test output
3. This causes cascading failures in other tests that depend on state content

### Code Analysis

#### Test Structure
The test is using extensive instrumentation:
```typescript
// Start debug session with enhanced configuration
const debugSessionId = await context.startDebugSession({
  captureConfig: {
    capturePoints: ['pre-transform', 'post-transform', 'error'],
    includeFields: ['nodes', 'transformedNodes', 'variables', 'metadata'],
    format: 'full'
  },
  visualization: {
    format: 'mermaid',
    includeMetadata: true,
    includeTimestamps: true
  }
});
```

#### Service Initialization
In TestContext constructor:
```typescript
const tracking = new StateTrackingService();
const eventService = new StateEventService();
const history = new StateHistoryService(eventService);
const visualization = new StateVisualizationService(history, tracking);
const state = new StateService();
state.setCurrentFilePath('test.meld');
state.enableTransformation(true);
state.setTrackingService(tracking);
state.setEventService(eventService);
```

#### Root Cause
The issue stems from the state initialization sequence:

1. In `StateService` constructor:
```typescript
constructor(parentState?: IStateService) {
  this.stateFactory = new StateFactory();
  this.currentState = this.stateFactory.createState({
    source: 'new',
    parentState: parentState ? (parentState as StateService).currentState : undefined
  });

  // Initialize state ID first
  this.currentState.stateId = crypto.randomUUID();
  // ...
}
```

2. In `StateFactory.createState()`:
```typescript
createState(options?: StateNodeOptions): StateNode {
  const state: StateNode = {
    variables: {
      text: new Map(options?.parentState?.variables.text ?? []),
      data: new Map(options?.parentState?.variables.data ?? []),
      path: new Map(options?.parentState?.variables.path ?? [])
    },
    commands: new Map(options?.parentState?.commands ?? []),
    imports: new Set(options?.parentState?.imports ?? []),
    nodes: [...(options?.parentState?.nodes ?? [])],
    transformedNodes: options?.parentState?.transformedNodes ? [...options.parentState.transformedNodes] : undefined,
    filePath: options?.filePath ?? options?.parentState?.filePath,
    parentState: options?.parentState
  };
  // Note: No stateId is set here
  return state;
}
```

3. In `types.ts`:
```typescript
export interface StateNode {
  stateId?: string;  // Optional field
  source?: 'clone' | 'merge' | 'new' | 'child' | 'implicit';
  // ...
}
```

The issue is that the state ID is being generated AFTER the state is created by the factory. The factory doesn't set a state ID, and the state ID is optional in the `StateNode` interface. This means that operations that happen between state creation and ID generation could be working with an uninitialized state.

### Debug Output
```
All tracked states: []
Test failed with error: Error: Failed to get state ID - state not properly initialized
```

### Instrumentation Analysis
1. The state tracking service shows no tracked states because the state ID is not properly initialized
2. The state service is generating an ID but it may be happening too late in the initialization sequence
3. The state initialization sequence needs to be adjusted to ensure the ID is set before any other operations

## Attempted Solutions
None yet - root cause has been identified.

## Additional Notes
1. The state initialization sequence in TestContext appears correct but relies on proper state ID initialization
2. The state service is properly connected to tracking and event services
3. The issue is in the timing of state ID generation vs state creation

## Next Steps
1. Move state ID generation into the factory's createState method
2. Make stateId a required field in the StateNode interface
3. Add validation in the factory to ensure state ID is always set
4. Add state service lifecycle events for better debugging
5. Consider adding invariant checks to ensure state ID is present before any operations