type FlowState struct {
    input   map[string][]byte  // Initial workflow input
    results map[string]any     // Node outputs (keyed by node name)
    cursors map[string]Cursor  // Position tracking for data sources
}

// Get a value (panics if key missing or type mismatch)
result := core.Get[FetchOutput](state, "fetch-node")

// Get with default fallback (returns default on missing/mismatch)
result := core.GetOr(state, "fetch-node", FetchOutput{})

// Set a typed value
core.Set(state, "custom-key", MyData{Value: 42})

// Raw access (less safe)
state.SetResult("key", value)
raw := state.GetResult("key")  // Returns any

// First node produces output
fetchNode := core.NewNode("fetch", fetchData, FetchInput{})

// Second node consumes it via WithInputFunc
processNode := core.NewNode("process", processData, ProcessInput{}).
    WithInputFunc(func(state *core.FlowState) ProcessInput {
        // Type-safe retrieval of previous node's output
        fetchResult := core.Get[FetchOutput](state, "fetch")
        return ProcessInput{
            Items: fetchResult.Items,
            Count: len(fetchResult.Items),
        }
    })

type Cursor struct {
    Source    string    // Data source identifier
    Position  string    // Current position (timestamp, ID, offset)
    UpdatedAt time.Time // When cursor was last updated
}

// Get cursor for a data source
cursor := state.GetCursor("jira-issues")

// Parse as timestamp
since, err := cursor.Time()

// Parse with default fallback
since := cursor.TimeOr(time.Now().AddDate(0, 0, -7))  // Default: 7 days ago

// Update cursor position
state.SetCursor("jira-issues", latestIssue.UpdatedAt.Format(time.RFC3339))

fetchNode := core.NewNode("fetch", fetchIssues, FetchInput{}).
    WithInputFunc(func(state *core.FlowState) FetchInput {
        cursor := state.GetCursor("jira-issues")
        return FetchInput{
            Since: cursor.TimeOr(time.Now().AddDate(0, -1, 0)),  // Default: 1 month
        }
    })

// After successful sync, update cursor
updateCursorNode := core.NewNode("update-cursor", updateCursor, UpdateInput{}).
    WithInputFunc(func(state *core.FlowState) UpdateInput {
        result := core.Get[FetchOutput](state, "fetch")
        if len(result.Issues) == 0 {
            return UpdateInput{}  // No update needed
        }
        latest := result.Issues[len(result.Issues)-1]
        return UpdateInput{
            Source:   "jira-issues",
            Position: latest.UpdatedAt.Format(time.RFC3339),
        }
    })

// Default: Local .resolute/ directory
// Production: Configure a cloud backend
flow := core.NewFlow("sync").
    WithState(core.StateConfig{
        Backend: myS3Backend,
    }).
    ...

// Create a snapshot (deep copy)
snapshot := state.Snapshot()

// Snapshot is used in Saga pattern for rollback
// When compensation runs, it receives the snapshot from when the original node ran

// During execution:
// 1. fetchNode executes, snapshot captured
// 2. processNode fails
// 3. Compensation for fetchNode runs with the captured snapshot
//    (can see what fetchNode produced, undo accordingly)

type FlowState struct {
    mu sync.RWMutex  // Protects all fields
    // ...
}

type StateBackend interface {
    Load(workflowID, flowName string) (*PersistedState, error)
    Save(workflowID, flowName string, state *PersistedState) error
}

type PersistedState struct {
    Cursors   map[string]Cursor
    Metadata  map[string]string
    Version   int64
    UpdatedAt time.Time
}

type S3Backend struct {
    bucket string
    client *s3.Client
}

func (b *S3Backend) Load(workflowID, flowName string) (*core.PersistedState, error) {
    key := fmt.Sprintf("%s/%s.json", workflowID, flowName)
    // Load from S3...
}

func (b *S3Backend) Save(workflowID, flowName string, state *core.PersistedState) error {
    key := fmt.Sprintf("%s/%s.json", workflowID, flowName)
    // Save to S3...
}

// Use in flow
flow := core.NewFlow("sync").
    WithState(core.StateConfig{
        Backend:   &S3Backend{bucket: "my-bucket", client: s3Client},
        Namespace: "production",
    }).
    Then(syncNode).
    Build()

// Good
result := core.Get[FetchOutput](state, "fetch")

// Avoid
raw := state.GetResult("fetch")
result := raw.(FetchOutput)  // Runtime panic risk

// Output stored as "fetch-issues" by default
fetchNode := core.NewNode("fetch-issues", fetch, input)

// Or explicitly name it
fetchNode := core.NewNode("fetch-issues", fetch, input).As("issues")

// Good: Handles missing cursor
since := cursor.TimeOr(time.Now().AddDate(0, 0, -30))

// Risky: May panic or return zero time
since, _ := cursor.Time()

// Bad: Large data in state
type BadOutput struct {
    AllRecords []Record  // Could be millions
}

// Good: Store reference
type GoodOutput struct {
    S3Key     string  // Reference to data
    Count     int
    Summary   string
}