using NxGraph; using NxGraph.Authoring; using NxGraph.Fsm; static ValueTask<Result> Acquire(CancellationToken _) => ResultHelpers.Success; static ValueTask<Result> Process(CancellationToken _) => ResultHelpers.Success; static ValueTask<Result> Release(CancellationToken _) => ResultHelpers.Success; AsyncStateMachine fsm = GraphBuilder .StartWith(Acquire).SetName("Acquire") .To(Process).SetName("Process") .To(Release).SetName("Release") .ToAsyncStateMachine(); Result result = await fsm.ExecuteAsync();

using NxGraph; using NxGraph.Authoring; using NxGraph.Fsm; StateMachine fsm = GraphBuilder .StartWith(() => Result.Success).SetName("Start") .To(() => Result.Success).SetName("End") .ToStateMachine(); Result result = fsm.Execute();

var graph = GraphBuilder .StartWith(_ => ResultHelpers.Success).SetName("Start") .To(_ => ResultHelpers.Success).SetName("Step1") .To(_ => ResultHelpers.Success).SetName("Step2") .Build();

bool IsPremium() => true; var graph = GraphBuilder .StartWith(_ => ResultHelpers.Success).SetName("Entry") .If(IsPremium) .Then(_ => ResultHelpers.Success).SetName("Premium") .Else(_ => ResultHelpers.Success).SetName("Standard") .Build();

int RouteKey() => 2; var graph = GraphBuilder .StartWith(_ => ResultHelpers.Success).SetName("Entry") .Switch(RouteKey) .Case(1, _ => ResultHelpers.Success) .Case(2, _ => ResultHelpers.Success) .Default(_ => ResultHelpers.Failure) .End().SetName("Router") .Build();

var delayed = GraphBuilder .StartWith(_ => ResultHelpers.Success).SetName("Start") .WaitFor(250.Milliseconds()).SetName("Cooldown") .To(_ => ResultHelpers.Success).SetName("Finish") .Build(); var timed = GraphBuilder .StartWith(_ => ResultHelpers.Success).SetName("Start") .ToWithTimeout(2.Seconds(), _ => ResultHelpers.Success, TimeoutBehavior.Fail) .SetName("TimedWork") .To(_ => ResultHelpers.Success).SetName("AfterTimeout") .Build();

var graph = GraphBuilder .StartWith(_ => ResultHelpers.Success).SetName("Initial") .To(_ => ResultHelpers.Success).SetName("Second") .Build() .SetName("SampleGraph");

using NxGraph; using NxGraph.Authoring; using NxGraph.Fsm; public sealed class AppAgent { public int Counter { get; set; } } public sealed class WorkState : AsyncState<AppAgent> { protected override ValueTask<Result> OnRunAsync(CancellationToken ct) { Agent.Counter++; return ResultHelpers.Success; } } AsyncStateMachine<AppAgent> fsm = GraphBuilder .StartWith(new WorkState()).SetName("Work") .ToAsyncStateMachine<AppAgent>() .WithAgent(new AppAgent()); await fsm.ExecuteAsync();

AsyncStateMachine sm = graph.ToAsyncStateMachine(observer: null); Result result = await sm.ExecuteAsync();

StateMachine sm = graph.ToStateMachine(observer: null); Result result = sm.Execute();

using NxGraph.Diagnostics.Validations; Graph graph = GraphBuilder .StartWith(_ => ResultHelpers.Success) .To(_ => ResultHelpers.Success) .Build(); GraphValidationResult validation = graph.Validate(); if (validation.HasErrors) { foreach (GraphDiagnostic diagnostic in validation.Diagnostics) { Console.WriteLine(diagnostic); } } graph.ValidateAndThrowIfErrorsDebug();

using NxGraph.Fsm; using NxGraph.Graphs; public sealed class ConsoleObserver : IAsyncStateMachineObserver { public ValueTask OnStateMachineStarted(NodeId graphId, CancellationToken ct = default) { Console.WriteLine($"FSM started: {graphId}"); return ValueTask.CompletedTask; } public ValueTask OnStateEntered(NodeId id, CancellationToken ct = default) { Console.WriteLine($"Entered: {id.Name}"); return ValueTask.CompletedTask; } public ValueTask OnTransition(NodeId from, NodeId to, CancellationToken ct = default) { Console.WriteLine($"Transition: {from.Name} -> {to.Name}"); return ValueTask.CompletedTask; } public ValueTask OnStateExited(NodeId id, CancellationToken ct = default) { Console.WriteLine($"Exited: {id.Name}"); return ValueTask.CompletedTask; } }

using NxGraph.Fsm; IAsyncStateMachineObserver observer = new TracingObserver(); AsyncStateMachine fsm = graph.ToAsyncStateMachine(observer); await fsm.ExecuteAsync();

using NxGraph.Diagnostics.Replay; using NxGraph.Fsm; ReplayRecorder recorder = new(); AsyncStateMachine fsm = graph.ToAsyncStateMachine(recorder); await fsm.ExecuteAsync(); StateMachineReplay replay = new(recorder.GetEvents().Span); replay.ReplayAll(evt => { Console.WriteLine($"{evt.Type}: {evt.SourceId} -> {evt.TargetId} | {evt.Message}"); }); byte[] bytes = replay.Serialize(); ReplayEvent[] roundTripped = StateMachineReplay.Deserialize(bytes);

using NxGraph.Diagnostics.Export; string mermaid = GraphBuilder .StartWith(_ => ResultHelpers.Success).SetName("Start") .To(_ => ResultHelpers.Success).SetName("Process") .To(_ => ResultHelpers.Success).SetName("End") .Build() .ToMermaid(); Console.WriteLine(mermaid);

using System.Text.Json; using NxGraph; using NxGraph.Authoring; using NxGraph.Graphs; using NxGraph.Serialization; public sealed class ExampleState : IAsyncLogic { public string Data { get; set; } = string.Empty; public ValueTask<Result> ExecuteAsync(CancellationToken ct = default) => ResultHelpers.Success; } public sealed class ExampleLogicCodec : ILogicTextCodec { public string Serialize(IAsyncLogic data) => JsonSerializer.Serialize((ExampleState)data); public IAsyncLogic Deserialize(string payload) => JsonSerializer.Deserialize<ExampleState>(payload) ?? throw new InvalidOperationException("Failed to deserialize ExampleState."); } Graph graph = GraphBuilder .StartWith(new ExampleState { Data = "start" }).SetName("Start") .To(new ExampleState { Data = "end" }).SetName("End") .Build() .SetName("ExampleGraph"); GraphSerializer serializer = new(new ExampleLogicCodec()); await using MemoryStream stream = new(); await serializer.ToJsonAsync(graph, stream); stream.Position = 0; Graph roundTripped = await serializer.FromJsonAsync(stream);