diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index 74083f7..b6bcafd 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -15,7 +15,7 @@ on:
       - develop
 
 env:
-  DOTNET_VERSION: "8.0.x"
+  DOTNET_VERSION: "9.0.x"
 
 jobs:
   format:
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index d452c75..3c223de 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -17,7 +17,7 @@ on:
 env:
   BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
   SOLUTION_NAME: ${{ vars.SOLUTION_NAME }}
-  DOTNET_VERSION: "8.0.x"
+  DOTNET_VERSION: "9.0.x"
 
 jobs:
   test:
diff --git a/Directory.Build.targets b/Directory.Build.targets
index ab19c8b..8cea3b3 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -4,7 +4,7 @@
     -->
 	<Target Name="PushPackage" AfterTargets="Pack" 
 	        Condition="'$(PushAfterPack)'=='true' AND '$(IsPackable)'=='true'">
-		<Exec Command="dotnet nuget push $(SolutionDir)output/$(TargetName).$(PackageVersion).nupkg $(PackageSourceParam) $(PackageApiKeyParam)"></Exec>
+		<Exec Command="dotnet nuget push $(SolutionDir)output/$(PackageId).$(PackageVersion).nupkg $(PackageSourceParam) $(PackageApiKeyParam)"></Exec>
 	</Target>
 
 	<!--
diff --git a/Hyperbee.Expressions.sln.DotSettings b/Hyperbee.Expressions.sln.DotSettings
index b6a0b9b..5eea785 100644
--- a/Hyperbee.Expressions.sln.DotSettings
+++ b/Hyperbee.Expressions.sln.DotSettings
@@ -1,8 +1,12 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=15b5b1f1_002D457c_002D4ca6_002Db278_002D5615aedc07d3/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static readonly fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" WarnAboutPrefixesAndSuffixes="False" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="__" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=f9fce829_002De6f4_002D4cb2_002D80f1_002D5497c44f51df/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="__" Suffix="" Style="aa_bb" /&gt;&lt;/Policy&gt;&lt;/Policy&gt;</s:String>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Awaiters/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Castclass/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=comparand/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=fingerprinter/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=gotos/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Hyperbee/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ldarg/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ldarga/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ldarga/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=optimizer_0027s/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/README.md b/README.md
index 4202ad7..e2cb1b7 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # Welcome to Hyperbee Expressions
 
-`Hyperbee.Expressions` is a library for creating c# expression trees that extend the capabilities of standard expression 
-trees to handle asynchronous workflows and other constructs.
+`Hyperbee.Expressions` is a C# library that extends the capabilities of expression trees to handle asynchronous 
+workflows and other language constructs.
 
 ## Features
 
@@ -17,6 +17,10 @@ trees to handle asynchronous workflows and other constructs.
     * `ForExpression`: An expression that represents a for loop.
     * `ForEachExpression`: An expression that represents a foreach loop.
 
+* * **Other Expressions**
+    * `StringFormatExpression`: An expression that creates a string using a supplied format string and parameters.
+    * `DebugExpression`: An expression that helps when debugging expression trees.
+
 * Supports Fast Expression Compiler (FEC) for improved performance.
 
 ## Examples
@@ -25,41 +29,33 @@ trees to handle asynchronous workflows and other constructs.
 
 The following example demonstrates how to create an asynchronous expression tree.
 
+When the expression tree is compiled, the `BlockAsyncExpression` will auto-generate a state machine that executes 
+`AwaitExpressions` in the block asynchronously.
+
 ```csharp
 
 public class AsyncExample
 {
     public async Task ExampleAsync()
     {
-        // Variables to store the results
-        var result1 = Expression.Variable( typeof(int), "result1" );
-        var result2 = Expression.Variable( typeof(int), "result2" );
-
-        // Define two async method calls
-
-        var instance = Expression.Constant( this );
-
-        var awaitExpr1 = ExpressionExtensions.Await( 
-            Expression.Call( instance, nameof(FirstAsyncMethod), Type.EmptyTypes ) 
-        );
-
-        var awaitExpr2 = ExpressionExtensions.Await( 
-            Expression.Call( instance, nameof(SecondAsyncMethod), Type.EmptyTypes, result1 )
-        );
+        // Create an async block that calls async methods and assigns their results
 
-        // Assign the results of the await expressions to the variables
-        var assignResult1 = Expression.Assign( result1, awaitExpr1 );
-        var assignResult2 = Expression.Assign( result2, awaitExpr2 );
+        var instance = Constant( this );
+        var result1 = Variable( typeof(int), "result1" );
+        var result2 = Variable( typeof(int), "result2" );
 
-        // Create an async block that calls both methods and assigns their results
-        var asyncBlock = AsyncExpression.BlockAsync(
+        var asyncBlock = BlockAsync(
             [result1, result2],
-            assignResult1,
-            assignResult2
+            Assign( result1, Await(
+                Call( instance, nameof(FirstAsyncMethod), Type.EmptyTypes )
+            ) ),
+            Assign( result2, Await(
+                Call( instance, nameof(SecondAsyncMethod), Type.EmptyTypes, result1 )
+            ) )
         );
 
         // Compile and execute the async block
-        var lambda = Expression.Lambda<Func<Task<int>>>( asyncBlock );
+        var lambda = Lambda<Func<Task<int>>>( asyncBlock );
         var compiledLambda = lambda.Compile();
         var resultValue2 = await compiledLambda();
 
@@ -119,6 +115,7 @@ public class UsingExample
 Special thanks to:
 
 - Sergey Tepliakov - [Dissecting the async methods in C#](https://devblogs.microsoft.com/premier-developer/dissecting-the-async-methods-in-c/).
+- [Fast Expression Compiler](https://github.com/dadhi/FastExpressionCompiler) for improved performance.
 - [Just The Docs](https://github.com/just-the-docs/just-the-docs) for the documentation theme.
 
 ## Contributing
diff --git a/docs/.todo.md b/docs/.todo.md
index e89651f..da778b2 100644
--- a/docs/.todo.md
+++ b/docs/.todo.md
@@ -1,17 +1,10 @@
 # Things TODO
 
-## Work to be done
+## AsyncEnumerable
+  - Add support for `IAsyncEnumerable` 
 
-- Investigate alternative StateMachine implementation that would allow us to use a struct instead of a class for the state machine.
-
-## State machine Fields
-  - Are we over adding fields to the StateMachine?
-  - Look into shared Exceptions object
+## State machine fields
+  - Look into shared Exceptions objects
   - Add shared awaiters based on common types
 
-## Documentation 
-- Add fast compile documation
-- Find/Document known limitations
-  - Unsupported `Await` in SwitchCase TestValues
-  - Unsupported `Await` in Finally blocks
   
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
index f6501ab..0b840c8 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -6,7 +6,7 @@ nav_order: 1
 # Welcome to Hyperbee Expressions
 
 `Hyperbee.Expressions` is a library for creating c# expression trees that extend the capabilities of standard expression 
-trees to handle asynchronous workflows and other constructs.
+trees to handle asynchronous workflows and other language constructs.
 
 ## Features
 
@@ -22,6 +22,10 @@ trees to handle asynchronous workflows and other constructs.
     * `ForExpression`: An expression that represents a for loop.
     * `ForEachExpression`: An expression that represents a foreach loop.
 
+* **Other Expressions**
+    * `StringFormatExpression`: An expression that creates a string using a supplied format string and parameters.
+    * `DebugExpression`: An expression that helps when debugging expression trees.
+
 * Supports Fast Expression Compiler (FEC) for improved performance.
 
 ## Examples
@@ -30,41 +34,32 @@ trees to handle asynchronous workflows and other constructs.
 
 The following example demonstrates how to create an asynchronous expression tree.
 
+When the expression tree is compiled, the `BlockAsyncExpression` will auto-generate a state machine that executes 
+`AwaitExpressions` in the block asynchronously.
+
 ```csharp
 
 public class AsyncExample
 {
     public async Task ExampleAsync()
     {
-        // Variables to store the results
-        var result1 = Expression.Variable( typeof(int), "result1" );
-        var result2 = Expression.Variable( typeof(int), "result2" );
-
-        // Define two async method calls
-
-        var instance = Expression.Constant( this );
-
-        var awaitExpr1 = ExpressionExtensions.Await( 
-            Expression.Call( instance, nameof(FirstAsyncMethod), Type.EmptyTypes ) 
-        );
-
-        var awaitExpr2 = ExpressionExtensions.Await( 
-            Expression.Call( instance, nameof(SecondAsyncMethod), Type.EmptyTypes, result1 )
-        );
-
-        // Assign the results of the await expressions to the variables
-        var assignResult1 = Expression.Assign( result1, awaitExpr1 );
-        var assignResult2 = Expression.Assign( result2, awaitExpr2 );
+        // Create an async block that calls async methods and assigns their results
+        var instance = Constant( this );
+        var result1 = Variable( typeof(int), "result1" );
+        var result2 = Variable( typeof(int), "result2" );
 
-        // Create an async block that calls both methods and assigns their results
-        var asyncBlock = AsyncExpression.BlockAsync(
+        var asyncBlock = BlockAsync(
             [result1, result2],
-            assignResult1,
-            assignResult2
+            Assign( result1, Await(
+                Call( instance, nameof(FirstAsyncMethod), Type.EmptyTypes )
+            ) ),
+            Assign( result2, Await(
+                Call( instance, nameof(SecondAsyncMethod), Type.EmptyTypes, result1 )
+            ) )
         );
 
         // Compile and execute the async block
-        var lambda = Expression.Lambda<Func<Task<int>>>( asyncBlock );
+        var lambda = Lambda<Func<Task<int>>>( asyncBlock );
         var compiledLambda = lambda.Compile();
         var resultValue2 = await compiledLambda();
 
@@ -124,6 +119,7 @@ public class UsingExample
 Special thanks to:
 
 - Sergey Tepliakov - [Dissecting the async methods in C#](https://devblogs.microsoft.com/premier-developer/dissecting-the-async-methods-in-c/).
+- [Fast Expression Compiler](https://github.com/dadhi/FastExpressionCompiler) for improved performance. :heart:
 - [Just The Docs](https://github.com/just-the-docs/just-the-docs) for the documentation theme.
 
 ## Contributing
diff --git a/docs/state-machine/lowering-visitor.md b/docs/state-machine/lowering-visitor.md
index d0d6777..a9ba461 100644
--- a/docs/state-machine/lowering-visitor.md
+++ b/docs/state-machine/lowering-visitor.md
@@ -16,11 +16,11 @@ It also identifies variables that will need to be hoisted so that variable scope
 
 ## Introduction
 
-The `LoweringVisitor` is responsible for transforming an expression tree into discrete states, and transitions, that will be used 
+The `LoweringVisitor` is responsible for transforming an expression tree into discrete states and transitions, that will be used 
 to generate the final state machine. 
 
-The purpose of this visitor is to "lower" high-level constructs, such as `await`, `if/else`, `switch`, and loops, into individual 
-`NodeExpression` objects that the state machine can later process.
+The purpose of this visitor is to "lower" high-level constructs, such as `await`, `if/else`, `switch`, `try\catch`, and loops, 
+into individual `NodeExpression` objects that the state machine can later process.
 
 
 ## 1. Handling Control Flow Constructs (Branching and Loops)
diff --git a/docs/state-machine/overview.md b/docs/state-machine/overview.md
index 72cd584..70cbd4a 100644
--- a/docs/state-machine/overview.md
+++ b/docs/state-machine/overview.md
@@ -21,10 +21,9 @@ operations that must suspend and resume execution.
 State machine creation occurs in two passes:
 
 ### Pass 1: Expression Tree Transformation
-The first pass uses a Lowering Technique to transform flow control constructs (such as if, switch, loops, and awaits) into a 
-state tree that can be used to generate a flattened goto state machine. This step systematically traverses the expression tree
-and replaces branching constructs with state nodes that manage control flow using transitions and goto operations. This step also 
-identifies variables that persist across state transitions and which will need to be hoisted by the builder.
+The first pass uses a Lowering Technique to transform `BlockAsyncExpression`s into state trees, and handles the lowering of
+complex flow control constructs (ifs, switches, loops, try/catch, and awaits) into more primitive representations. This step 
+also identifies variables that persist across states and require hoisting.
 
 ### Pass 2: State Machine Builder
 The second pass builds the state machine based on the transformed structure. This involves creating a state-machine type,
diff --git a/src/Hyperbee.Expressions/AsyncBlockExpression.cs b/src/Hyperbee.Expressions/AsyncBlockExpression.cs
index 422643a..c513196 100644
--- a/src/Hyperbee.Expressions/AsyncBlockExpression.cs
+++ b/src/Hyperbee.Expressions/AsyncBlockExpression.cs
@@ -1,4 +1,5 @@
-using System.Diagnostics;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Linq.Expressions;
 using Hyperbee.Expressions.Transformation;
 
@@ -7,61 +8,116 @@ namespace Hyperbee.Expressions;
 [DebuggerTypeProxy( typeof( AsyncBlockExpressionDebuggerProxy ) )]
 public class AsyncBlockExpression : Expression
 {
-    private readonly Expression[] _expressions;
-    private readonly ParameterExpression[] _variables;
-    private readonly Type _resultType;
-    private readonly Type _type;
-
+    private readonly Type _taskType;
     private Expression _stateMachine;
 
-    public AsyncBlockExpression( Expression[] expressions )
-        : this( [], expressions )
+    public ReadOnlyCollection<Expression> Expressions { get; }
+    public ReadOnlyCollection<ParameterExpression> Variables { get; }
+    internal ReadOnlyCollection<ParameterExpression> ExternVariables { get; set; }
+
+    public Expression Result => Expressions[^1];
+
+    internal AsyncBlockExpression( ReadOnlyCollection<ParameterExpression> variables, ReadOnlyCollection<Expression> expressions )
+        : this( variables, expressions, null )
     {
     }
 
-    public AsyncBlockExpression( ParameterExpression[] variables, Expression[] expressions )
+    internal AsyncBlockExpression(
+        ReadOnlyCollection<ParameterExpression> variables,
+        ReadOnlyCollection<Expression> expressions,
+        ReadOnlyCollection<ParameterExpression> externVariables
+    )
     {
-        if ( expressions == null || expressions.Length == 0 )
+        if ( expressions == null || expressions.Count == 0 )
             throw new ArgumentException( $"{nameof( AsyncBlockExpression )} must contain at least one expression.", nameof( expressions ) );
 
-        _variables = variables;
-        _expressions = expressions;
-        _resultType = _expressions[^1].Type;
-        _type = _resultType == typeof( void ) ? typeof( Task ) : typeof( Task<> ).MakeGenericType( _resultType );
+        Variables = variables;
+        Expressions = expressions;
+        ExternVariables = externVariables;
+
+        _taskType = GetTaskType( Result.Type );
     }
 
     public override bool CanReduce => true;
 
     public override ExpressionType NodeType => ExpressionType.Extension;
 
-    // ReSharper disable once ConvertToAutoProperty
-    public override Type Type => _type;
+    public override Type Type => _taskType;
 
     public override Expression Reduce()
     {
-        return _stateMachine ??= GenerateStateMachine( _resultType, _variables, _expressions );
+        return _stateMachine ??= StateMachineBuilder.Create( Result.Type, LoweringTransformer );
     }
 
-    private static Expression GenerateStateMachine( Type resultType, ParameterExpression[] variables, Expression[] expressions )
+    private LoweringInfo LoweringTransformer()
     {
-        var visitor = new LoweringVisitor();
-        var source = visitor.Transform( variables, expressions );
+        try
+        {
+            var visitor = new LoweringVisitor();
+
+            return visitor.Transform(
+                Result.Type,
+                [.. Variables],
+                [.. Expressions],
+                ExternVariables != null ? [.. ExternVariables] : []
+            );
+        }
+        catch ( LoweringException ex )
+        {
+            throw new InvalidOperationException( $"Unable to lower {nameof( AsyncBlockExpression )}.", ex );
+        }
+    }
 
-        if ( source.AwaitCount == 0 )
-            throw new InvalidOperationException( $"{nameof( AsyncBlockExpression )} must contain at least one await." );
+    protected override Expression VisitChildren( ExpressionVisitor visitor )
+    {
+        var newVariables = visitor.VisitAndConvert( Variables, nameof( VisitChildren ) );
+        var newExpressions = visitor.Visit( Expressions );
 
-        var stateMachine = StateMachineBuilder.Create( resultType, source );
+        if ( Compare( newVariables, Variables ) && Compare( newExpressions, Expressions ) )
+            return this;
 
-        return stateMachine;
+        return new AsyncBlockExpression( newVariables, newExpressions, ExternVariables );
+    }
+
+    internal static bool Compare<T>( ICollection<T> compare, IReadOnlyList<T> current )
+        where T : class
+    {
+        if ( ReferenceEquals( compare, current ) )
+            return true;
+
+        if ( compare == null )
+            return current.Count == 0;
+
+        if ( compare.Count != current.Count )
+            return false;
+
+        using var comparand = compare.GetEnumerator();
+
+        for ( var i = 0; i < current.Count; i++ )
+        {
+            comparand.MoveNext();
+
+            if ( !ReferenceEquals( comparand.Current, current[i] ) )
+                return false;
+        }
+
+        return true;
+    }
+
+    private static Type GetTaskType( Type resultType )
+    {
+        return resultType == typeof( void )
+            ? typeof( Task )
+            : typeof( Task<> ).MakeGenericType( resultType );
     }
 
     private class AsyncBlockExpressionDebuggerProxy( AsyncBlockExpression node )
     {
         public Expression StateMachine => node._stateMachine;
-        public Type ReturnType => node._resultType;
 
-        public Expression[] Expressions => node._expressions;
-        public ParameterExpression[] Variables => node._variables;
+        public ReadOnlyCollection<Expression> Expressions => node.Expressions;
+        public ReadOnlyCollection<ParameterExpression> Variables => node.Variables;
+        public Expression Result => node.Result;
     }
 }
 
@@ -69,12 +125,21 @@ public static partial class ExpressionExtensions
 {
     public static AsyncBlockExpression BlockAsync( params Expression[] expressions )
     {
-        return new AsyncBlockExpression( expressions );
+        return new AsyncBlockExpression( ReadOnlyCollection<ParameterExpression>.Empty, new ReadOnlyCollection<Expression>( expressions ) );
     }
 
     public static AsyncBlockExpression BlockAsync( ParameterExpression[] variables, params Expression[] expressions )
+    {
+        return new AsyncBlockExpression( new ReadOnlyCollection<ParameterExpression>( variables ), new ReadOnlyCollection<Expression>( expressions ) );
+    }
+
+    public static AsyncBlockExpression BlockAsync( ReadOnlyCollection<Expression> expressions )
+    {
+        return new AsyncBlockExpression( ReadOnlyCollection<ParameterExpression>.Empty, expressions );
+    }
+
+    public static AsyncBlockExpression BlockAsync( ReadOnlyCollection<ParameterExpression> variables, ReadOnlyCollection<Expression> expressions )
     {
         return new AsyncBlockExpression( variables, expressions );
     }
 }
-
diff --git a/src/Hyperbee.Expressions/AwaitExpression.cs b/src/Hyperbee.Expressions/AwaitExpression.cs
index 4d6c24b..519c29f 100644
--- a/src/Hyperbee.Expressions/AwaitExpression.cs
+++ b/src/Hyperbee.Expressions/AwaitExpression.cs
@@ -13,7 +13,6 @@ public class AwaitExpression : Expression
     internal AwaitExpression( Expression asyncExpression, bool configureAwait )
     {
         Target = asyncExpression ?? throw new ArgumentNullException( nameof( asyncExpression ) );
-
         ConfigureAwait = configureAwait;
     }
 
@@ -25,15 +24,13 @@ internal AwaitExpression( Expression asyncExpression, bool configureAwait )
 
     public bool ConfigureAwait { get; }
 
-    public AwaitBinder GetAwaitBinder() => AwaitBinderFactory.GetOrCreate( Target.Type );
+    internal AwaitBinder GetAwaitBinder() => AwaitBinderFactory.GetOrCreate( Target.Type );
 
     public override Expression Reduce()
     {
-        var awaitableType = Target.Type;
-        var awaitableInfo = AwaitBinderFactory.GetOrCreate( awaitableType );
+        var awaitableInfo = AwaitBinderFactory.GetOrCreate( Target.Type );
 
-        var reduced = Call( Constant( awaitableInfo ), awaitableInfo.AwaitMethod, Target, Constant( ConfigureAwait ) );
-        return reduced;
+        return Call( Constant( awaitableInfo ), awaitableInfo.WaitMethod, Target, Constant( ConfigureAwait ) );
     }
 
     private static Type ResultType( Type awaitableType )
@@ -59,6 +56,15 @@ private static Type ResultType( Type awaitableType )
         return awaiterInfo.GetResultMethod.ReturnType;
     }
 
+    protected override Expression VisitChildren( ExpressionVisitor visitor )
+    {
+        var newTarget = visitor.Visit( Target );
+
+        return newTarget == Target
+            ? this
+            : new AwaitExpression( newTarget, ConfigureAwait );
+    }
+
     internal static bool IsAwaitable( Type type )
     {
         return typeof( Task ).IsAssignableFrom( type ) || typeof( ValueTask ).IsAssignableFrom( type ) || AwaitBinderFactory.TryGetOrCreate( type, out _ );
@@ -75,9 +81,6 @@ public static partial class ExpressionExtensions
 {
     public static AwaitExpression Await( Expression expression, bool configureAwait = false )
     {
-        if ( expression is AsyncBlockExpression )
-            return new AwaitExpression( expression, configureAwait );
-
         if ( !AwaitExpression.IsAwaitable( expression.Type ) )
             throw new ArgumentException( "Expression must be awaitable.", nameof( expression ) );
 
diff --git a/src/Hyperbee.Expressions/DebugExpression.cs b/src/Hyperbee.Expressions/DebugExpression.cs
new file mode 100644
index 0000000..38310d6
--- /dev/null
+++ b/src/Hyperbee.Expressions/DebugExpression.cs
@@ -0,0 +1,62 @@
+using System.Linq.Expressions;
+
+namespace Hyperbee.Expressions;
+
+public class DebugExpression : Expression
+{
+    public Delegate DebugDelegate { get; }
+    public IReadOnlyList<Expression> Arguments { get; }
+    public Expression DebugCondition { get; }
+
+    public DebugExpression( Delegate debugDelegate, Expression condition, Expression[] arguments )
+    {
+        ArgumentNullException.ThrowIfNull( debugDelegate, nameof( debugDelegate ) );
+        ArgumentNullException.ThrowIfNull( arguments, nameof( arguments ) );
+
+        if ( condition != null && condition.Type != typeof( bool ) )
+            throw new ArgumentException( "Condition must be a boolean expression.", nameof( condition ) );
+
+        DebugDelegate = debugDelegate;
+        DebugCondition = condition;
+        Arguments = arguments.ToList();
+    }
+
+    public override Type Type => typeof( void );
+    public override ExpressionType NodeType => ExpressionType.Extension;
+    public override bool CanReduce => true;
+
+    public override Expression Reduce()
+    {
+        var delegateExpression = Constant( DebugDelegate );
+
+        if ( DebugCondition == null )
+        {
+            return Invoke( delegateExpression, Arguments );
+        }
+
+        return IfThen( DebugCondition, Invoke( delegateExpression, Arguments ) );
+    }
+}
+
+public static partial class ExpressionExtensions
+{
+    public static DebugExpression Debug( Delegate debugDelegate, Expression argument )
+    {
+        return new DebugExpression( debugDelegate, null, [argument] );
+    }
+
+    public static DebugExpression Debug( Delegate debugDelegate, Expression[] arguments )
+    {
+        return new DebugExpression( debugDelegate, null, arguments );
+    }
+
+    public static DebugExpression Debug( Delegate debugDelegate, Expression condition, Expression argument )
+    {
+        return new DebugExpression( debugDelegate, condition, [argument] );
+    }
+
+    public static DebugExpression Debug( Delegate debugDelegate, Expression condition, Expression[] arguments )
+    {
+        return new DebugExpression( debugDelegate, condition, arguments );
+    }
+}
diff --git a/src/Hyperbee.Expressions/ForEachExpression.cs b/src/Hyperbee.Expressions/ForEachExpression.cs
index 18bd01e..0cb8748 100644
--- a/src/Hyperbee.Expressions/ForEachExpression.cs
+++ b/src/Hyperbee.Expressions/ForEachExpression.cs
@@ -63,7 +63,7 @@ private static void ThrowIfInvalid( Expression collection, ParameterExpression e
         ArgumentNullException.ThrowIfNull( body, nameof( body ) );
 
         if ( !typeof( IEnumerable ).IsAssignableFrom( collection.Type ) )
-            throw new ArgumentException( "Collection must implement IEnumerable.", nameof( collection ) );
+            throw new ArgumentException( $"Collection must implement {nameof( IEnumerable )}.", nameof( collection ) );
     }
 
     public override Type Type => typeof( void );
@@ -98,12 +98,10 @@ protected override Expression VisitChildren( ExpressionVisitor visitor )
         var newCollection = visitor.Visit( Collection );
         var newBody = visitor.Visit( Body );
 
-        if ( newCollection != Collection || newBody != Body )
-        {
-            return new ForEachExpression( newCollection, Element, newBody, BreakLabel, ContinueLabel );
-        }
+        if ( newCollection == Collection && newBody == Body )
+            return this;
 
-        return this;
+        return new ForEachExpression( newCollection, Element, newBody, BreakLabel, ContinueLabel );
     }
 }
 
diff --git a/src/Hyperbee.Expressions/ForExpression.cs b/src/Hyperbee.Expressions/ForExpression.cs
index 5dcfdba..e2fae65 100644
--- a/src/Hyperbee.Expressions/ForExpression.cs
+++ b/src/Hyperbee.Expressions/ForExpression.cs
@@ -87,12 +87,11 @@ protected override Expression VisitChildren( ExpressionVisitor visitor )
         var newIteration = visitor.Visit( Iteration );
         var newBody = visitor.Visit( Body );
 
-        if ( newInitialization != Initialization || newTest != Test || newIteration != Iteration || newBody != Body )
-        {
-            return new ForExpression( newInitialization, newTest, newIteration, newBody, BreakLabel, ContinueLabel );
-        }
+        if ( newInitialization == Initialization && newTest == Test && newIteration == Iteration && newBody == Body )
+            return this;
+
+        return new ForExpression( newInitialization, newTest, newIteration, newBody, BreakLabel, ContinueLabel );
 
-        return this;
     }
 }
 
diff --git a/src/Hyperbee.Expressions/Hyperbee.Expressions.csproj b/src/Hyperbee.Expressions/Hyperbee.Expressions.csproj
index fc3909a..8843c77 100644
--- a/src/Hyperbee.Expressions/Hyperbee.Expressions.csproj
+++ b/src/Hyperbee.Expressions/Hyperbee.Expressions.csproj
@@ -1,16 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>disable</Nullable>
 
     <Authors>Stillpoint Software, Inc.</Authors>
+    <PackageId>Hyperbee.Expressions</PackageId>
     <PackageReadmeFile>README.md</PackageReadmeFile>
-    <PackageTags>expression-tree;expressions;async;await;</PackageTags>
+    <PackageTags>expression-tree;expressions;async;await;expression-extension;async-await;custom-expressions;dynamic-code;code-generation</PackageTags>
+
     <PackageIcon>icon.png</PackageIcon>
     <PackageProjectUrl>https://stillpoint-software.github.io/hyperbee.expressions/</PackageProjectUrl>
-    <TargetFrameworks>net8.0</TargetFrameworks>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <Copyright>Stillpoint Software, Inc.</Copyright>
     <Title>Hyperbee Expressions</Title>
@@ -37,7 +38,7 @@
     <None Include="..\..\assets\icon.png" Pack="true" Visible="false" PackagePath="/" />
     <None Include="..\..\README.md" Pack="true" Visible="true" PackagePath="/" Link="README.md" />
     <None Include="..\..\LICENSE" Pack="true" Visible="false" PackagePath="/" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.12.0" />
     <PackageReference Update="Microsoft.SourceLink.GitHub" Version="8.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/src/Hyperbee.Expressions/StringFormatExpression.cs b/src/Hyperbee.Expressions/StringFormatExpression.cs
new file mode 100644
index 0000000..f77426a
--- /dev/null
+++ b/src/Hyperbee.Expressions/StringFormatExpression.cs
@@ -0,0 +1,74 @@
+
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Hyperbee.Expressions;
+
+public class StringFormatExpression : Expression
+{
+    public Expression FormatProvider { get; }
+    public Expression Format { get; }
+    public IReadOnlyList<Expression> Arguments { get; }
+
+    private static readonly MethodInfo StringFormatMethod;
+
+    static StringFormatExpression()
+    {
+        StringFormatMethod = typeof( string ).GetMethod( "Format", [typeof( IFormatProvider ), typeof( string ), typeof( object[] )] );
+    }
+
+    internal StringFormatExpression( Expression formatProvider, Expression format, Expression[] arguments )
+    {
+        ArgumentNullException.ThrowIfNull( format, nameof( format ) );
+        ArgumentNullException.ThrowIfNull( arguments, nameof( arguments ) );
+
+        if ( format.Type != typeof( string ) )
+            throw new ArgumentException( "Format expression must be of type string.", nameof( format ) );
+
+        if ( formatProvider != null && !typeof( IFormatProvider ).IsAssignableFrom( formatProvider.Type ) )
+            throw new ArgumentException( "Format provider must implement IFormatProvider.", nameof( formatProvider ) );
+
+        FormatProvider = formatProvider ?? Constant( null, typeof( IFormatProvider ) );
+        Format = format;
+        Arguments = arguments.ToList();
+    }
+
+    public override Type Type => typeof( string );
+    public override ExpressionType NodeType => ExpressionType.Extension;
+    public override bool CanReduce => true;
+
+    public override Expression Reduce()
+    {
+        if ( !Arguments.Any() )
+            return Format;
+
+        var argsArrayExpression = NewArrayInit(
+            typeof( object ),
+            Arguments.Select( arg => Convert( arg, typeof( object ) ) )
+        );
+
+        if ( StringFormatMethod == null )
+            throw new InvalidOperationException( "string Format method not found." );
+
+        return Call( StringFormatMethod, FormatProvider, Format, argsArrayExpression );
+    }
+}
+
+public static partial class ExpressionExtensions
+{
+    public static StringFormatExpression StringFormat( Expression format, Expression argument )
+    {
+        return new StringFormatExpression( null, format, [argument] );
+    }
+
+    public static StringFormatExpression StringFormat( Expression format, Expression[] arguments )
+    {
+        return new StringFormatExpression( null, format, arguments );
+    }
+
+    public static StringFormatExpression StringFormat( Expression formatProvider, Expression format, Expression[] arguments )
+    {
+        return new StringFormatExpression( formatProvider, format, arguments );
+    }
+}
+
diff --git a/src/Hyperbee.Expressions/Transformation/AwaitBinder.cs b/src/Hyperbee.Expressions/Transformation/AwaitBinder.cs
index db98736..577c20e 100644
--- a/src/Hyperbee.Expressions/Transformation/AwaitBinder.cs
+++ b/src/Hyperbee.Expressions/Transformation/AwaitBinder.cs
@@ -6,9 +6,9 @@ namespace Hyperbee.Expressions.Transformation;
 internal delegate TAwaiter AwaitBinderGetAwaiterDelegate<TAwaitable, out TAwaiter>( ref TAwaitable awaitable, bool configureAwait );
 internal delegate TResult AwaitBinderGetResultDelegate<TAwaiter, out TResult>( ref TAwaiter awaiter );
 
-public class AwaitBinder
+internal class AwaitBinder
 {
-    public MethodInfo AwaitMethod { get; }
+    public MethodInfo WaitMethod { get; }
     public MethodInfo GetAwaiterMethod { get; }
     public MethodInfo GetResultMethod { get; }
 
@@ -16,13 +16,13 @@ public class AwaitBinder
     private Delegate GetResultImplDelegate { get; }
 
     internal AwaitBinder(
-        MethodInfo awaitMethod,
+        MethodInfo waitMethod,
         MethodInfo getAwaiterMethod,
         MethodInfo getResultMethod,
         Delegate getAwaiterImplDelegate = null,
         Delegate getResultImplDelegate = null )
     {
-        AwaitMethod = awaitMethod;
+        WaitMethod = waitMethod;
         GetAwaiterMethod = getAwaiterMethod;
         GetResultMethod = getResultMethod;
         GetAwaiterImplDelegate = getAwaiterImplDelegate;
@@ -32,7 +32,7 @@ internal AwaitBinder(
     // Await methods
 
     [MethodImpl( MethodImplOptions.AggressiveInlining )]
-    internal void Await<TAwaitable, TAwaiter>( ref TAwaitable awaitable, bool configureAwait )
+    internal void Wait<TAwaitable, TAwaiter>( ref TAwaitable awaitable, bool configureAwait )
     {
         switch ( awaitable )
         {
@@ -52,7 +52,7 @@ internal void Await<TAwaitable, TAwaiter>( ref TAwaitable awaitable, bool config
     }
 
     [MethodImpl( MethodImplOptions.AggressiveInlining )]
-    internal TResult AwaitResult<TAwaitable, TAwaiter, TResult>( ref TAwaitable awaitable, bool configureAwait )
+    internal TResult WaitResult<TAwaitable, TAwaiter, TResult>( ref TAwaitable awaitable, bool configureAwait )
     {
         switch ( awaitable )
         {
diff --git a/src/Hyperbee.Expressions/Transformation/AwaitBinderFactory.cs b/src/Hyperbee.Expressions/Transformation/AwaitBinderFactory.cs
index c1286a3..fabd175 100644
--- a/src/Hyperbee.Expressions/Transformation/AwaitBinderFactory.cs
+++ b/src/Hyperbee.Expressions/Transformation/AwaitBinderFactory.cs
@@ -13,10 +13,10 @@ internal static class AwaitBinderFactory
     const string GetAwaiterName = "GetAwaiter";
     const string ConfigureAwaitName = "ConfigureAwait";
 
-    // Pre-cached MethodInfo
+    // Cached reflection members
 
-    private static MethodInfo AwaitMethod;
-    private static MethodInfo AwaitResultMethod;
+    private static MethodInfo WaitMethod;
+    private static MethodInfo WaitResultMethod;
 
     private static MethodInfo GetAwaiterTaskMethod;
     private static MethodInfo GetAwaiterTaskResultMethod;
@@ -34,10 +34,17 @@ internal static class AwaitBinderFactory
     private static MethodInfo CreateGetAwaiterImplDelegateMethod;
     private static MethodInfo CreateGetResultImplDelegateMethod;
 
+    private static FieldInfo VoidResultInstance;
+
+    private sealed class VoidResult : IVoidResult
+    {
+        public static readonly VoidResult Instance = new();
+    }
+
     static AwaitBinderFactory()
     {
-        // Pre-cache MethodInfo to reduce reflection overhead
-        PreCacheMethodInfo();
+        // cache reflection member to reduce overhead
+        CacheReflectionMembers();
     }
 
     public static void Clear() => Cache.Clear();
@@ -64,10 +71,10 @@ private static AwaitBinder Create( Type awaitableType )
         {
             var awaitableTypeDefinition = awaitableType.GetGenericTypeDefinition();
 
-            if ( Reflection.OpenGenericIsOrInherits( typeof( Task<> ), awaitableTypeDefinition ) )
+            if ( ReflectionHelper.OpenGenericIsOrInherits( typeof( Task<> ), awaitableTypeDefinition ) )
                 return CreateGenericTaskAwaitBinder( awaitableType );
 
-            if ( Reflection.OpenGenericIsOrInherits( typeof( ValueTask<> ), awaitableTypeDefinition ) )
+            if ( ReflectionHelper.OpenGenericIsOrInherits( typeof( ValueTask<> ), awaitableTypeDefinition ) )
                 return CreateGenericValueTaskAwaitBinder( awaitableType );
         }
         else
@@ -90,7 +97,7 @@ private static AwaitBinder CreateGenericTaskAwaitBinder( Type awaitableType )
         var awaiterType = typeof( ConfiguredTaskAwaitable<>.ConfiguredTaskAwaiter ).MakeGenericType( awaiterResultType );
 
         return new AwaitBinder(
-            AwaitResultMethod.MakeGenericMethod( awaitableType, awaiterType, awaiterResultType ),
+            WaitResultMethod.MakeGenericMethod( awaitableType, awaiterType, awaiterResultType ),
             GetAwaiterTaskResultMethod.MakeGenericMethod( awaiterResultType ),
             GetResultTaskResultMethod.MakeGenericMethod( awaiterResultType ) );
     }
@@ -101,7 +108,7 @@ private static AwaitBinder CreateGenericValueTaskAwaitBinder( Type awaitableType
         var awaiterType = typeof( ConfiguredValueTaskAwaitable<>.ConfiguredValueTaskAwaiter ).MakeGenericType( awaiterResultType );
 
         return new AwaitBinder(
-            AwaitResultMethod.MakeGenericMethod( awaitableType, awaiterType, awaiterResultType ),
+            WaitResultMethod.MakeGenericMethod( awaitableType, awaiterType, awaiterResultType ),
             GetAwaiterValueTaskResultMethod.MakeGenericMethod( awaiterResultType ),
             GetResultValueTaskResultMethod.MakeGenericMethod( awaiterResultType ) );
     }
@@ -111,7 +118,7 @@ private static AwaitBinder CreateTaskAwaitBinder( Type awaitableType )
         var awaiterType = typeof( ConfiguredTaskAwaitable.ConfiguredTaskAwaiter );
 
         return new AwaitBinder(
-            AwaitMethod.MakeGenericMethod( awaitableType, awaiterType ),
+            WaitMethod.MakeGenericMethod( awaitableType, awaiterType ),
             GetAwaiterTaskMethod,
             GetResultTaskMethod );
     }
@@ -121,7 +128,7 @@ private static AwaitBinder CreateValueTaskAwaitBinder( Type awaitableType )
         var awaiterType = typeof( ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter );
 
         return new AwaitBinder(
-            AwaitMethod.MakeGenericMethod( awaitableType, awaiterType ),
+            WaitMethod.MakeGenericMethod( awaitableType, awaiterType ),
             GetAwaiterValueTaskMethod,
             GetResultValueTaskMethod );
     }
@@ -133,7 +140,7 @@ private static AwaitBinder CreateAwaitableTypeAwaitBinder( Type awaitableType )
         // Find GetAwaiter method
 
         var getAwaiterImplMethod = awaitableType.GetMethod( GetAwaiterName, bindingAttr )
-            ?? Reflection.FindExtensionMethod( awaitableType, GetAwaiterName )
+            ?? ReflectionHelper.FindExtensionMethod( awaitableType, GetAwaiterName )
             ?? throw new InvalidOperationException( $"The type {awaitableType} is not awaitable." );
 
         // Find GetResult method
@@ -151,7 +158,7 @@ private static AwaitBinder CreateAwaitableTypeAwaitBinder( Type awaitableType )
 
         // Get the AwaitBinder methods
 
-        MethodInfo awaitMethod;
+        MethodInfo waitMethod;
         MethodInfo getAwaiterMethod;
         MethodInfo getResultMethod;
 
@@ -159,13 +166,13 @@ private static AwaitBinder CreateAwaitableTypeAwaitBinder( Type awaitableType )
         {
             var awaiterResultType = awaiterType.GetGenericArguments()[0];
 
-            awaitMethod = AwaitResultMethod.MakeGenericMethod( awaitableType, awaiterType, awaiterResultType );
+            waitMethod = WaitResultMethod.MakeGenericMethod( awaitableType, awaiterType, awaiterResultType );
             getAwaiterMethod = GetAwaiterCustomMethod.MakeGenericMethod( awaitableType, awaiterType );
             getResultMethod = GetResultCustomResultMethod.MakeGenericMethod( awaiterType, awaiterResultType );
         }
         else
         {
-            awaitMethod = AwaitMethod.MakeGenericMethod( awaitableType, awaiterType );
+            waitMethod = WaitMethod.MakeGenericMethod( awaitableType, awaiterType );
             getAwaiterMethod = GetAwaiterCustomMethod.MakeGenericMethod( awaitableType, awaiterType );
             getResultMethod = GetResultCustomMethod.MakeGenericMethod( awaiterType );
         }
@@ -173,7 +180,7 @@ private static AwaitBinder CreateAwaitableTypeAwaitBinder( Type awaitableType )
         // Return the AwaitBinder
 
         return new AwaitBinder(
-            awaitMethod,
+            waitMethod,
             getAwaiterMethod,
             getResultMethod,
             getAwaiterImplDelegate,
@@ -275,38 +282,49 @@ private static Delegate CreateGetResultImplDelegate<TAwaiter, TResult>( MethodIn
         var il = dynamicMethod.GetILGenerator();
 
         il.Emit( OpCodes.Ldarg_0 );
-        il.Emit( OpCodes.Call, getResultImplMethod );
+        il.Emit( OpCodes.Ldind_Ref );
+
+        il.Emit( OpCodes.Callvirt, getResultImplMethod );
 
-        il.DeclareLocal( typeof( TResult ) );
-        il.Emit( OpCodes.Stloc_0 );
-        il.Emit( OpCodes.Ldloc_0 );
+        if ( typeof( TResult ) == typeof( IVoidResult ) )
+        {
+            il.Emit( OpCodes.Ldsfld, VoidResultInstance );
+        }
+        else
+        {
+            il.DeclareLocal( typeof( TResult ) );
+            il.Emit( OpCodes.Stloc_0 );
+            il.Emit( OpCodes.Ldloc_0 );
+        }
 
         il.Emit( OpCodes.Ret );
 
         return dynamicMethod.CreateDelegate( typeof( AwaitBinderGetResultDelegate<TAwaiter, TResult> ) );
     }
 
-    // Pre-Cache factory MethodInfos
-
-    private static void PreCacheMethodInfo()
+    private static void CacheReflectionMembers()
     {
+        // VoidResult
+
+        VoidResultInstance = typeof( VoidResult ).GetField( nameof( VoidResult.Instance ) );
+
         // Await methods
 
-        Reflection.GetMethods(
+        ReflectionHelper.GetMethods(
             typeof( AwaitBinder ),
             BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic,
             ( name, method, matches ) =>
             {
                 switch ( name )
                 {
-                    case nameof( AwaitBinder.Await )
+                    case nameof( AwaitBinder.Wait )
                         when matches( [null, typeof( bool )], argCount: 2 ):
-                        AwaitMethod = method;
+                        WaitMethod = method;
                         break;
 
-                    case nameof( AwaitBinder.AwaitResult )
+                    case nameof( AwaitBinder.WaitResult )
                         when matches( [null, typeof( bool )], argCount: 3 ):
-                        AwaitResultMethod = method;
+                        WaitResultMethod = method;
                         break;
 
                     case nameof( AwaitBinder.GetAwaiter )
@@ -369,7 +387,7 @@ when matches( [null], argCount: 2 ):
 
         // Delegate creation methods
 
-        Reflection.GetMethods(
+        ReflectionHelper.GetMethods(
             typeof( AwaitBinderFactory ),
             BindingFlags.Static | BindingFlags.NonPublic,
             ( name, method, matches ) =>
diff --git a/src/Hyperbee.Expressions/Transformation/DebugViewWriter.cs b/src/Hyperbee.Expressions/Transformation/DebugViewWriter.cs
deleted file mode 100644
index 6534c3d..0000000
--- a/src/Hyperbee.Expressions/Transformation/DebugViewWriter.cs
+++ /dev/null
@@ -1,342 +0,0 @@
-using System.Linq.Expressions;
-using System.Text;
-using Hyperbee.Expressions.Transformation.Transitions;
-
-namespace Hyperbee.Expressions.Transformation;
-
-internal static class DebugViewWriter
-{
-    private const string Indent1 = "\t";
-    private const string Indent2 = "\t\t";
-    private const string Indent3 = "\t\t\t";
-    private const string Indent4 = "\t\t\t\t";
-
-    public static void WriteTo( StringWriter writer, List<StateScope> scopes,
-        IEnumerable<ParameterExpression> variables )
-    {
-        // variables
-        var parameterExpressions = variables ?? [];
-
-        var variableCount = 0;
-
-        foreach ( var expr in parameterExpressions )
-        {
-            if ( variableCount++ == 0 )
-                writer.WriteLine( "Variables" );
-
-            writer.WriteLine( $"{Indent1}{VariableToString( expr )}" );
-        }
-
-        if ( variableCount > 0 )
-            writer.WriteLine();
-
-        // nodes
-        foreach ( var node in scopes.SelectMany( scope => scope.Nodes.Where( node => node != null ) ) )
-        {
-            // label
-            writer.WriteLine( $"{node.NodeLabel.Name}:" );
-
-            // expressions
-
-            if ( node.Expressions.Count > 0 )
-            {
-                writer.WriteLine( $"{Indent1}Expressions" );
-
-                foreach ( var expr in node.Expressions )
-                {
-                    writer.WriteLine( $"{Indent2}{ExpressionToString( expr )}" );
-                }
-            }
-
-            // transitions
-
-            writer.WriteLine( $"{Indent1}Transition" );
-            writer.WriteLine( TransitionToString( node.Transition ) );
-
-            // results
-
-            if ( node.ResultValue != null || node.ResultVariable != null )
-            {
-                writer.WriteLine( $"{Indent1}Result ({node.Type.Name})" );
-
-                if ( node.ResultValue != null )
-                    writer.WriteLine( $"{Indent2}Value: {node.ResultValue}" );
-
-                if ( node.ResultVariable != null )
-                    writer.WriteLine( $"{Indent2}Variable: {node.ResultVariable}" );
-            }
-
-            writer.WriteLine();
-        }
-    }
-
-    private static string TransitionToString( Transition transition )
-    {
-        if ( transition == null )
-            return $"{Indent2}Exit";
-
-        var builder = new StringBuilder();
-        builder.AppendLine( $"{Indent2}{transition.GetType().Name}" );
-
-        switch ( transition )
-        {
-            case ConditionalTransition conditional:
-                builder.AppendLine( $"{Indent3}Test: {ExpressionToString( conditional.Test )}" );
-                builder.AppendLine( $"{Indent3}IfTrue: {ExpressionToString( conditional.IfTrue )}" );
-                builder.AppendLine( $"{Indent3}IfFalse: {ExpressionToString( conditional.IfFalse )}" );
-                break;
-
-            case GotoTransition gotoTransition:
-                builder.AppendLine( $"{Indent3}Target: {gotoTransition.TargetNode.NodeLabel.Name}" );
-                break;
-
-            case AwaitTransition awaitTransition:
-                builder.AppendLine( $"{Indent3}Completion: {awaitTransition.CompletionNode.NodeLabel.Name}" );
-                break;
-
-            case AwaitResultTransition awaitResultTransition:
-                builder.AppendLine( $"{Indent3}Target: {awaitResultTransition.TargetNode.NodeLabel.Name}" );
-                break;
-
-            case LoopTransition loopTransition:
-                builder.AppendLine( $"{Indent3}Body: {ExpressionToString( loopTransition.BodyNode )}" );
-                break;
-
-            case SwitchTransition switchTransition:
-                builder.AppendLine( $"{Indent3}SwitchValue: {ExpressionToString( switchTransition.SwitchValue )}" );
-                foreach ( var caseDefinition in switchTransition.CaseNodes )
-                {
-                    builder.AppendLine( $"{Indent4}Test: {string.Join( ",", caseDefinition.TestValues )}" );
-                    builder.AppendLine( $"{Indent4}Body: {ExpressionToString( caseDefinition.Body )}" );
-                }
-
-                break;
-
-            case TryCatchTransition tryCatchTransition:
-                builder.AppendLine( $"{Indent3}Try: {ExpressionToString( tryCatchTransition.TryNode )}" );
-                builder.AppendLine( $"{Indent3}Finally: {ExpressionToString( tryCatchTransition.FinallyNode )}" );
-
-                foreach ( var catchBlockDefinition in tryCatchTransition.CatchBlocks )
-                {
-                    builder.AppendLine( $"{Indent4}Catch: {catchBlockDefinition.Handler.Test.Name}" );
-                    builder.AppendLine( $"{Indent4}Body: {ExpressionToString( catchBlockDefinition.Handler.Body )}" );
-                }
-
-                break;
-        }
-
-        return builder.ToString();
-    }
-
-    private static string ExpressionToString( Expression expr )
-    {
-        return expr switch
-        {
-            BinaryExpression binary => FormatBinaryExpression( binary ),
-            MethodCallExpression methodCall => FormatMethodCallExpression( methodCall ),
-            ConstantExpression constant => FormatConstantExpression( constant ),
-            ParameterExpression param => FormatParameterExpression( param ),
-            LabelExpression label => FormatLabelExpression( label ),
-            ConditionalExpression conditional => FormatConditionalExpression( conditional ),
-            LambdaExpression lambda => FormatLambdaExpression( lambda ),
-            UnaryExpression unary => FormatUnaryExpression( unary ),
-            MemberExpression member => FormatMemberExpression( member ),
-            SwitchExpression cases => FormatSwitchExpression( cases ),
-            LoopExpression loop => FormatLoopExpression( loop ),
-            BlockExpression block => FormatBlockExpression( block ),
-            NodeExpression node => FormatNodeExpression( node ),
-            null => "null",
-            _ => expr.ToString()
-        };
-    }
-
-    private static string FormatNodeExpression( NodeExpression node )
-    {
-        return $"node {node.NodeLabel.Name}";
-    }
-
-    private static string FormatBlockExpression( BlockExpression block )
-    {
-        var builder = new StringBuilder();
-        builder.Append( "block" );
-        builder.AppendLine();
-
-        foreach ( var blockExpression in block.Expressions )
-        {
-            builder.Append( Indent3 );
-            builder.Append( ExpressionToString( blockExpression ) );
-            builder.AppendLine();
-        }
-
-        return builder.ToString();
-    }
-
-    private static string FormatBinaryExpression( BinaryExpression binary )
-    {
-        return $"{binary.Left} {GetBinaryOperator( binary.NodeType )} {binary.Right}";
-    }
-
-    private static string FormatConditionalExpression( ConditionalExpression conditional )
-    {
-        var test = ExpressionToString( conditional.Test );
-        var ifTrue = ExpressionToString( conditional.IfTrue );
-        var ifFalse = ExpressionToString( conditional.IfFalse );
-
-        return $"if ({test}) {{ {ifTrue} }} else {{ {ifFalse} }}";
-    }
-
-    private static string FormatConstantExpression( ConstantExpression constant )
-    {
-        switch ( constant.Value )
-        {
-            case string stringValue:
-                return $"Constant String \"{stringValue}\"";
-
-            default:
-                {
-                    var typeName = constant.Type.Name;
-                    return $"Constant {typeName} {constant.Value}";
-                }
-        }
-    }
-
-    private static string FormatLabelExpression( LabelExpression label )
-    {
-        return $"Label {label.Target.Name}";
-    }
-
-    private static string FormatLambdaExpression( LambdaExpression lambda )
-    {
-        var parameters = string.Join( ", ", lambda.Parameters.Select( p => p.Name ) );
-        var body = ExpressionToString( lambda.Body );
-
-        return $"Lambda ({parameters}) => {body}";
-    }
-
-    private static string FormatLoopExpression( LoopExpression loop )
-    {
-        var builder = new StringBuilder();
-
-        builder.AppendLine( $"loop => {ExpressionToString( loop.Body )}" );
-        builder.Append( Indent2 );
-        builder.AppendLine( $"break: {loop.BreakLabel?.Name}" );
-        builder.Append( Indent2 );
-        builder.AppendLine( $"continue: {loop.ContinueLabel?.Name}" );
-
-        return builder.ToString();
-    }
-
-    private static string FormatMemberExpression( MemberExpression member )
-    {
-        return $"{member.Expression}.{member.Member.Name}";
-    }
-
-    private static string FormatMethodCallExpression( MethodCallExpression methodCall )
-    {
-        var declaringTypeName = methodCall.Method.DeclaringType?.Name;
-        var methodName = methodCall.Method.Name;
-        var arguments = string.Join( ", ", methodCall.Arguments.Select( ExpressionToString ) );
-
-        return $"{declaringTypeName}.{methodName}({arguments})";
-    }
-
-    private static string FormatParameterExpression( ParameterExpression param )
-    {
-        return $"{param.Type.Name} {param.Name}";
-    }
-
-    private static string FormatSwitchExpression( SwitchExpression switchExpr )
-    {
-        var builder = new StringBuilder();
-
-        builder.Append( $"switch ({ExpressionToString( switchExpr.SwitchValue )})" );
-
-        foreach ( var caseExpr in switchExpr.Cases )
-        {
-            var caseValues = string.Join( ", ", caseExpr.TestValues.Select( ExpressionToString ) );
-
-            builder.AppendLine();
-            builder.Append( Indent3 );
-            builder.Append( $"case {caseValues}:" );
-            builder.AppendLine();
-            builder.Append( Indent4 );
-            builder.Append( ExpressionToString( caseExpr.Body ) );
-        }
-
-        if ( switchExpr.DefaultBody != null )
-        {
-            builder.AppendLine();
-            builder.Append( Indent3 );
-            builder.Append( "default:" );
-            builder.AppendLine();
-            builder.Append( Indent4 );
-            builder.Append( ExpressionToString( switchExpr.DefaultBody ) );
-        }
-
-        return builder.ToString();
-
-    }
-
-    private static string FormatUnaryExpression( UnaryExpression unary )
-    {
-        return $"{GetUnaryOperator( unary.NodeType )}({ExpressionToString( unary.Operand )})";
-    }
-
-    private static string GetBinaryOperator( ExpressionType nodeType )
-    {
-        return nodeType switch
-        {
-            ExpressionType.Add => "+",
-            ExpressionType.Subtract => "-",
-            ExpressionType.Multiply => "*",
-            ExpressionType.Divide => "/",
-            ExpressionType.Modulo => "%",
-            ExpressionType.AndAlso => "&&",
-            ExpressionType.OrElse => "||",
-            ExpressionType.Equal => "==",
-            ExpressionType.NotEqual => "!=",
-            ExpressionType.GreaterThan => ">",
-            ExpressionType.GreaterThanOrEqual => ">=",
-            ExpressionType.LessThan => "<",
-            ExpressionType.LessThanOrEqual => "<=",
-            ExpressionType.Assign => "=",
-            ExpressionType.AddAssign => "+=",
-            ExpressionType.SubtractAssign => "-=",
-            ExpressionType.MultiplyAssign => "*=",
-            ExpressionType.DivideAssign => "/=",
-            ExpressionType.ModuloAssign => "%=",
-            _ => nodeType.ToString()
-        };
-    }
-
-    private static string GetUnaryOperator( ExpressionType nodeType )
-    {
-        return nodeType switch
-        {
-            ExpressionType.Negate => "-",
-            ExpressionType.Not => "!",
-            ExpressionType.Increment => "++",
-            ExpressionType.Decrement => "--",
-            ExpressionType.UnaryPlus => "+",
-            _ => nodeType.ToString()
-        };
-    }
-
-    private static string VariableToString( ParameterExpression expr )
-    {
-        return $"{TypeToString( expr.Type )} {expr.Name}";
-
-        static string TypeToString( Type type )
-        {
-            return type switch
-            {
-                null => "null",
-                { IsGenericType: true } => $"{type.Name.Split( '`' )[0]}<{string.Join( ", ", type.GetGenericArguments().Select( TypeToString ) )}>",
-                { IsArray: true } => $"{TypeToString( type.GetElementType() )}[]",
-                { IsByRef: true } => $"{TypeToString( type.GetElementType() )}&",
-                { IsPointer: true } => $"{TypeToString( type.GetElementType() )}*",
-                { IsGenericType: false } => type.Name
-            };
-        }
-    }
-}
diff --git a/src/Hyperbee.Expressions/Transformation/HoistingVisitor.cs b/src/Hyperbee.Expressions/Transformation/HoistingVisitor.cs
deleted file mode 100644
index ea40c4a..0000000
--- a/src/Hyperbee.Expressions/Transformation/HoistingVisitor.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-using System.Linq.Expressions;
-
-namespace Hyperbee.Expressions.Transformation;
-
-internal class HoistingVisitor : ExpressionVisitor, IHoistingSource
-{
-    private readonly IReadOnlyDictionary<string, MemberExpression> _mappingCache;
-
-    public ParameterExpression StateMachine { get; init; }
-
-    public LabelTarget ExitLabel { get; init; }
-    public MemberExpression StateIdField { get; init; }
-    public MemberExpression BuilderField { get; init; }
-    public MemberExpression ResultField { get; init; }
-    public ParameterExpression ReturnValue { get; init; }
-
-    public HoistingVisitor(
-        ParameterExpression stateMachine,
-        IReadOnlyDictionary<string, MemberExpression> fields,
-        MemberExpression stateIdField,
-        MemberExpression builderField,
-        MemberExpression resultField,
-        LabelTarget exitLabel,
-        ParameterExpression returnValue )
-    {
-        StateMachine = stateMachine;
-        ExitLabel = exitLabel;
-        StateIdField = stateIdField;
-        BuilderField = builderField;
-        ResultField = resultField;
-        ReturnValue = returnValue;
-
-        _mappingCache = fields;
-    }
-
-    protected override Expression VisitParameter( ParameterExpression node )
-    {
-        var name = node.Name ?? node.ToString();
-
-        if ( !_mappingCache.TryGetValue( name, out var fieldAccess ) )
-            return node;
-
-        return fieldAccess;
-    }
-
-    protected override Expression VisitBlock( BlockExpression node )
-    {
-        // Update each expression in a block to use only state machine fields/variables
-        return node.Update(
-            node.Variables.Where( x => !_mappingCache.ContainsKey( x.Name ?? x.ToString() ) ),
-            node.Expressions.Select( Visit )
-        );
-    }
-
-    protected override Expression VisitExtension( Expression node )
-    {
-        return node switch
-        {
-            AwaitExpression awaitExpression => Visit( awaitExpression.Target )!,
-            NodeExpression stateNode => Visit( stateNode.Reduce( this ) ),
-            _ => base.VisitExtension( node )
-        } ?? Expression.Empty();
-    }
-}
diff --git a/src/Hyperbee.Expressions/Transformation/IHoistingSource.cs b/src/Hyperbee.Expressions/Transformation/IHoistingSource.cs
deleted file mode 100644
index e28fe36..0000000
--- a/src/Hyperbee.Expressions/Transformation/IHoistingSource.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System.Linq.Expressions;
-
-namespace Hyperbee.Expressions.Transformation;
-
-internal interface IHoistingSource
-{
-    public ParameterExpression StateMachine { get; init; }
-
-    LabelTarget ExitLabel { get; init; }
-    MemberExpression StateIdField { get; init; }
-    MemberExpression BuilderField { get; init; }
-    MemberExpression ResultField { get; init; }
-    ParameterExpression ReturnValue { get; init; }
-
-    public void Deconstruct(
-        out ParameterExpression stateMachine,
-        out LabelTarget exitLabel,
-        out MemberExpression stateIdField, out MemberExpression builderField,
-        out MemberExpression resultField, out ParameterExpression returnValue )
-    {
-        stateMachine = StateMachine;
-        exitLabel = ExitLabel;
-        stateIdField = StateIdField;
-        builderField = BuilderField;
-        resultField = ResultField;
-        returnValue = ReturnValue;
-    }
-}
diff --git a/src/Hyperbee.Expressions/Transformation/IStateNode.cs b/src/Hyperbee.Expressions/Transformation/IStateNode.cs
new file mode 100644
index 0000000..14f5697
--- /dev/null
+++ b/src/Hyperbee.Expressions/Transformation/IStateNode.cs
@@ -0,0 +1,22 @@
+using System.Linq.Expressions;
+using Hyperbee.Expressions.Transformation.Transitions;
+
+namespace Hyperbee.Expressions.Transformation;
+
+internal interface IStateNode
+{
+    public int StateId { get; }
+    public int GroupId { get; }
+    public int ScopeId { get; }
+
+    public int StateOrder { get; set; }
+
+    public StateResult Result { get; }
+
+    public LabelTarget NodeLabel { get; }
+    public List<Expression> Expressions { get; }
+
+    public Transition Transition { get; }
+
+    public Expression GetExpression( StateMachineContext context );
+}
diff --git a/src/Hyperbee.Expressions/Transformation/JumpTableBuilder.cs b/src/Hyperbee.Expressions/Transformation/JumpTableBuilder.cs
index 02cc9b1..53a6508 100644
--- a/src/Hyperbee.Expressions/Transformation/JumpTableBuilder.cs
+++ b/src/Hyperbee.Expressions/Transformation/JumpTableBuilder.cs
@@ -1,90 +1,76 @@
 using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
 
 namespace Hyperbee.Expressions.Transformation;
 
 internal static class JumpTableBuilder
 {
-    public static Expression Build( StateScope current, List<StateScope> scopes, Expression stateField )
+    public static Expression Build( StateContext.Scope current, IReadOnlyList<StateContext.Scope> scopes, Expression stateField )
     {
         var jumpCases = current.JumpCases;
         var jumpTable = new List<SwitchCase>( jumpCases.Count );
 
-        for ( var index = 0; index < jumpCases.Count; index++ )
+        foreach ( var jumpCase in jumpCases )
         {
-            var jumpCase = jumpCases[index];
-
             // Go to the result of awaiter
-            var resultJumpExpression = Expression.SwitchCase(
-                Expression.Block(
-                    Expression.Assign( stateField, Expression.Constant( -1 ) ),
-                    Expression.Goto( jumpCase.ResultLabel )
+
+            var resultJumpExpression = SwitchCase(
+                Block(
+                    Assign( stateField, Constant( -1 ) ),
+                    Goto( jumpCase.ResultLabel )
                 ),
-                Expression.Constant( jumpCase.StateId )
+                Constant( jumpCase.StateId )
             );
 
             jumpTable.Add( resultJumpExpression );
+        }
 
-            // Go to nested jump cases
+        // Loop over scopes and flatten; nested by parent
 
-            var testValues = JumpCaseTests( current, jumpCase.StateId, scopes );
+        foreach ( var childScope in scopes.Where( x => x.Parent == current ) )
+        {
+            var testValues = GetNestedTestValues( childScope, scopes );
 
             if ( testValues.Count <= 0 )
                 continue;
 
-            var nestedJumpExpression = Expression.SwitchCase(
-                Expression.Block(
-                    Expression.Assign( stateField, Expression.Constant( -1 ) ),
-                    Expression.Goto( jumpCase.ContinueLabel )
-                ),
+            var nestedJumpExpression = SwitchCase(
+                Goto( childScope.InitialLabel ),
                 testValues
             );
 
             jumpTable.Add( nestedJumpExpression );
         }
 
-        return Expression.Switch(
+        return Switch(
             stateField,
-            Expression.Empty(),
+            Empty(),
             [.. jumpTable]
         );
     }
 
-    // Iterative function to build jump table cases
-    private static List<Expression> JumpCaseTests( StateScope scope, int stateId, List<StateScope> scopes )
+    private static List<ConstantExpression> GetNestedTestValues( StateContext.Scope current, IReadOnlyList<StateContext.Scope> scopes )
     {
-        var testValues = new List<Expression>();
-        var stack = new Stack<(StateScope, int)>();
+        var testCases = current.JumpCases.Select( jumpCase => Constant( jumpCase.StateId ) ).ToList();
+        var stack = new Stack<StateContext.Scope>();
 
         while ( true )
         {
-            for ( var scopeIndex = 0; scopeIndex < scopes.Count; scopeIndex++ )
+            foreach ( var child in scopes.Where( scope => scope.Parent == current ) )
             {
-                var nestedScope = scopes[scopeIndex];
-
-                if ( nestedScope.Parent != scope )
-                    continue;
-
-                for ( var jumpIndex = 0; jumpIndex < nestedScope.JumpCases.Count; jumpIndex++ )
-                {
-                    var childJumpCase = nestedScope.JumpCases[jumpIndex];
-
-                    if ( childJumpCase.ParentId != stateId )
-                        continue;
-
-                    // Return self
-                    testValues.Add( Expression.Constant( childJumpCase.StateId ) );
-
-                    // Push nested jump cases onto the stack
-                    stack.Push( (nestedScope, childJumpCase.StateId) );
-                }
+                stack.Push( child );
             }
 
-            if ( !stack.TryPop( out var item ) )
+            if ( !stack.TryPop( out current ) )
                 break;
 
-            (scope, stateId) = item;
+            foreach ( var jumpCase in current.JumpCases )
+            {
+                testCases.Add( Constant( jumpCase.StateId ) );
+            }
         }
 
-        return testValues;
+        return testCases;
     }
+
 }
diff --git a/src/Hyperbee.Expressions/Transformation/LoweringException.cs b/src/Hyperbee.Expressions/Transformation/LoweringException.cs
new file mode 100644
index 0000000..2342859
--- /dev/null
+++ b/src/Hyperbee.Expressions/Transformation/LoweringException.cs
@@ -0,0 +1,6 @@
+namespace Hyperbee.Expressions.Transformation;
+
+internal class LoweringException : Exception
+{
+    public LoweringException( string message ) : base( message ) { }
+}
diff --git a/src/Hyperbee.Expressions/Transformation/LoweringResult.cs b/src/Hyperbee.Expressions/Transformation/LoweringResult.cs
deleted file mode 100644
index 2a148f5..0000000
--- a/src/Hyperbee.Expressions/Transformation/LoweringResult.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using System.Globalization;
-using System.Linq.Expressions;
-
-namespace Hyperbee.Expressions.Transformation;
-
-public record LoweringResult
-{
-    public List<StateScope> Scopes { get; init; }
-    public ParameterExpression ReturnValue { get; init; }
-    public int AwaitCount { get; init; }
-    public ParameterExpression[] Variables { get; init; }
-
-    internal string DebugView
-    {
-        get
-        {
-            using StringWriter writer = new StringWriter( CultureInfo.CurrentCulture );
-            DebugViewWriter.WriteTo( writer, Scopes, Variables );
-            return writer.ToString();
-        }
-    }
-}
diff --git a/src/Hyperbee.Expressions/Transformation/LoweringVisitor.cs b/src/Hyperbee.Expressions/Transformation/LoweringVisitor.cs
index dfe1fa1..5364347 100644
--- a/src/Hyperbee.Expressions/Transformation/LoweringVisitor.cs
+++ b/src/Hyperbee.Expressions/Transformation/LoweringVisitor.cs
@@ -1,70 +1,95 @@
 using System.Linq.Expressions;
 using System.Runtime.CompilerServices;
 using Hyperbee.Expressions.Transformation.Transitions;
+using Hyperbee.Expressions.Visitors;
 
 namespace Hyperbee.Expressions.Transformation;
 
 internal class LoweringVisitor : ExpressionVisitor
 {
-    private const int InitialCapacity = 8;
+    private const int InitialCapacity = 4;
+
+    private ParameterExpression _finalResultVariable;
+    private bool _hasFinalResultVariable;
 
-    private ParameterExpression _returnValue;
-    private ParameterExpression[] _definedVariables;
-    private readonly Dictionary<int, ParameterExpression> _variables = new( InitialCapacity );
     private int _awaitCount;
 
     private readonly StateContext _states = new( InitialCapacity );
-    private readonly Dictionary<LabelTarget, Expression> _labels = [];
+    private readonly ExpressionMatcher _expressionMatcher = new( expr => expr is AwaitExpression || expr is AsyncBlockExpression );
 
-    private int _variableId;
+    private VariableResolver _variableResolver;
 
-    private static class VariableName
+    public LoweringInfo Transform( Type resultType, ParameterExpression[] variables, Expression[] expressions, ParameterExpression[] externVariables )
     {
-        // use special names to prevent collisions
-        [MethodImpl( MethodImplOptions.AggressiveInlining )]
-        public static string Awaiter( int stateId ) => $"__awaiter<{stateId}>";
-
-        [MethodImpl( MethodImplOptions.AggressiveInlining )]
-        public static string Result( int stateId ) => $"__result<{stateId}>";
-
-        [MethodImpl( MethodImplOptions.AggressiveInlining )]
-        public static string Try( int stateId ) => $"__try<{stateId}>";
+        ArgumentNullException.ThrowIfNull( expressions, nameof( expressions ) );
+        ArgumentOutOfRangeException.ThrowIfZero( expressions.Length, nameof( expressions ) );
 
-        [MethodImpl( MethodImplOptions.AggressiveInlining )]
-        public static string Exception( int stateId ) => $"__ex<{stateId}>";
+        _variableResolver = new VariableResolver( variables, _states );
+        _finalResultVariable = CreateFinalResultVariable( resultType, _variableResolver );
 
-        [MethodImpl( MethodImplOptions.AggressiveInlining )]
-        public static string Variable( string name, int stateId, ref int variableId ) => $"__{name}<{stateId}_{variableId++}>";
-
-        public const string Return = "return<>";
-    }
+        VisitExpressions( expressions );
 
-    public LoweringResult Transform( ParameterExpression[] variables, params Expression[] expressions )
-    {
-        _definedVariables = variables;
+        StateOptimizer.Optimize( _states );
 
-        VisitExpressions( expressions );
+        ThrowIfInvalid();
 
-        return new LoweringResult
+        return new LoweringInfo
         {
             Scopes = _states.Scopes,
-            ReturnValue = _returnValue,
+            HasFinalResultVariable = _hasFinalResultVariable,
             AwaitCount = _awaitCount,
-            Variables = _variables.Select( x => x.Value ).ToArray()
+            Variables = _variableResolver.GetMappedVariables(),
+            ExternVariables = externVariables
         };
-    }
 
-    public LoweringResult Transform( params Expression[] expressions )
-    {
-        return Transform( [], expressions );
+        // helpers
+
+        void ThrowIfInvalid()
+        {
+            if ( _states.Scopes[0].States.Count == 0 )
+                throw new LoweringException( $"Evaluation of the {nameof( expressions )} parameter resulted in empty states." );
+
+            if ( _awaitCount == 0 )
+                throw new LoweringException( $"The {nameof( expressions )} parameter must contain at least one awaitable." );
+        }
+
+        static ParameterExpression CreateFinalResultVariable( Type resultType, VariableResolver resolver )
+        {
+            var finalResultType = resultType == typeof( void )
+                ? typeof( IVoidResult )
+                : resultType;
+
+            return resolver.GetFinalResult( finalResultType );
+        }
     }
 
     // Visit methods
 
-    private NodeExpression VisitBranch( Expression expression, NodeExpression joinState,
-        ParameterExpression resultVariable = null,
-        Action<NodeExpression> init = null,
-        bool capture = true )
+    private void VisitExpressions( IEnumerable<Expression> expressions )
+    {
+        foreach ( var expression in expressions )
+        {
+            var updateNode = Visit( expression ); // Warning: visitation mutates the tail state.
+            UpdateTailState( updateNode );
+        }
+
+        // update the final state
+
+        var tailState = _states.TailState;
+
+        if ( !_hasFinalResultVariable )
+        {
+            // assign the final result variable if not already assigned for state-machine builder.
+            // this is the case when the last expression is not a return statement.
+            // this will ensure that the state-machine builder will have a final result field.
+
+            tailState.Result.Variable = _finalResultVariable;
+        }
+
+        tailState.Transition = new FinalTransition();
+    }
+
+    private StateExpression VisitBranch( Expression expression, StateExpression joinState, Expression resultVariable = null, Action<StateExpression> init = null )
     {
         // Create a new state for the branch
 
@@ -76,69 +101,117 @@ private NodeExpression VisitBranch( Expression expression, NodeExpression joinSt
 
         var updateNode = Visit( expression ); // Warning: visitation mutates the tail state.
 
-        var tailState = _states.TailState;
-
-        // If the expression is not explicitly handled
-        // by the visitor, add it to the tail state.
+        UpdateTailState( updateNode, joinState ?? branchState ); // if no join-state, join to the branch-state (e.g. loops)
 
-        if ( capture && !IsExplicitlyHandledType( expression ) )
-            tailState.Expressions.Add( updateNode );
+        _states.TailState.Result.Variable = resultVariable;
 
-        // Set a default Transition if the branch tail didn't join
+        return branchState;
+    }
 
-        tailState.ResultVariable = resultVariable;
+    private void UpdateTailState( Expression visited, StateExpression defaultTarget = null )
+    {
+        var tailState = _states.TailState;
 
-        if ( tailState.Transition != null )
-            return branchState;
+        // add unhandled the expressions to the tail state
 
-        tailState.Transition = new GotoTransition { TargetNode = joinState };
+        if ( visited is not StateExpression )
+        {
+            tailState.Expressions.Add( visited );
+        }
 
-        return branchState;
-    }
+        // transition handling
 
-    private void VisitExpressions( IEnumerable<Expression> expressions )
-    {
-        foreach ( var expression in expressions )
+        if ( tailState.Transition != null )
         {
-            var visited = Visit( expression ); // Warning: visitation mutates the tail state.
+            return;
+        }
 
-            // If the expression is not explicitly handled
-            // by the visitor, add it to the tail state.
+        if ( visited is GotoExpression gotoExpression && _states.TryGetLabelTarget( gotoExpression.Target, out var targetNode ) )
+        {
+            tailState.Transition = new GotoTransition { TargetNode = targetNode };
+        }
 
-            if ( !IsExplicitlyHandledType( expression ) )
-                _states.TailState.Expressions.Add( visited );
+        if ( defaultTarget != null )
+        {
+            tailState.Transition = new GotoTransition { TargetNode = defaultTarget };
         }
     }
 
-    private static bool IsExplicitlyHandledType( Expression expr )
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    private bool RequiresLowering( Expression node )
     {
-        // These expression types are explicitly handled by the visitor.
-
-        return expr
-            is BlockExpression
-            or ConditionalExpression
-            or SwitchExpression
-            or TryExpression
-            or AwaitExpression
-            or AsyncBlockExpression
-            or LoopExpression;
+        return _expressionMatcher.HasMatch( node );
     }
 
     // Override methods for specific expression types
 
+    protected override Expression VisitLambda<T>( Expression<T> node )
+    {
+        // Lambda expressions should not be lowered with this visitor.
+        // But we still need to track the variables used in the lambda.
+        return _variableResolver.Resolve( node );
+    }
+
     protected override Expression VisitBlock( BlockExpression node )
     {
-        VisitExpressions( node.Expressions );
-        return node;
+        if ( !RequiresLowering( node ) )
+            return _variableResolver.Resolve( node );
+
+        var joinState = _states.EnterGroup( out var sourceState );
+
+        var resultVariable = _variableResolver.GetResultVariable( node, sourceState.StateId );
+
+        _variableResolver.AddLocalVariables( node.Variables );
+
+        var currentSource = sourceState;
+        StateExpression firstGoto = null;
+
+        StateExpression previousTail = null;
+        Expression previousVariable = resultVariable;
+
+        foreach ( var expression in node.Expressions )
+        {
+            if ( RequiresLowering( expression ) )
+            {
+                var updated = VisitBranch( expression, joinState, resultVariable ); // Warning: visitation mutates the tail state.
+
+                previousVariable = updated.Result.Variable;
+                joinState.Result.Variable = previousVariable;
+
+                // Fix tail link list of Transitions.
+                if ( previousTail != null )
+                    previousTail.Transition = new GotoTransition { TargetNode = updated };
+
+                firstGoto ??= updated;
+                currentSource = _states.TailState;
+                previousTail = _states.TailState;
+            }
+            else
+            {
+                currentSource.Expressions.Add( _variableResolver.Resolve( Visit( expression ) ) );
+            }
+        }
+
+        var blockTransition = new GotoTransition { TargetNode = firstGoto ?? joinState };
+
+        sourceState.Result.Variable = previousVariable;
+        joinState.Result.Value = previousVariable;
+
+        _states.ExitGroup( sourceState, blockTransition );
+
+        return sourceState;
     }
 
     protected override Expression VisitConditional( ConditionalExpression node )
     {
+        if ( !RequiresLowering( node ) )
+            return _variableResolver.Resolve( node );
+
         var updatedTest = base.Visit( node.Test );
 
         var joinState = _states.EnterGroup( out var sourceState );
 
-        var resultVariable = GetResultVariable( node, sourceState.StateId );
+        var resultVariable = _variableResolver.GetResultVariable( node, sourceState.StateId );
 
         var conditionalTransition = new ConditionalTransition
         {
@@ -149,8 +222,8 @@ protected override Expression VisitConditional( ConditionalExpression node )
                 : joinState,
         };
 
-        sourceState.ResultVariable = resultVariable;
-        joinState.ResultValue = resultVariable;
+        sourceState.Result.Variable = resultVariable;
+        joinState.Result.Value = resultVariable;
 
         _states.ExitGroup( sourceState, conditionalTransition );
 
@@ -159,79 +232,68 @@ protected override Expression VisitConditional( ConditionalExpression node )
 
     protected override Expression VisitGoto( GotoExpression node )
     {
-        if ( _labels.TryGetValue( node.Target, out var labelExpression ) )
-        {
-            return labelExpression;
-        }
+        if ( _variableResolver.TryResolveLabel( node, out var label ) )
+            return label;
 
         var updateNode = base.VisitGoto( node );
 
         if ( updateNode is not GotoExpression { Kind: GotoExpressionKind.Return } gotoExpression )
             return updateNode;
 
-        _returnValue ??= CreateVariable( gotoExpression.Value!.Type, VariableName.Return );
+        _hasFinalResultVariable = true;
 
-        // update this to assign to a return value versus a goto
-        return Expression.Assign( _returnValue, gotoExpression.Value! );
+        return Expression.Assign( _finalResultVariable, gotoExpression.Value! );
     }
 
     protected override Expression VisitLoop( LoopExpression node )
     {
-        var joinState = _states.EnterGroup( out var sourceState );
+        if ( !RequiresLowering( node ) )
+            return _variableResolver.Resolve( node );
 
-        var resultVariable = GetResultVariable( node, sourceState.StateId );
+        var joinState = _states.EnterGroup( out var sourceState );
 
-        var loopTransition = new LoopTransition { BodyNode = VisitBranch( node.Body, joinState, resultVariable, InitializeLabels ) };
+        var resultVariable = _variableResolver.GetResultVariable( node, sourceState.StateId );
 
-        sourceState.ResultVariable = resultVariable;
-        joinState.ResultValue = resultVariable;
+        var newBody = VisitBranch( node.Body, default, resultVariable, InitializeLabels );
 
-        if ( _states.TailState.Transition is not GotoTransition gotoTransition )
-            throw new InvalidOperationException( "Loop must have a goto transition." );
+        var loopTransition = new LoopTransition
+        {
+            BodyNode = newBody, // pass default to join back to the branch-state 
+            ContinueLabel = node.ContinueLabel != null ? newBody.NodeLabel : null,
+            BreakLabel = node.BreakLabel != null ? joinState.NodeLabel : null,
+        };
 
-        gotoTransition.TargetNode = loopTransition.BodyNode;
+        sourceState.Result.Variable = resultVariable;
+        joinState.Result.Value = resultVariable;
 
         _states.ExitGroup( sourceState, loopTransition );
 
         return sourceState;
 
-        // Helper function for fixing loop labels
-        void InitializeLabels( NodeExpression branchState )
-        {
-            if ( node.ContinueLabel != null )
-                _labels[node.ContinueLabel] = Expression.Goto( branchState.NodeLabel );
+        // Helper function for assigning loop labels
 
-            if ( node.BreakLabel != null )
-                _labels[node.BreakLabel] = Expression.Goto( joinState.NodeLabel );
+        void InitializeLabels( StateExpression branchState )
+        {
+            _variableResolver.ResolveLabel( node.ContinueLabel, branchState.NodeLabel );
+            _variableResolver.ResolveLabel( node.BreakLabel, joinState.NodeLabel );
         }
     }
 
     protected override Expression VisitParameter( ParameterExpression node )
     {
-        if ( !_definedVariables.Contains( node ) )
-            return base.VisitParameter( node );
-
-        var hash = node.GetHashCode();
-
-        if ( _variables.TryGetValue( hash, out var existingNode ) )
-            return existingNode;
-
-        var updateNode = Expression.Parameter(
-            node.Type,
-            VariableName.Variable( node.Name, _states.TailState.StateId, ref _variableId ) );
-
-        _variables[hash] = updateNode;
-
-        return updateNode;
+        return _variableResolver.Resolve( node );
     }
 
     protected override Expression VisitSwitch( SwitchExpression node )
     {
+        if ( !RequiresLowering( node ) )
+            return _variableResolver.Resolve( node );
+
         var updatedSwitchValue = base.Visit( node.SwitchValue );
 
         var joinState = _states.EnterGroup( out var sourceState );
 
-        var resultVariable = GetResultVariable( node, sourceState.StateId );
+        var resultVariable = _variableResolver.GetResultVariable( node, sourceState.StateId );
 
         var switchTransition = new SwitchTransition { SwitchValue = updatedSwitchValue };
 
@@ -243,13 +305,13 @@ protected override Expression VisitSwitch( SwitchExpression node )
         foreach ( var switchCase in node.Cases )
         {
             switchTransition.AddSwitchCase(
-                [.. switchCase.TestValues], // TODO: Visit these because they could be async
+                [.. switchCase.TestValues],
                 VisitBranch( switchCase.Body, joinState, resultVariable )
             );
         }
 
-        sourceState.ResultVariable = resultVariable;
-        joinState.ResultValue = resultVariable;
+        sourceState.Result.Variable = resultVariable;
+        joinState.Result.Value = resultVariable;
 
         _states.ExitGroup( sourceState, switchTransition );
 
@@ -258,15 +320,18 @@ protected override Expression VisitSwitch( SwitchExpression node )
 
     protected override Expression VisitTry( TryExpression node )
     {
+        if ( !RequiresLowering( node ) )
+            return _variableResolver.Resolve( node );
+
         var joinState = _states.EnterGroup( out var sourceState );
 
-        var resultVariable = GetResultVariable( node, sourceState.StateId );
+        var resultVariable = _variableResolver.GetResultVariable( node, sourceState.StateId );
+        var tryStateVariable = _variableResolver.GetTryVariable( sourceState.StateId );
+        var exceptionVariable = _variableResolver.GetExceptionVariable( sourceState.StateId );
 
-        var tryStateVariable = CreateVariable( typeof( int ), VariableName.Try( sourceState.StateId ) );
-        var exceptionVariable = CreateVariable( typeof( object ), VariableName.Exception( sourceState.StateId ) );
+        // if there is a finally block then that is the join for a try/catch.
 
-        // If there is a finally block then that is the join for a try/catch.
-        NodeExpression finalExpression = null;
+        StateExpression finalExpression = null;
 
         if ( node.Finally != null )
         {
@@ -274,7 +339,7 @@ protected override Expression VisitTry( TryExpression node )
             joinState = finalExpression;
         }
 
-        var nodeScope = _states.EnterScope();
+        var nodeScope = _states.EnterScope( sourceState );
 
         var tryCatchTransition = new TryCatchTransition
         {
@@ -290,69 +355,77 @@ protected override Expression VisitTry( TryExpression node )
 
         for ( var index = 0; index < node.Handlers.Count; index++ )
         {
+            // use a non-zero based index for catch states to avoid
+            // conflicts with default catch state value (zero).
+
+            var catchState = index + 1;
             var catchBlock = node.Handlers[index];
+
             tryCatchTransition.AddCatchBlock(
                 catchBlock,
                 VisitBranch( catchBlock.Body, joinState ),
-                index );
+                catchState );
         }
 
-        sourceState.ResultVariable = resultVariable;
-        joinState.ResultValue = resultVariable;
+        sourceState.Result.Variable = resultVariable;
+        joinState.Result.Value = resultVariable;
 
         _states.ExitGroup( sourceState, tryCatchTransition );
 
         return sourceState;
     }
 
-    // Override method for extension expression types
-
     protected override Expression VisitBinary( BinaryExpression node )
     {
         var updatedLeft = Visit( node.Left );
         var updatedRight = Visit( node.Right );
 
-        if ( updatedRight is NodeExpression nodeExpression )
+        if ( updatedRight is not StateExpression nodeExpression )
         {
-            return node.Update( updatedLeft, node.Conversion, nodeExpression.ResultVariable );
+            return node.Update( updatedLeft, node.Conversion, updatedRight );
         }
 
-        return base.VisitBinary( node );
+        return node.Update( updatedLeft, node.Conversion, nodeExpression.Result.Variable );
     }
 
+    // Override method for extension expression types
+
     protected override Expression VisitExtension( Expression node )
     {
-        return node switch
+        switch ( node )
         {
-            AsyncBlockExpression asyncBlockExpression => VisitAsyncBlock( asyncBlockExpression ),
-            AwaitExpression awaitExpression => VisitAwait( awaitExpression ),
-            _ => base.VisitExtension( node )
-        };
-    }
-
-    protected static Expression VisitAsyncBlock( AsyncBlockExpression node )
-    {
-        return node.Reduce();
+            case AwaitExpression awaitExpression:
+                return VisitAwaitExtension( awaitExpression );
+
+            case AsyncBlockExpression:
+                // Nested blocks should be visited by their own visitor,
+                // but nested variables must be replaced
+                return _variableResolver.Resolve( node );
+
+            default:
+                // Lowering visitor shouldn't be used by extensions directly
+                // since it changes the shape of the code
+                return Visit( node.Reduce() );
+        }
     }
 
-    protected Expression VisitAwait( AwaitExpression node )
+    protected Expression VisitAwaitExtension( AwaitExpression node )
     {
         var updatedNode = Visit( node.Target );
 
         var joinState = _states.EnterGroup( out var sourceState );
 
-        var resultVariable = GetResultVariable( node, sourceState.StateId );
-
+        var resultVariable = _variableResolver.GetResultVariable( node, sourceState.StateId );
         var completionState = _states.AddState();
-        _states.TailState.ResultVariable = resultVariable;
+        _states.TailState.Result.Variable = resultVariable;
 
         _awaitCount++;
 
         var awaitBinder = node.GetAwaitBinder();
 
-        var awaiterVariable = CreateVariable(
+        var awaiterVariable = _variableResolver.GetAwaiterVariable(
             awaitBinder.GetAwaiterMethod.ReturnType,
-            VariableName.Awaiter( sourceState.StateId )
+            sourceState.StateId
         );
 
         completionState.Transition = new AwaitResultTransition
@@ -365,10 +438,11 @@ protected Expression VisitAwait( AwaitExpression node )
 
         _states.AddJumpCase( completionState.NodeLabel, joinState.NodeLabel, sourceState.StateId );
 
-        // If we already visited a branching node we only want to use the result variable
-        // else it is most likely direct awaitable (e.g. Task)
-        var targetNode = updatedNode is NodeExpression nodeExpression
-            ? nodeExpression.ResultVariable
+        // if we already visited a branching node we only want to use the result variable
+        // else it is most likely directly awaitable (e.g. Task)
+
+        var targetNode = updatedNode is StateExpression nodeExpression
+            ? nodeExpression.Result.Variable
             : updatedNode;
 
         var awaitTransition = new AwaitTransition
@@ -381,94 +455,11 @@ protected Expression VisitAwait( AwaitExpression node )
             ConfigureAwait = node.ConfigureAwait
         };
 
-        sourceState.ResultVariable = resultVariable;
-        joinState.ResultValue = resultVariable;
+        sourceState.Result.Variable = resultVariable;
+        joinState.Result.Value = resultVariable;
 
         _states.ExitGroup( sourceState, awaitTransition );
 
-        return (Expression) resultVariable ?? Expression.Empty();
-    }
-
-    // Helpers
-
-    private ParameterExpression GetResultVariable( Expression node, int stateId )
-    {
-        if ( node.Type == typeof( void ) )
-            return null;
-
-        ParameterExpression returnVariable =
-            Expression.Parameter( node.Type, VariableName.Result( stateId ) );
-        _variables[returnVariable.GetHashCode()] = returnVariable;
-
-        return returnVariable;
-    }
-
-    private ParameterExpression CreateVariable( Type type, string name )
-    {
-        var variable = Expression.Variable( type, name );
-        _variables[variable.GetHashCode()] = variable;
-        return variable;
-    }
-
-    // State management
-
-    private sealed class StateContext
-    {
-        private int _stateId;
-        private readonly Stack<int> _scopeIndexes;
-        private readonly int _initialCapacity;
-
-        public List<StateScope> Scopes { get; }
-
-        public StateContext( int initialCapacity )
-        {
-            _initialCapacity = initialCapacity;
-            _scopeIndexes = new Stack<int>( _initialCapacity );
-            _scopeIndexes.Push( 0 );
-
-            Scopes =
-            [
-                new StateScope( 0, parent: null, _initialCapacity )
-            ];
-
-            CurrentScope.AddState( _stateId++ );
-        }
-
-        private StateScope CurrentScope => Scopes[_scopeIndexes.Peek()];
-
-        public NodeExpression TailState => CurrentScope.TailState;
-
-        public NodeExpression AddState() => CurrentScope.AddState( _stateId++ );
-
-        public NodeExpression EnterGroup( out NodeExpression sourceState )
-        {
-            return CurrentScope.EnterGroup( _stateId++, out sourceState );
-        }
-
-        public void ExitGroup( NodeExpression sourceState, Transition transition )
-        {
-            CurrentScope.ExitGroup( sourceState, transition );
-        }
-
-        public StateScope EnterScope()
-        {
-            var scope = new StateScope( Scopes.Count, CurrentScope, _initialCapacity );
-
-            Scopes.Add( scope );
-
-            _scopeIndexes.Push( scope.ScopeId );
-
-            return scope;
-        }
-
-        public void ExitScope()
-        {
-            _scopeIndexes.Pop();
-        }
-
-        public void AddJumpCase( LabelTarget resultLabel, LabelTarget continueLabel, int stateId )
-        {
-            CurrentScope.AddJumpCase( resultLabel, continueLabel, stateId );
-        }
+        return resultVariable ?? Expression.Empty();
     }
 }
diff --git a/src/Hyperbee.Expressions/Transformation/NodeExpression.cs b/src/Hyperbee.Expressions/Transformation/NodeExpression.cs
deleted file mode 100644
index ba4317b..0000000
--- a/src/Hyperbee.Expressions/Transformation/NodeExpression.cs
+++ /dev/null
@@ -1,112 +0,0 @@
-using System.Diagnostics;
-using System.Linq.Expressions;
-using Hyperbee.Expressions.Transformation.Transitions;
-
-namespace Hyperbee.Expressions.Transformation;
-
-[DebuggerDisplay( "State = {NodeLabel?.Name,nq}, Transition = {Transition?.GetType().Name,nq}" )]
-public class NodeExpression : Expression
-{
-    public int StateId { get; }
-    public int ScopeId { get; }
-
-    internal int MachineOrder { get; set; }
-    public ParameterExpression ResultVariable { get; set; }
-    public Expression ResultValue { get; set; }
-
-    public LabelTarget NodeLabel { get; set; }
-    public List<Expression> Expressions { get; set; } = new( 8 );
-    public Transition Transition { get; set; }
-
-    private Expression _expression;
-    private IHoistingSource _resolverSource;
-
-    public NodeExpression( int stateId, int scopeId )
-    {
-        StateId = stateId;
-        ScopeId = scopeId;
-        NodeLabel = Label( $"ST_{StateId:0000}" );
-    }
-
-    public override ExpressionType NodeType => ExpressionType.Extension;
-    public override Type Type => ResultValue?.Type ?? typeof( void );
-    public override bool CanReduce => true;
-
-    internal Expression Reduce( IHoistingSource resolverSource )
-    {
-        _resolverSource = resolverSource;
-        return Reduce();
-    }
-
-    public override Expression Reduce()
-    {
-        if ( _resolverSource == null )
-            throw new InvalidOperationException( $"Reduce requires an {nameof( IHoistingSource )} instance." );
-
-        return _expression ??= ReduceTransition();
-    }
-
-    private BlockExpression ReduceTransition()
-    {
-        return Transition != null
-            ? ReduceBlock()
-            : ReduceFinalBlock();
-    }
-
-    private BlockExpression ReduceBlock()
-    {
-        if ( ResultValue != null && ResultVariable != null &&
-             ResultValue.Type == ResultVariable.Type )
-        {
-            Expressions.Add( Assign( ResultVariable, ResultValue ) );
-        }
-        else if ( ResultVariable != null && Expressions.Count > 0 && ResultVariable.Type == Expressions[^1].Type )
-        {
-            // TODO: This feels like a hack that should be moved somewhere else
-            // This might be related to Gotos and Joins?
-            Expressions[^1] = Assign( ResultVariable, Expressions[^1] );
-        }
-
-        Expressions.Add( Transition.Reduce( MachineOrder, this, _resolverSource ) );
-
-        // Add the label to the beginning of the block
-        Expressions.Insert( 0, Label( NodeLabel ) );
-
-        return Block( Expressions );
-    }
-
-    private BlockExpression ReduceFinalBlock()
-    {
-        var (_, _, stateIdField, builderField, resultField, returnValue) = _resolverSource;
-
-        Expression blockBody;
-
-        if ( Expressions.Count > 0 )
-            blockBody = Block( Expressions );
-        else if ( ResultValue != null )
-            blockBody = Block( ResultValue );
-        else
-            blockBody = Empty();
-
-        // TODO: see if this can be improved earlier in the process
-        var finalResult = returnValue != null
-            ? Assign( resultField, returnValue )
-            : (blockBody.Type == typeof( void ))
-                ? Assign( resultField, Constant( null, typeof( IVoidResult ) ) )
-                : Assign( resultField, blockBody );
-
-        return Block(
-            Label( NodeLabel ),
-            finalResult,
-            Assign( stateIdField, Constant( -2 ) ),
-            Call(
-                builderField,
-                "SetResult",
-                null,
-                resultField.Type != typeof( IVoidResult )
-                    ? resultField
-                    : Constant( null, resultField.Type ) // No result for IVoidResult
-            )
-        );
-    }
-}
diff --git a/src/Hyperbee.Expressions/Transformation/Reflection.cs b/src/Hyperbee.Expressions/Transformation/ReflectionHelper.cs
similarity index 95%
rename from src/Hyperbee.Expressions/Transformation/Reflection.cs
rename to src/Hyperbee.Expressions/Transformation/ReflectionHelper.cs
index a60bd90..0ccec8a 100644
--- a/src/Hyperbee.Expressions/Transformation/Reflection.cs
+++ b/src/Hyperbee.Expressions/Transformation/ReflectionHelper.cs
@@ -5,7 +5,7 @@ namespace Hyperbee.Expressions.Transformation;
 
 public delegate bool MethodMatchDelegate( Type[] parameterTypes, int? argCount = null );
 
-internal static class Reflection
+internal static class ReflectionHelper
 {
     internal static bool OpenGenericIsOrInherits( Type baseType, Type checkType )
     {
@@ -30,16 +30,13 @@ internal static bool OpenGenericIsOrInherits( Type baseType, Type checkType )
 
     // find open-generic and non-generic methods
 
-    public static void GetMethods( Type target, BindingFlags bindingFlags, Action<string, MethodInfo, MethodMatchDelegate> matchCallback )
+    internal static void GetMethods( Type target, BindingFlags bindingFlags, Action<string, MethodInfo, MethodMatchDelegate> matchCallback )
     {
         var methods = target.GetMethods( bindingFlags );
 
         foreach ( var method in methods )
         {
-            var methodName = method.Name;
-
-            matchCallback( methodName, method, Matches );
-
+            matchCallback( method.Name, method, Matches );
             continue;
 
             bool Matches( Type[] parameterTypes, int? argCount = null )
@@ -183,7 +180,7 @@ internal static MethodInfo FindExtensionMethod( Type targetType, string methodNa
     internal static MethodInfo FindExtensionMethodInAssembly( Assembly assembly, Type targetType, string methodName )
     {
         // Search for an extension method with the specified name that extends the specified target type.
-        // This is a very expensive operation. To minimize the performance impact, we will filter out as
+        // This is an expensive operation. To minimize the performance impact, we will filter out as
         // many types as possible.
 
         var methods = assembly.GetTypes()
diff --git a/src/Hyperbee.Expressions/Transformation/StateContext.cs b/src/Hyperbee.Expressions/Transformation/StateContext.cs
new file mode 100644
index 0000000..8dc5d0c
--- /dev/null
+++ b/src/Hyperbee.Expressions/Transformation/StateContext.cs
@@ -0,0 +1,189 @@
+using System.Linq.Expressions;
+using System.Runtime.CompilerServices;
+using Hyperbee.Expressions.Transformation.Transitions;
+
+namespace Hyperbee.Expressions.Transformation;
+
+internal sealed class StateContext
+{
+    private int _stateId;
+    private int _groupId;
+    private readonly int _initialCapacity;
+
+    private readonly Stack<StateExpression> _joinStates;
+    private readonly Stack<int> _scopeIndexes;
+    public List<Scope> Scopes { get; }
+
+    public StateExpression TailState { get; private set; }
+
+    private Scope CurrentScope => Scopes[_scopeIndexes.Peek()];
+
+    public StateContext( int initialCapacity )
+    {
+        _initialCapacity = initialCapacity;
+
+        Scopes = new List<Scope>( _initialCapacity )
+        {
+            new ( 0, null, null, _initialCapacity ) // root scope
+        };
+
+        _joinStates = new Stack<StateExpression>( _initialCapacity );
+        _scopeIndexes = new Stack<int>( _initialCapacity );
+        _scopeIndexes.Push( 0 ); // the root scope index
+
+        AddState();
+    }
+
+    public void Clear()
+    {
+        _stateId = 0;
+        _groupId = 0;
+        TailState = null;
+
+        Scopes.Clear();
+        Scopes.Add( new Scope( 0, null, null, _initialCapacity ) );
+
+        _joinStates.Clear();
+        _scopeIndexes.Clear();
+        _scopeIndexes.Push( 0 );
+
+        AddState();
+    }
+
+    public Scope EnterScope( StateExpression initialState )
+    {
+        var parentScope = CurrentScope;
+
+        var newScopeId = Scopes.Count;
+        var newScope = new Scope( newScopeId, parentScope, initialState?.NodeLabel, _initialCapacity );
+
+        Scopes.Add( newScope );
+        _scopeIndexes.Push( newScopeId );
+
+        return newScope;
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void ExitScope()
+    {
+        _scopeIndexes.Pop();
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public StateExpression EnterGroup( out StateExpression sourceState )
+    {
+        var scope = CurrentScope;
+        var joinState = new StateExpression( _stateId++, scope.ScopeId, _groupId++ );
+
+        scope.States.Add( joinState );
+        _joinStates.Push( joinState );
+
+        sourceState = TailState;
+        TailState = joinState;
+
+        return joinState;
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void ExitGroup( StateExpression sourceState, Transition transition )
+    {
+        sourceState.Transition = transition;
+        TailState = _joinStates.Pop();
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public StateExpression AddState()
+    {
+        var scope = CurrentScope;
+        var newState = new StateExpression( _stateId++, scope.ScopeId, _groupId );
+        scope.States.Add( newState );
+        TailState = newState;
+
+        return newState;
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void AddJumpCase( LabelTarget resultLabel, LabelTarget continueLabel, int stateId )
+    {
+        var scope = CurrentScope;
+        var jumpCase = new JumpCase( resultLabel, continueLabel, stateId, scope.ScopeId );
+        scope.JumpCases.Add( jumpCase );
+    }
+
+    public bool TryGetLabelTarget( LabelTarget target, out IStateNode node )
+    {
+        node = null;
+
+        for ( var index = 0; index < CurrentScope.States.Count; index++ )
+        {
+            var check = CurrentScope.States[index];
+
+            if ( check.NodeLabel != target )
+                continue;
+
+            node = check;
+            break;
+        }
+
+        return node != null;
+    }
+
+    public sealed class Scope
+    {
+        public int ScopeId { get; }
+        public LabelTarget InitialLabel { get; }
+        public Scope Parent { get; }
+        public List<IStateNode> States { get; set; }
+        public List<JumpCase> JumpCases { get; }
+
+        public Scope( int scopeId, Scope parent, LabelTarget initialLabel, int initialCapacity )
+        {
+            Parent = parent;
+            ScopeId = scopeId;
+            InitialLabel = initialLabel;
+            States = new List<IStateNode>( initialCapacity );
+            JumpCases = [];
+        }
+
+        internal IReadOnlyList<Expression> GetExpressions( StateMachineContext context )
+        {
+            var expressions = new List<Expression>( 32 );
+
+            for ( var index = 0; index < States.Count; index++ )
+            {
+                var node = States[index];
+                var expression = node.GetExpression( context );
+
+                if ( expression is BlockExpression innerBlock )
+                    expressions.AddRange( innerBlock.Expressions.Where( expr => !IsDefaultVoid( expr ) ) );
+                else
+                    expressions.Add( expression );
+            }
+
+            return expressions;
+
+            static bool IsDefaultVoid( Expression expression )
+            {
+                return expression is DefaultExpression defaultExpression &&
+                       defaultExpression.Type == typeof( void );
+            }
+        }
+    }
+
+    public readonly struct JumpCase
+    {
+        public LabelTarget ResultLabel { get; }
+        public LabelTarget ContinueLabel { get; }
+
+        public int StateId { get; }
+        public int? ParentId { get; }
+
+        public JumpCase( LabelTarget resultLabel, LabelTarget continueLabel, int stateId, int? parentId )
+        {
+            ResultLabel = resultLabel;
+            ContinueLabel = continueLabel;
+            StateId = stateId;
+            ParentId = parentId;
+        }
+    }
+}
diff --git a/src/Hyperbee.Expressions/Transformation/StateExpression.cs b/src/Hyperbee.Expressions/Transformation/StateExpression.cs
new file mode 100644
index 0000000..8436358
--- /dev/null
+++ b/src/Hyperbee.Expressions/Transformation/StateExpression.cs
@@ -0,0 +1,55 @@
+using System.Diagnostics;
+using System.Linq.Expressions;
+using Hyperbee.Expressions.Transformation.Transitions;
+
+namespace Hyperbee.Expressions.Transformation;
+
+[DebuggerDisplay( "State = {NodeLabel?.Name,nq}, ScopeId = {ScopeId}, GroupId = {GroupId}, StateOrder = {StateOrder}, Transition = {Transition?.GetType().Name,nq}" )]
+internal sealed class StateExpression : Expression, IStateNode
+{
+    public int StateId { get; }
+    public int GroupId { get; }
+    public int ScopeId { get; }
+
+    public int StateOrder { get; set; }
+
+    public StateResult Result { get; } = new();
+
+    public LabelTarget NodeLabel { get; }
+    public List<Expression> Expressions { get; } = new( 8 );
+
+    public Transition Transition { get; set; }
+
+    public StateExpression( int stateId, int scopeId, int groupId )
+    {
+        StateId = stateId;
+        ScopeId = scopeId;
+        GroupId = groupId;
+        NodeLabel = Label( $"ST_{StateId:0000}" );
+    }
+
+    public override ExpressionType NodeType => ExpressionType.Extension;
+    public override Type Type => typeof( void );
+
+    public override bool CanReduce => false; // This should NEVER be reduced
+    public override Expression Reduce() => throw new NotSupportedException();
+
+    public Expression GetExpression( StateMachineContext context )
+    {
+        ArgumentNullException.ThrowIfNull( context, nameof( context ) );
+
+        var expressions = new List<Expression>( 8 ) { Label( NodeLabel ) };
+        expressions.AddRange( Expressions );
+
+        var prevState = context.StateNode;
+        context.StateNode = this;
+
+        Transition.AddExpressions( expressions, context );
+
+        context.StateNode = prevState;
+
+        return expressions.Count == 1
+            ? expressions[0]
+            : Block( expressions );
+    }
+}
diff --git a/src/Hyperbee.Expressions/Transformation/StateMachineBuilder.cs b/src/Hyperbee.Expressions/Transformation/StateMachineBuilder.cs
index a110d7d..8f1e2dc 100644
--- a/src/Hyperbee.Expressions/Transformation/StateMachineBuilder.cs
+++ b/src/Hyperbee.Expressions/Transformation/StateMachineBuilder.cs
@@ -7,24 +7,23 @@
 namespace Hyperbee.Expressions.Transformation;
 
 public interface IVoidResult; // Marker interface for void Task results
+public delegate void MoveNextDelegate<in T>( T stateMachine ) where T : IAsyncStateMachine;
 
-public delegate void MoveNextDelegate<T>( ref T stateMachine ) where T : IAsyncStateMachine;
+internal delegate LoweringInfo LoweringTransformer();
 
-public class StateMachineBuilder<TResult>
+internal class StateMachineBuilder<TResult>
 {
     private readonly ModuleBuilder _moduleBuilder;
     private readonly string _typeName;
 
-    private static class FieldName
+    protected static class FieldName
     {
-        // use special names to prevent collisions with user fields
+        // special names to prevent collisions with user identifiers
+
         public const string Builder = "__builder<>";
-        public const string FinalResult = "__finalResult<>";
+        public const string FinalResult = "__final<>";
         public const string MoveNextDelegate = "__moveNextDelegate<>";
         public const string State = "__state<>";
-
-        [MethodImpl( MethodImplOptions.AggressiveInlining )]
-        public static bool IsSystemField( string name ) => name.EndsWith( "<>" );
     }
 
     public StateMachineBuilder( ModuleBuilder moduleBuilder, string typeName )
@@ -33,21 +32,34 @@ public StateMachineBuilder( ModuleBuilder moduleBuilder, string typeName )
         _typeName = typeName;
     }
 
-    public Expression CreateStateMachine( LoweringResult source, int id, bool createRunner = true )
+    public Expression CreateStateMachine( LoweringTransformer loweringTransformer, int id )
     {
-        if ( source.Scopes[0].Nodes == null )
-            throw new InvalidOperationException( "States must be set before creating state machine." );
+        ArgumentNullException.ThrowIfNull( loweringTransformer, nameof( loweringTransformer ) );
+
+        // Lower the async expression
+        //
+        var loweringInfo = loweringTransformer();
+
+        // Create the state-machine builder context
+        //
+        var context = new StateMachineContext { LoweringInfo = loweringInfo };
 
         // Create the state-machine
         //
         // Conceptually:
         //
         // var stateMachine = new StateMachine();
+        //
         // stateMachine.__state<> = -1;
+        // stateMachine.<extern_fields> = <extern_fields>;
+        //
         // stateMachine.__moveNextDelegate<> = (ref StateMachine stateMachine) => { ... }
+        // stateMachine._builder.Start<StateMachineType>( ref stateMachine );
+        //
+        // return stateMachine.__builder<>.Task;
 
-        var stateMachineType = CreateStateMachineType( source, out var fields );
-        var moveNextLambda = CreateMoveNextBody( id, source, stateMachineType, fields );
+        var stateMachineType = CreateStateMachineType( context, out var fields );
+        var moveNextLambda = CreateMoveNextBody( id, context, stateMachineType, fields );
 
         // Initialize the state machine
 
@@ -56,78 +68,64 @@ public Expression CreateStateMachine( LoweringResult source, int id, bool create
             $"stateMachine<{id}>"
         );
 
-        var assignNew = Assign(
-            stateMachineVariable,
-            New( stateMachineType )
-        );
-
-        var assignStateField = Assign(
-            Field(
+        var bodyExpression = new List<Expression>
+        {
+            Assign( // Create the state-machine
                 stateMachineVariable,
-                stateMachineType.GetField( FieldName.State )!
+                New( stateMachineType )
             ),
-            Constant( -1 )
-        );
+            Assign( // Set the state-machine state to -1
+                Field(
+                    stateMachineVariable,
+                    stateMachineType.GetField( FieldName.State )!
+                ),
+                Constant( -1 )
+            )
+        };
 
-        var assignMoveNextDelegate = Assign(
-            Field(
-                stateMachineVariable,
-                stateMachineType.GetField( FieldName.MoveNextDelegate )!
-            ),
-            moveNextLambda
+        bodyExpression.AddRange( // Assign extern variables to state-machine
+            loweringInfo.ExternVariables.Select( externVariable =>
+                Assign(
+                    Field( stateMachineVariable, fields.First( field => field.Name == externVariable.Name ) ),
+                    externVariable
+                )
+            )
         );
 
-        if ( !createRunner )
-        {
-            return Block(
-                [stateMachineVariable],
-                assignNew,
-                assignStateField,
-                assignMoveNextDelegate,
+        bodyExpression.AddRange( [
+            Assign( // Set the state-machine moveNextDelegate
+                Field(
+                    stateMachineVariable,
+                    stateMachineType.GetField( FieldName.MoveNextDelegate )!
+                ),
+                moveNextLambda
+            ),
+            Call( // Start the state-machine
+                Field( stateMachineVariable, stateMachineType.GetField( FieldName.Builder )! ),
+                stateMachineType.GetField( FieldName.Builder )!.FieldType
+                    .GetMethod( "Start" )!
+                    .MakeGenericMethod( stateMachineType ),
                 stateMachineVariable
-            );
-        }
-
-        // Run the state-machine
-        //
-        // Conceptually:
-        //
-        // stateMachine._builder.Start<StateMachineType>( ref stateMachine );
-        // return stateMachine.__builder<>.Task;
-
-        var builderFieldInfo = stateMachineType.GetField( FieldName.Builder )!;
-        var builderField = Field( stateMachineVariable, builderFieldInfo );
-
-        var startMethod = builderFieldInfo.FieldType
-            .GetMethod( "Start" )!
-            .MakeGenericMethod( stateMachineType );
-
-        var callBuilderStart = Call(
-            builderField,
-            startMethod,
-            stateMachineVariable // ref stateMachine
-        );
-
-        var taskProperty = builderFieldInfo.FieldType.GetProperty( "Task" );
-        var taskExpression = Property( builderField, taskProperty! );
+            ),
+            Property( // Return the state-machine task
+                Field( stateMachineVariable, stateMachineType.GetField( FieldName.Builder )! ),
+                stateMachineType.GetField( FieldName.Builder )!.FieldType.GetProperty( "Task" )!
+            )
+        ] );
 
         return Block(
             [stateMachineVariable],
-            assignNew,
-            assignStateField,
-            assignMoveNextDelegate,
-            callBuilderStart,
-            taskExpression
+            bodyExpression
         );
     }
 
-    private Type CreateStateMachineType( LoweringResult source, out IEnumerable<FieldInfo> fields )
+    private Type CreateStateMachineType( StateMachineContext context, out FieldInfo[] fields )
     {
         var typeBuilder = _moduleBuilder.DefineType(
             _typeName,
-            TypeAttributes.Public | TypeAttributes.SequentialLayout | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.Sealed,
-            typeof( ValueType ) // struct
-        );
+            TypeAttributes.Public | TypeAttributes.Class,
+            typeof( object ),
+            [typeof( IAsyncStateMachine )] );
 
         typeBuilder.AddInterfaceImplementation( typeof( IAsyncStateMachine ) );
 
@@ -152,13 +150,20 @@ private Type CreateStateMachineType( LoweringResult source, out IEnumerable<Fiel
             FieldAttributes.Public
         );
 
-        typeBuilder.DefineField(
-            FieldName.FinalResult,
-            typeof( TResult ),
-            FieldAttributes.Public
-        );
+        // variables from this state-machine
+
+        foreach ( var parameterExpression in context.LoweringInfo.Variables.OfType<ParameterExpression>() )
+        {
+            typeBuilder.DefineField(
+                parameterExpression.Name ?? parameterExpression.ToString(),
+                parameterExpression.Type,
+                FieldAttributes.Public
+            );
+        }
+
+        // variables from other state-machines
 
-        foreach ( var parameterExpression in source.Variables )
+        foreach ( var parameterExpression in context.LoweringInfo.ExternVariables )
         {
             typeBuilder.DefineField(
                 parameterExpression.Name ?? parameterExpression.ToString(),
@@ -175,14 +180,12 @@ private Type CreateStateMachineType( LoweringResult source, out IEnumerable<Fiel
         // Close the type builder
         var stateMachineType = typeBuilder.CreateType();
 
-        fields = stateMachineType.GetFields( BindingFlags.Instance | BindingFlags.Public )
-            .Where( field => !FieldName.IsSystemField( field.Name ) )
-            .ToArray();
+        fields = [.. stateMachineType.GetFields( BindingFlags.Instance | BindingFlags.Public )];
 
         return stateMachineType;
     }
 
-    private static void ImplementSetStateMachine( TypeBuilder typeBuilder, FieldInfo builderFieldInfo )
+    private static void ImplementSetStateMachine( TypeBuilder typeBuilder, FieldBuilder builderFieldInfo )
     {
         // Define the IAsyncStateMachine.SetStateMachine method
         //
@@ -200,16 +203,16 @@ private static void ImplementSetStateMachine( TypeBuilder typeBuilder, FieldInfo
 
         var ilGenerator = setStateMachineMethod.GetILGenerator();
 
-        ilGenerator.Emit( OpCodes.Ldarg_0 ); // Load 'this'
-        ilGenerator.Emit( OpCodes.Ldflda, builderFieldInfo ); // Load address of '__builder<>'
-        ilGenerator.Emit( OpCodes.Ldarg_1 ); // Load 'stateMachine' argument
+        ilGenerator.Emit( OpCodes.Ldarg_0 );
+        ilGenerator.Emit( OpCodes.Ldflda, builderFieldInfo );
+        ilGenerator.Emit( OpCodes.Ldarg_1 );
 
         var setStateMachineOnBuilder = builderFieldInfo
             .FieldType
             .GetMethod( "SetStateMachine", [typeof( IAsyncStateMachine )]
         );
 
-        ilGenerator.Emit( OpCodes.Call, setStateMachineOnBuilder! );
+        ilGenerator.Emit( OpCodes.Callvirt, setStateMachineOnBuilder! );
         ilGenerator.Emit( OpCodes.Ret );
 
         typeBuilder.DefineMethodOverride( setStateMachineMethod,
@@ -234,9 +237,9 @@ private static void ImplementMoveNext( TypeBuilder typeBuilder, FieldBuilder mov
 
         var ilGenerator = moveNextMethod.GetILGenerator();
 
-        ilGenerator.Emit( OpCodes.Ldarg_0 ); // Load 'this'
-        ilGenerator.Emit( OpCodes.Ldfld, moveNextDelegateField ); // Load '__moveNextDelegate<>'
-        ilGenerator.Emit( OpCodes.Ldarg_0 ); // Load 'this'
+        ilGenerator.Emit( OpCodes.Ldarg_0 );
+        ilGenerator.Emit( OpCodes.Ldfld, moveNextDelegateField );
+        ilGenerator.Emit( OpCodes.Ldarg_0 );
 
         var openInvokeMethod = typeof( MoveNextDelegate<> ).GetMethod( "Invoke" )!;
         var invokeMethod = TypeBuilder.GetMethod( moveNextDelegateType, openInvokeMethod );
@@ -249,209 +252,130 @@ private static void ImplementMoveNext( TypeBuilder typeBuilder, FieldBuilder mov
 
     private static LambdaExpression CreateMoveNextBody(
         int id,
-        LoweringResult source,
+        StateMachineContext context,
         Type stateMachineType,
-        IEnumerable<FieldInfo> fields
+        FieldInfo[] fields
     )
     {
-        /* Example state-machine:
-
-            (ref StateMachine1 sm<1>) =>
-            {
-                var var<1> = sm<1>.__stateMachineData<>;
-                try
-                {
-                    switch (var<1>.__state<>)
-                    {
-                        case 0:
-                            var<1>.__state<> = -1;
-                            goto ST_0002;
-            
-                        case 1:
-                            var<1>.__state<> = -1;
-                            goto ST_0004;
-                    }
-            
-                    var awaitable = Task<int>;
-                    var<1>.__awaiter<0> = AwaitBinder.GetAwaiter(ref awaitable, false);
-            
-                    if (!var<1>.__awaiter<0>.IsCompleted)
-                    {
-                        var<1>.__state<> = 0;
-                        var<1>.__builder<>.AwaitUnsafeOnCompleted(ref var<1>.__awaiter<0>, ref sm<1>);
-                        return;
-                    }
-
-                ST_0002:
-                    var<1>.__result<0> = AwaitBinder.GetResult(ref var<1>.__awaiter<0>);
-                    var<1>.__result<1> = var<1>.__result<0>;
-                    Task<int> awaitable;
-                    awaitable = Task<int>;
-                    var<1>.__awaiter<1> = AwaitBinder.GetAwaiter(ref awaitable, false);
-            
-                    if (!var<1>.__awaiter<1>.IsCompleted)
-                    {
-                        var<1>.__state<> = 1;
-                        var<1>.__builder<>.AwaitUnsafeOnCompleted(ref var<1>.__awaiter<1>, ref sm<1>);
-                        return;
-                    }
-
-                ST_0004:
-                    var<1>.__result<1> = AwaitBinder.GetResult(ref var<1>.__awaiter<1>);
-                    var<1>.__finalResult<> = var<1>.__result<1>;
-                    var<1>.__state<> = -2;
-                    var<1>.__builder<>.SetResult(var<1>.__finalResult<>);
-                }
-                catch (Exception ex)
-                {
-                    var<1>.__state<> = -2;
-                    var<1>.__builder<>.SetException(ex);
-                }
-            }
-           
-        */
-
-        var stateMachine = Parameter( stateMachineType.MakeByRefType(), $"sm<{id}>" );
+        // Set context state-machine-info
+
+        var stateMachine = Parameter( stateMachineType, $"sm<{id}>" );
 
         var stateField = Field( stateMachine, FieldName.State );
         var builderField = Field( stateMachine, FieldName.Builder );
         var finalResultField = Field( stateMachine, FieldName.FinalResult );
 
-        var fieldMembers = fields
-            .Select( field => Field( stateMachine, field ) )
-            .ToDictionary( x => x.Member.Name );
-
         var exitLabel = Label( "ST_EXIT" );
 
-        // Optimize node ordering to reduce goto calls
-
-        var nodes = OptimizeNodeOrder( source.Scopes );
-
-        // Create the jump table
-
-        var jumpTable = JumpTableBuilder.Build(
-            source.Scopes[0],
-            source.Scopes,
-            stateField
-        );
-
-        // Create the body 
-
-        var hoistingVisitor = new HoistingVisitor(
+        context.StateMachineInfo = new StateMachineInfo(
             stateMachine,
-            fieldMembers,
+            exitLabel,
             stateField,
             builderField,
-            finalResultField,
-            exitLabel,
-            source.ReturnValue );
-
-        var bodyExpressions = new List<Expression>( 8 ) // preallocate slots for expressions
-        {
-            jumpTable
-        };
-
-        bodyExpressions.AddRange( nodes.Select( hoistingVisitor.Visit ) );
+            finalResultField
+        );
 
-        // Create a try-catch block to handle exceptions
+        // Create final lambda with try-catch block
 
         var exceptionParam = Parameter( typeof( Exception ), "ex" );
 
-        var tryCatchBlock = TryCatch(
-            Block(
-                typeof( void ),
-                source.ReturnValue != null
-                    ? [source.ReturnValue]
-                    : [],
-                bodyExpressions
-            ),
-            Catch(
-                exceptionParam,
-                Block(
-                    Assign( stateField, Constant( -2 ) ),
-                    Call(
-                        builderField,
-                        nameof( AsyncTaskMethodBuilder<TResult>.SetException ),
-                        null,
-                        exceptionParam
-                    )
-                )
-            )
-        );
-
-        // Create the final lambda expression
-
         return Lambda(
             typeof( MoveNextDelegate<> ).MakeGenericType( stateMachineType ),
             Block(
-                tryCatchBlock,
+                TryCatch(
+                    Block(
+                        typeof( void ),
+                        CreateBody(
+                            fields,
+                            context,
+                            Assign( stateField, Constant( -2 ) ),
+                            Call(
+                                builderField,
+                                nameof( AsyncTaskMethodBuilder<TResult>.SetResult ),
+                                null,
+                                finalResultField
+                            )
+                        )
+                    ),
+                    Catch(
+                        exceptionParam,
+                        Block(
+                            Assign( stateField, Constant( -2 ) ),
+                            Call(
+                                builderField,
+                                nameof( AsyncTaskMethodBuilder<TResult>.SetException ),
+                                null,
+                                exceptionParam
+                            )
+                        )
+                    )
+                ),
                 Label( exitLabel )
             ),
             stateMachine
         );
     }
 
-    private static List<NodeExpression> OptimizeNodeOrder( List<StateScope> scopes )
+    private static IEnumerable<Expression> CreateBody( FieldInfo[] fields, StateMachineContext context, params Expression[] antecedents )
     {
-        for ( var i = 1; i < scopes.Count - 1; i++ )
-        {
-            scopes[i].Nodes = OrderNodes( scopes[i].ScopeId, scopes[i].Nodes );
-        }
+        var stateMachineInfo = context.StateMachineInfo;
+        var loweringInfo = context.LoweringInfo;
 
-        return OrderNodes( scopes[0].ScopeId, scopes[0].Nodes );
+        var scopes = loweringInfo.Scopes;
 
-        static List<NodeExpression> OrderNodes( int currentScopeId, List<NodeExpression> nodes )
-        {
-            // Optimize node order for better performance by performing a greedy depth-first
-            // search to find the best order of execution for each node.
-            //
-            // Doing this will allow us to reduce the number of goto calls in the final machine.
-            //
-            // The first node is always the start node, and the last node is always the final node.
+        // Create the body expressions
 
-            var ordered = new List<NodeExpression>( nodes.Count );
-            var visited = new HashSet<NodeExpression>( nodes.Count );
+        var firstScope = scopes[0];
 
-            // Perform greedy DFS for every unvisited node
+        var jumpTable = JumpTableBuilder.Build(
+            firstScope,
+            scopes,
+            stateMachineInfo.StateField
+        );
 
-            for ( var index = 0; index < nodes.Count; index++ )
-            {
-                var node = nodes[index];
+        // hoist variables
 
-                if ( !visited.Contains( node ) )
-                    Visit( node );
-            }
+        var bodyExpressions = HoistVariables(
+            jumpTable,
+            firstScope.GetExpressions( context ),
+            fields,
+            stateMachineInfo.StateMachine
+        );
 
-            // Make sure the final state is last
+        // return the body expressions
 
-            var finalNode = nodes.FirstOrDefault( x => x.Transition == null );
+        return bodyExpressions.Concat( antecedents );
+    }
 
-            if ( finalNode != null && ordered.Last() != finalNode )
-            {
-                ordered.Remove( finalNode );
-                ordered.Add( finalNode );
-            }
+    private static IEnumerable<Expression> HoistVariables( Expression jumpTable, IReadOnlyList<Expression> expressions, FieldInfo[] fields, ParameterExpression stateMachine )
+    {
+        var fieldMembers = fields
+            .Select( field => Field( stateMachine, field ) )
+            .ToDictionary( x => x.Member.Name );
 
-            // Update the order property of each node
+        var hoistingVisitor = new HoistingVisitor( fieldMembers );
+
+        return HoistingSource().Select( hoistingVisitor.Visit );
+
+        IEnumerable<Expression> HoistingSource()
+        {
+            yield return jumpTable;
 
-            for ( var index = 0; index < ordered.Count; index++ )
-            {
-                ordered[index].MachineOrder = index;
-            }
+            foreach ( var expression in expressions )
+                yield return expression;
+        }
+    }
 
-            return ordered;
+    private sealed class HoistingVisitor( IReadOnlyDictionary<string, MemberExpression> memberExpressions ) : ExpressionVisitor
+    {
+        protected override Expression VisitParameter( ParameterExpression node )
+        {
+            var name = node.Name ?? node.ToString();
 
-            void Visit( NodeExpression node )
-            {
-                while ( node != null && visited.Add( node ) )
-                {
-                    ordered.Add( node );
-                    node = node.Transition?.FallThroughNode;
+            if ( memberExpressions.TryGetValue( name, out var fieldAccess ) )
+                return fieldAccess;
 
-                    if ( node?.ScopeId != currentScopeId )
-                        return;
-                }
-            }
+            return node;
         }
     }
 }
@@ -462,6 +386,10 @@ public static class StateMachineBuilder
     private static readonly ModuleBuilder ModuleBuilder;
     private static int __id;
 
+    const string RuntimeAssemblyName = "RuntimeStateMachineAssembly";
+    const string RuntimeModuleName = "RuntimeStateMachineModule";
+    const string StateMachineTypeName = "StateMachine";
+
     static StateMachineBuilder()
     {
         BuildStateMachineMethod = typeof( StateMachineBuilder )
@@ -469,27 +397,28 @@ static StateMachineBuilder()
             .First( method => method.Name == nameof( Create ) && method.IsGenericMethod );
 
         // Create the state machine module
-        var assemblyName = new AssemblyName( "RuntimeStateMachineAssembly" );
+        var assemblyName = new AssemblyName( RuntimeAssemblyName );
         var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run );
-        ModuleBuilder = assemblyBuilder.DefineDynamicModule( "MainModule" );
+        ModuleBuilder = assemblyBuilder.DefineDynamicModule( RuntimeModuleName );
     }
 
-    public static Expression Create( Type resultType, LoweringResult source, bool createRunner = true )
+    internal static Expression Create( Type resultType, LoweringTransformer loweringTransformer )
     {
-        // If the result type is void, use the internal IVoidResult type
         if ( resultType == typeof( void ) )
             resultType = typeof( IVoidResult );
 
         var buildStateMachine = BuildStateMachineMethod.MakeGenericMethod( resultType );
-        return (Expression) buildStateMachine.Invoke( null, [source, createRunner] );
+
+        return (Expression) buildStateMachine.Invoke( null, [loweringTransformer] );
     }
 
-    internal static Expression Create<TResult>( LoweringResult source, bool createRunner = true )
+    internal static Expression Create<TResult>( LoweringTransformer loweringTransformer )
     {
-        var typeName = $"StateMachine{Interlocked.Increment( ref __id )}";
+        var typeId = Interlocked.Increment( ref __id );
+        var typeName = $"{StateMachineTypeName}{typeId}";
 
         var stateMachineBuilder = new StateMachineBuilder<TResult>( ModuleBuilder, typeName );
-        var stateMachineExpression = stateMachineBuilder.CreateStateMachine( source, __id, createRunner );
+        var stateMachineExpression = stateMachineBuilder.CreateStateMachine( loweringTransformer, __id );
 
         return stateMachineExpression; // the-best expression breakpoint ever
     }
diff --git a/src/Hyperbee.Expressions/Transformation/StateMachineContext.cs b/src/Hyperbee.Expressions/Transformation/StateMachineContext.cs
new file mode 100644
index 0000000..8d6d28b
--- /dev/null
+++ b/src/Hyperbee.Expressions/Transformation/StateMachineContext.cs
@@ -0,0 +1,28 @@
+
+using System.Linq.Expressions;
+
+namespace Hyperbee.Expressions.Transformation;
+
+internal sealed class StateMachineContext
+{
+    public IStateNode StateNode { get; set; }
+    public StateMachineInfo StateMachineInfo { get; set; }
+    public LoweringInfo LoweringInfo { get; set; }
+}
+
+internal record StateMachineInfo(
+    ParameterExpression StateMachine,
+    LabelTarget ExitLabel,
+    MemberExpression StateField,
+    MemberExpression BuilderField,
+    MemberExpression FinalResultField
+);
+
+internal record LoweringInfo
+{
+    public IReadOnlyList<StateContext.Scope> Scopes { get; init; }
+    public IReadOnlyCollection<Expression> Variables { get; init; }
+    public IReadOnlyCollection<ParameterExpression> ExternVariables { get; init; }
+    public int AwaitCount { get; init; }
+    public bool HasFinalResultVariable { get; init; }
+}
diff --git a/src/Hyperbee.Expressions/Transformation/StateOptimizer.cs b/src/Hyperbee.Expressions/Transformation/StateOptimizer.cs
new file mode 100644
index 0000000..0c11c82
--- /dev/null
+++ b/src/Hyperbee.Expressions/Transformation/StateOptimizer.cs
@@ -0,0 +1,93 @@
+using System.Linq.Expressions;
+using Hyperbee.Expressions.Transformation.Transitions;
+
+namespace Hyperbee.Expressions.Transformation;
+
+internal sealed class StateOptimizer
+{
+    internal static void Optimize( StateContext states )
+    {
+        var references = new HashSet<LabelTarget>();
+        int stateOrder = 0;
+
+        var scopes = states.Scopes;
+
+        foreach ( var scope in scopes )
+        {
+            OptimizeOrder( ref stateOrder, scope, references );
+        }
+
+        RemoveUnreferenced( scopes, references );
+    }
+
+    private static void OptimizeOrder( ref int stateOrder, StateContext.Scope scope, HashSet<LabelTarget> references )
+    {
+        var nodes = scope.States;
+
+        var visited = new HashSet<IStateNode>( nodes.Count );
+
+        IStateNode finalNode = null;
+
+        // Add scope references to the set
+
+        SetScopeReferences( scope, references );
+
+        // Perform greedy DFS for each unvisited node
+        for ( var index = 0; index < nodes.Count; index++ )
+        {
+            var node = nodes[index];
+
+            if ( visited.Contains( node ) )
+            {
+                continue;
+            }
+
+            while ( node != null && visited.Add( node ) )
+            {
+                // Optimize transition, which may mutate node.Transition
+                node.Transition?.Optimize( references );
+
+                if ( node.Transition is FinalTransition )
+                {
+                    finalNode = node;
+                    break;
+                }
+
+                node.StateOrder = stateOrder++;
+                node = node.Transition?.FallThroughNode;
+
+                if ( node?.ScopeId != scope.ScopeId )
+                    break;
+            }
+        }
+
+        if ( finalNode != null )
+        {
+            finalNode.StateOrder = stateOrder;
+        }
+
+        // Sort nodes in-place based on StateOrder to reflect the DFS order
+        nodes.Sort( ( x, y ) => x.StateOrder.CompareTo( y.StateOrder ) );
+
+        return;
+
+        static void SetScopeReferences( StateContext.Scope scope, HashSet<LabelTarget> references )
+        {
+            references.Add( scope.States[0].NodeLabel ); // start node
+
+            foreach ( var jumpCase in scope.JumpCases ) // jump cases
+            {
+                references.Add( jumpCase.ContinueLabel );
+                references.Add( jumpCase.ResultLabel );
+            }
+        }
+    }
+
+    private static void RemoveUnreferenced( IReadOnlyList<StateContext.Scope> scopes, HashSet<LabelTarget> references )
+    {
+        foreach ( var scope in scopes )
+        {
+            scope.States.RemoveAll( node => !references.Contains( node.NodeLabel ) );
+        }
+    }
+}
diff --git a/src/Hyperbee.Expressions/Transformation/StateResult.cs b/src/Hyperbee.Expressions/Transformation/StateResult.cs
new file mode 100644
index 0000000..1f320a6
--- /dev/null
+++ b/src/Hyperbee.Expressions/Transformation/StateResult.cs
@@ -0,0 +1,15 @@
+using System.Linq.Expressions;
+
+namespace Hyperbee.Expressions.Transformation;
+
+internal sealed class StateResult
+{
+    public Expression Variable { get; set; }
+    public Expression Value { get; set; }
+
+    public void Deconstruct( out Expression variable, out Expression value )
+    {
+        variable = Variable;
+        value = Value;
+    }
+}
diff --git a/src/Hyperbee.Expressions/Transformation/StateScope.cs b/src/Hyperbee.Expressions/Transformation/StateScope.cs
deleted file mode 100644
index a8beff6..0000000
--- a/src/Hyperbee.Expressions/Transformation/StateScope.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System.Linq.Expressions;
-using System.Runtime.CompilerServices;
-using Hyperbee.Expressions.Transformation.Transitions;
-
-namespace Hyperbee.Expressions.Transformation;
-
-public sealed class StateScope
-{
-    public record struct JumpCase( LabelTarget ResultLabel, LabelTarget ContinueLabel, int StateId, int? ParentId );
-
-    public int ScopeId { get; init; }
-    public StateScope Parent { get; init; }
-    public List<NodeExpression> Nodes { get; set; }
-    public List<JumpCase> JumpCases { get; init; }
-    public Stack<NodeExpression> JoinStates { get; init; }
-
-    private int _currentJumpState;
-    private readonly int? _parentJumpState;
-
-    public StateScope( int scopeId, StateScope parent = null, int initialCapacity = 8 )
-    {
-        ScopeId = scopeId;
-        Parent = parent;
-
-        Nodes = new List<NodeExpression>( initialCapacity );
-        JumpCases = new List<JumpCase>( initialCapacity );
-        JoinStates = new Stack<NodeExpression>( initialCapacity );
-
-        TailState = parent?.TailState;
-        _parentJumpState = parent?._currentJumpState;
-    }
-
-    [MethodImpl( MethodImplOptions.AggressiveInlining )]
-    public NodeExpression AddState( int stateId )
-    {
-        var node = new NodeExpression( stateId, ScopeId );
-
-        Nodes.Add( node );
-        TailState = node;
-
-        return node;
-    }
-
-    public NodeExpression TailState { get; private set; }
-
-    public NodeExpression EnterGroup( int stateId, out NodeExpression sourceState )
-    {
-        var joinState = new NodeExpression( stateId, ScopeId ); // add a state without setting tail
-
-        Nodes.Add( joinState );
-        JoinStates.Push( joinState );
-
-        sourceState = TailState;
-
-        return joinState;
-    }
-
-    [MethodImpl( MethodImplOptions.AggressiveInlining )]
-    public void ExitGroup( NodeExpression sourceState, Transition transition )
-    {
-        sourceState.Transition = transition;
-        TailState = JoinStates.Pop();
-    }
-
-    [MethodImpl( MethodImplOptions.AggressiveInlining )]
-    public void AddJumpCase( LabelTarget resultLabel, LabelTarget continueLabel, int stateId )
-    {
-        _currentJumpState = stateId;
-        JumpCases.Add( new JumpCase( resultLabel, continueLabel, stateId, _parentJumpState ) );
-    }
-}
diff --git a/src/Hyperbee.Expressions/Transformation/Transitions/AwaitResultTransition.cs b/src/Hyperbee.Expressions/Transformation/Transitions/AwaitResultTransition.cs
index 51e3793..49baea0 100644
--- a/src/Hyperbee.Expressions/Transformation/Transitions/AwaitResultTransition.cs
+++ b/src/Hyperbee.Expressions/Transformation/Transitions/AwaitResultTransition.cs
@@ -3,36 +3,49 @@
 
 namespace Hyperbee.Expressions.Transformation.Transitions;
 
-public class AwaitResultTransition : Transition
+internal class AwaitResultTransition : Transition
 {
-    public ParameterExpression AwaiterVariable { get; set; }
-    public ParameterExpression ResultVariable { get; set; }
-    public NodeExpression TargetNode { get; set; }
+    public Expression AwaiterVariable { get; set; }
+    public Expression ResultVariable { get; set; }
+    public IStateNode TargetNode { get; set; }
     public AwaitBinder AwaitBinder { get; set; }
 
-    internal override Expression Reduce( int order, NodeExpression expression, IHoistingSource resolverSource )
-    {
-        var getResultMethod = AwaitBinder.GetResultMethod;
+    internal override IStateNode FallThroughNode => TargetNode;
 
-        var getResultCall = getResultMethod.IsStatic
-            ? Call( getResultMethod, AwaiterVariable )
-            : Call( Constant( AwaitBinder ), getResultMethod, AwaiterVariable );
+    public override void AddExpressions( List<Expression> expressions, StateMachineContext context )
+    {
+        base.AddExpressions( expressions, context );
+        expressions.AddRange( Expressions() );
+        return;
 
-        if ( ResultVariable == null )
+        List<Expression> Expressions()
         {
-            return Block(
-                getResultCall, // Use the pre-determined call expression
-                GotoOrFallThrough( order, TargetNode )
-            );
+            var getResultMethod = AwaitBinder.GetResultMethod;
+
+            var getResultCall = getResultMethod.IsStatic
+                ? Call( getResultMethod, AwaiterVariable )
+                : Call( Constant( AwaitBinder ), getResultMethod, AwaiterVariable );
+
+            if ( ResultVariable == null )
+            {
+                var transition = GotoOrFallThrough( context.StateNode.StateOrder, TargetNode );
+
+                return transition == Empty()
+                    ? [getResultCall]
+                    : [getResultCall, transition];
+            }
+
+            return
+            [
+                Assign( ResultVariable, getResultCall ),
+                GotoOrFallThrough( context.StateNode.StateOrder, TargetNode )
+            ];
         }
-
-        var getResult = Assign( ResultVariable, getResultCall );
-
-        return Block(
-            getResult,
-            GotoOrFallThrough( order, TargetNode )
-        );
     }
 
-    internal override NodeExpression FallThroughNode => TargetNode;
+    internal override void Optimize( HashSet<LabelTarget> references )
+    {
+        TargetNode = OptimizeGotos( TargetNode );
+        references.Add( TargetNode.NodeLabel );
+    }
 }
diff --git a/src/Hyperbee.Expressions/Transformation/Transitions/AwaitTransition.cs b/src/Hyperbee.Expressions/Transformation/Transitions/AwaitTransition.cs
index e8f02a4..b2ecba6 100644
--- a/src/Hyperbee.Expressions/Transformation/Transitions/AwaitTransition.cs
+++ b/src/Hyperbee.Expressions/Transformation/Transitions/AwaitTransition.cs
@@ -3,64 +3,72 @@
 
 namespace Hyperbee.Expressions.Transformation.Transitions;
 
-public class AwaitTransition : Transition
+internal class AwaitTransition : Transition
 {
     public int StateId { get; set; }
 
     public Expression Target { get; set; }
-    public ParameterExpression AwaiterVariable { get; set; }
-    public NodeExpression CompletionNode { get; set; }
+    public Expression AwaiterVariable { get; set; }
+    public IStateNode CompletionNode { get; set; }
     public AwaitBinder AwaitBinder { get; set; }
     public bool ConfigureAwait { get; set; }
 
-    internal override Expression Reduce( int order, NodeExpression expression, IHoistingSource resolverSource )
+    internal override IStateNode FallThroughNode => CompletionNode;
+
+    public override void AddExpressions( List<Expression> expressions, StateMachineContext context )
     {
-        var awaitable = Variable( Target.Type, "awaitable" );
+        base.AddExpressions( expressions, context );
+        expressions.AddRange( Expressions() );
+        return;
 
-        var getAwaiterMethod = AwaitBinder.GetAwaiterMethod;
+        List<Expression> Expressions()
+        {
+            var getAwaiterMethod = AwaitBinder.GetAwaiterMethod;
+            var source = context.StateMachineInfo;
 
-        var getAwaiterCall = getAwaiterMethod.IsStatic
-            ? Call( getAwaiterMethod, awaitable, Constant( ConfigureAwait ) )
-            : Call( Constant( AwaitBinder ), getAwaiterMethod, awaitable, Constant( ConfigureAwait ) );
+            var getAwaiterCall = getAwaiterMethod.IsStatic
+                ? Call( getAwaiterMethod, Target, Constant( ConfigureAwait ) )
+                : Call( Constant( AwaitBinder ), getAwaiterMethod, Target, Constant( ConfigureAwait ) );
 
-        // Get AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>( ref awaiter, ref state-machine )
-        var awaitUnsafeOnCompleted = resolverSource.BuilderField.Type
-            .GetMethods()
-            .Single( m => m.Name == "AwaitUnsafeOnCompleted" && m.IsGenericMethodDefinition )
-            .MakeGenericMethod( AwaiterVariable.Type, resolverSource.StateMachine.Type );
+            // Get AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>( ref awaiter, ref state-machine )
+            var awaitUnsafeOnCompleted = source.BuilderField.Type
+                .GetMethods()
+                .Single( methodInfo => methodInfo.Name == "AwaitUnsafeOnCompleted" && methodInfo.IsGenericMethodDefinition )
+                .MakeGenericMethod( AwaiterVariable.Type, source.StateMachine.Type );
 
-        var expressions = new List<Expression>
-        {
-            Assign(
-                awaitable,
-                Target
-            ),
-            Assign(
-                AwaiterVariable,
-                getAwaiterCall
-            ),
-            IfThen(
-                IsFalse( Property( AwaiterVariable, "IsCompleted" ) ),
-                Block(
-                    Assign( resolverSource.StateIdField, Constant( StateId ) ),
-                    Call(
-                        resolverSource.BuilderField,
-                        awaitUnsafeOnCompleted,
-                        AwaiterVariable,
-                        resolverSource.StateMachine
-                    ),
-                    Return( resolverSource.ExitLabel )
+            var body = new List<Expression>
+            {
+                Assign(
+                    AwaiterVariable,
+                    getAwaiterCall
+                ),
+                IfThen(
+                    IsFalse( Property( AwaiterVariable, "IsCompleted" ) ),
+                    Block(
+                        Assign( source.StateField, Constant( StateId ) ),
+                        Call(
+                            source.BuilderField,
+                            awaitUnsafeOnCompleted,
+                            AwaiterVariable,
+                            source.StateMachine
+                        ),
+                        Return( source.ExitLabel )
+                    )
                 )
-            )
-        };
+            };
 
-        var fallThrough = GotoOrFallThrough( order, CompletionNode, true );
+            var fallThrough = GotoOrFallThrough( context.StateNode.StateOrder, CompletionNode, true );
 
-        if ( fallThrough != null )
-            expressions.Add( fallThrough );
+            if ( fallThrough != null )
+                body.Add( fallThrough );
 
-        return Block( [awaitable], expressions );
+            return body;
+        }
     }
 
-    internal override NodeExpression FallThroughNode => CompletionNode;
+    internal override void Optimize( HashSet<LabelTarget> references )
+    {
+        CompletionNode = OptimizeGotos( CompletionNode );
+        references.Add( CompletionNode.NodeLabel );
+    }
 }
diff --git a/src/Hyperbee.Expressions/Transformation/Transitions/ConditionalTransition.cs b/src/Hyperbee.Expressions/Transformation/Transitions/ConditionalTransition.cs
index 574fb3a..9a238f0 100644
--- a/src/Hyperbee.Expressions/Transformation/Transitions/ConditionalTransition.cs
+++ b/src/Hyperbee.Expressions/Transformation/Transitions/ConditionalTransition.cs
@@ -3,25 +3,41 @@
 
 namespace Hyperbee.Expressions.Transformation.Transitions;
 
-public class ConditionalTransition : Transition
+internal class ConditionalTransition : Transition
 {
     public Expression Test { get; set; }
-    public NodeExpression IfTrue { get; set; }
-    public NodeExpression IfFalse { get; set; }
+    public IStateNode IfTrue { get; set; }
+    public IStateNode IfFalse { get; set; }
 
-    internal override Expression Reduce( int order, NodeExpression expression, IHoistingSource resolverSource )
+    internal override IStateNode FallThroughNode => IfFalse;
+
+    public override void AddExpressions( List<Expression> expressions, StateMachineContext context )
     {
-        var fallThrough = GotoOrFallThrough( order, IfFalse, true );
+        base.AddExpressions( expressions, context );
+        expressions.Add( Expression() );
+        return;
+
+        Expression Expression()
+        {
+            var fallThrough = GotoOrFallThrough( context.StateNode.StateOrder, IfFalse, true );
 
-        if ( fallThrough == null )
-            return IfThen( Test, Goto( IfTrue.NodeLabel ) );
+            if ( fallThrough == null )
+                return IfThen( Test, Goto( IfTrue.NodeLabel ) );
 
-        return IfThenElse(
-            Test,
-            Goto( IfTrue.NodeLabel ),
-            fallThrough
-        );
+            return IfThenElse(
+                Test,
+                Goto( IfTrue.NodeLabel ),
+                fallThrough
+            );
+        }
     }
 
-    internal override NodeExpression FallThroughNode => IfFalse;
+    internal override void Optimize( HashSet<LabelTarget> references )
+    {
+        IfTrue = OptimizeGotos( IfTrue );
+        IfFalse = OptimizeGotos( IfFalse );
+
+        references.Add( IfTrue.NodeLabel );
+        references.Add( IfFalse.NodeLabel );
+    }
 }
diff --git a/src/Hyperbee.Expressions/Transformation/Transitions/FinalTransition.cs b/src/Hyperbee.Expressions/Transformation/Transitions/FinalTransition.cs
new file mode 100644
index 0000000..4aa31c9
--- /dev/null
+++ b/src/Hyperbee.Expressions/Transformation/Transitions/FinalTransition.cs
@@ -0,0 +1,41 @@
+using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
+
+namespace Hyperbee.Expressions.Transformation.Transitions;
+
+internal class FinalTransition : Transition
+{
+    internal override IStateNode FallThroughNode => null;
+
+    internal override void Optimize( HashSet<LabelTarget> references )
+    {
+        // nop
+    }
+
+    public override void AddExpressions( List<Expression> expressions, StateMachineContext context )
+    {
+        var (variable, value) = context.StateNode.Result;
+
+        if ( variable == null )
+        {
+            return;
+        }
+
+        if ( expressions.Count <= 1 || expressions[^1].Type == typeof( void ) )
+        {
+            value ??= Constant( null, typeof( IVoidResult ) );
+            expressions.Add( Assign( variable, value ) );
+            return;
+        }
+
+        if ( expressions.Count > 1 )
+        {
+            var lastExpression = expressions[^1];
+
+            if ( variable.Type.IsAssignableFrom( lastExpression.Type ) )
+            {
+                expressions[^1] = Assign( variable, lastExpression );
+            }
+        }
+    }
+}
diff --git a/src/Hyperbee.Expressions/Transformation/Transitions/GotoTransition.cs b/src/Hyperbee.Expressions/Transformation/Transitions/GotoTransition.cs
index ccf6388..fdf0761 100644
--- a/src/Hyperbee.Expressions/Transformation/Transitions/GotoTransition.cs
+++ b/src/Hyperbee.Expressions/Transformation/Transitions/GotoTransition.cs
@@ -1,20 +1,21 @@
 using System.Linq.Expressions;
 
-using static System.Linq.Expressions.Expression;
-
 namespace Hyperbee.Expressions.Transformation.Transitions;
 
-public class GotoTransition : Transition
+internal class GotoTransition : Transition
 {
-    public NodeExpression TargetNode { get; set; }
+    public IStateNode TargetNode { get; set; }
+    internal override IStateNode FallThroughNode => TargetNode;
 
-    internal override Expression Reduce( int order, NodeExpression expression, IHoistingSource resolverSource )
+    public override void AddExpressions( List<Expression> expressions, StateMachineContext context )
     {
-        return Goto( TargetNode.NodeLabel );
-
-        // TODO: causes infinite loop with nested try/catch
-        // return GotoOrFallThrough( order, TargetNode );
+        base.AddExpressions( expressions, context );
+        expressions.Add( GotoOrFallThrough( context.StateNode.StateOrder, TargetNode ) );
     }
 
-    internal override NodeExpression FallThroughNode => TargetNode;
+    internal override void Optimize( HashSet<LabelTarget> references )
+    {
+        TargetNode = OptimizeGotos( TargetNode );
+        references.Add( TargetNode.NodeLabel );
+    }
 }
diff --git a/src/Hyperbee.Expressions/Transformation/Transitions/LoopTransition.cs b/src/Hyperbee.Expressions/Transformation/Transitions/LoopTransition.cs
index a806b69..f5eb3fa 100644
--- a/src/Hyperbee.Expressions/Transformation/Transitions/LoopTransition.cs
+++ b/src/Hyperbee.Expressions/Transformation/Transitions/LoopTransition.cs
@@ -2,14 +2,22 @@
 
 namespace Hyperbee.Expressions.Transformation.Transitions;
 
-public class LoopTransition : Transition
+internal class LoopTransition : Transition
 {
-    public NodeExpression BodyNode { get; set; }
+    public IStateNode BodyNode { get; set; }
+    public LabelTarget BreakLabel { get; set; }
+    public LabelTarget ContinueLabel { get; set; }
 
-    internal override Expression Reduce( int order, NodeExpression expression, IHoistingSource resolverSource )
+    internal override IStateNode FallThroughNode => BodyNode;
+
+    internal override void Optimize( HashSet<LabelTarget> references )
     {
-        return Expression.Empty();
-    }
+        references.Add( BodyNode.NodeLabel );
 
-    internal override NodeExpression FallThroughNode => BodyNode; // We won't reduce, but we need to provide a value for ordering
+        if ( BreakLabel != null )
+            references.Add( BreakLabel );
+
+        if ( ContinueLabel != null )
+            references.Add( ContinueLabel );
+    }
 }
diff --git a/src/Hyperbee.Expressions/Transformation/Transitions/SwitchTransition.cs b/src/Hyperbee.Expressions/Transformation/Transitions/SwitchTransition.cs
index a6c7f1c..bc8bb1c 100644
--- a/src/Hyperbee.Expressions/Transformation/Transitions/SwitchTransition.cs
+++ b/src/Hyperbee.Expressions/Transformation/Transitions/SwitchTransition.cs
@@ -3,37 +3,70 @@
 
 namespace Hyperbee.Expressions.Transformation.Transitions;
 
-public class SwitchTransition : Transition
+internal class SwitchTransition : Transition
 {
-    internal readonly List<SwitchCaseDefinition> CaseNodes = [];
-    public NodeExpression DefaultNode { get; set; }
+    public IStateNode DefaultNode { get; set; }
     public Expression SwitchValue { get; set; }
+    internal List<SwitchCaseDefinition> CaseNodes = [];
 
-    internal override Expression Reduce( int order, NodeExpression expression, IHoistingSource resolverSource )
+    internal override IStateNode FallThroughNode => DefaultNode;
+
+    public override void AddExpressions( List<Expression> expressions, StateMachineContext context )
     {
-        var defaultBody = DefaultNode != null
-            ? GotoOrFallThrough( order, DefaultNode, allowNull: true )
-            : null;
-
-        var cases = CaseNodes
-            .Select( switchCase => switchCase.Reduce() );
-
-        return Switch(
-            SwitchValue,
-            defaultBody,
-            [.. cases]
-        );
+        base.AddExpressions( expressions, context );
+        expressions.Add( Expression() );
+        return;
+
+        Expression Expression()
+        {
+            var stateOrder = context.StateNode.StateOrder;
+
+            Expression defaultBody;
+
+            if ( DefaultNode != null )
+            {
+                defaultBody = GotoOrFallThrough(
+                    stateOrder,
+                    DefaultNode,
+                    allowNull: true
+                );
+            }
+            else
+            {
+                defaultBody = null;
+            }
+
+            var cases = CaseNodes
+                .Select( switchCase => switchCase.Reduce( stateOrder ) )
+                .ToArray();
+
+            return Switch( SwitchValue, defaultBody, cases );
+        }
     }
 
-    internal override NodeExpression FallThroughNode => DefaultNode;
+    internal override void Optimize( HashSet<LabelTarget> references )
+    {
+        DefaultNode = OptimizeGotos( DefaultNode );
+        references.Add( DefaultNode.NodeLabel );
+
+        for ( var index = 0; index < CaseNodes.Count; index++ )
+        {
+            var caseNode = CaseNodes[index];
+            caseNode.Body = OptimizeGotos( caseNode.Body );
+
+            references.Add( caseNode.Body.NodeLabel );
+        }
+    }
 
-    public void AddSwitchCase( List<Expression> testValues, NodeExpression body )
+    public void AddSwitchCase( List<Expression> testValues, IStateNode body )
     {
         CaseNodes.Add( new SwitchCaseDefinition( testValues, body ) );
     }
 
-    internal record SwitchCaseDefinition( List<Expression> TestValues, NodeExpression Body )
+    internal sealed class SwitchCaseDefinition( List<Expression> testValues, IStateNode body )
     {
-        public SwitchCase Reduce() => SwitchCase( Goto( Body.NodeLabel ), TestValues );
+        public List<Expression> TestValues = testValues;
+        public IStateNode Body { get; set; } = body;
+        public SwitchCase Reduce( int order ) => SwitchCase( GotoOrFallThrough( order, Body ), TestValues );
     }
 }
diff --git a/src/Hyperbee.Expressions/Transformation/Transitions/Transition.cs b/src/Hyperbee.Expressions/Transformation/Transitions/Transition.cs
index 8a99b05..8a7f3b8 100644
--- a/src/Hyperbee.Expressions/Transformation/Transitions/Transition.cs
+++ b/src/Hyperbee.Expressions/Transformation/Transitions/Transition.cs
@@ -5,17 +5,64 @@
 namespace Hyperbee.Expressions.Transformation.Transitions;
 
 [DebuggerDisplay( "Transition = {GetType().Name,nq}" )]
-public abstract class Transition
+
+internal abstract class Transition
 {
-    internal abstract Expression Reduce( int order, NodeExpression expression, IHoistingSource resolverSource );
-    internal abstract NodeExpression FallThroughNode { get; } // this node is used to optimize state order
+    internal abstract IStateNode FallThroughNode { get; }
 
-    protected static Expression GotoOrFallThrough( int order, NodeExpression node, bool allowNull = false )
+    public virtual void AddExpressions( List<Expression> expressions, StateMachineContext context )
     {
-        return order + 1 == node.MachineOrder
-            ? allowNull
-                ? null
-                : Empty()
-            : Goto( node.NodeLabel );
+        SetResult( expressions, context );
+    }
+
+    private static void SetResult( List<Expression> expressions, StateMachineContext context )
+    {
+        var (variable, value) = context.StateNode.Result;
+
+        if ( variable == null )
+        {
+            return;
+        }
+
+        if ( value != null && variable.Type.IsAssignableFrom( value.Type ) )
+        {
+            expressions.Add( Assign( variable, value ) );
+            return;
+        }
+
+        if ( expressions.Count > 1 )
+        {
+            var lastExpression = expressions[^1];
+
+            if ( variable.Type.IsAssignableFrom( lastExpression.Type ) )
+            {
+                expressions[^1] = Assign( variable, lastExpression );
+            }
+        }
+    }
+
+    internal abstract void Optimize( HashSet<LabelTarget> references );
+
+    protected static IStateNode OptimizeGotos( IStateNode node )
+    {
+        while ( IsNoOp( node ) && node.Transition is GotoTransition gotoTransition )
+        {
+            node = gotoTransition.TargetNode;
+        }
+
+        return node;
+
+        static bool IsNoOp( IStateNode node ) => node.Expressions.Count == 0 && node.Result.Variable == null;
+    }
+
+    protected static Expression GotoOrFallThrough( int order, IStateNode node, bool allowNull = false )
+    {
+        if ( order + 1 == node.StateOrder )
+        {
+            return allowNull ? null : Empty();
+        }
+
+        return Goto( node.NodeLabel );
     }
 }
+
diff --git a/src/Hyperbee.Expressions/Transformation/Transitions/TryCatchTransition.cs b/src/Hyperbee.Expressions/Transformation/Transitions/TryCatchTransition.cs
index cb2fbe5..a69d3b7 100644
--- a/src/Hyperbee.Expressions/Transformation/Transitions/TryCatchTransition.cs
+++ b/src/Hyperbee.Expressions/Transformation/Transitions/TryCatchTransition.cs
@@ -3,47 +3,72 @@
 
 namespace Hyperbee.Expressions.Transformation.Transitions;
 
-public class TryCatchTransition : Transition
+internal class TryCatchTransition : Transition
 {
-    internal readonly List<CatchBlockDefinition> CatchBlocks = [];
-    public NodeExpression TryNode { get; set; }
-    public NodeExpression FinallyNode { get; set; }
+    internal List<CatchBlockDefinition> CatchBlocks = [];
+    public IStateNode TryNode { get; set; }
+    public IStateNode FinallyNode { get; set; }
 
-    internal override NodeExpression FallThroughNode => TryNode;
-    public ParameterExpression TryStateVariable { get; set; }
-    public ParameterExpression ExceptionVariable { get; set; }
+    public Expression TryStateVariable { get; set; }
+    public Expression ExceptionVariable { get; set; }
 
-    public StateScope StateScope { get; init; }
-    public List<StateScope> Scopes { get; init; }
+    public StateContext.Scope StateScope { get; init; }
+    public List<StateContext.Scope> Scopes { get; init; }
 
-    internal override Expression Reduce( int order, NodeExpression expression, IHoistingSource resolverSource )
+    internal override IStateNode FallThroughNode => TryNode;
+
+    public override void AddExpressions( List<Expression> expressions, StateMachineContext context )
     {
-        var expressions = new List<Expression>( StateScope.Nodes.Count + 1 )
+        base.AddExpressions( expressions, context );
+        expressions.AddRange( Expressions() );
+        return;
+
+        List<Expression> Expressions()
         {
-            JumpTableBuilder.Build(
-                StateScope,
-                Scopes,
-                resolverSource.StateIdField
-            )
-        };
-
-        expressions.AddRange( StateScope.Nodes.Select( x => x.Reduce( resolverSource ) ) );
-
-        MapCatchBlock( out var catches, out var switchCases );
-
-        return Block(
-            TryCatch(
-                Block( expressions ),
-                catches
-            ),
-            Switch( // Handle error
-                TryStateVariable,
-                Empty(),
-                switchCases )
-            );
+            var body = new List<Expression>
+            {
+                JumpTableBuilder.Build(
+                    StateScope,
+                    Scopes,
+                    context.StateMachineInfo.StateField
+                )
+            };
+
+            body.AddRange( StateScope.GetExpressions( context ) );
+
+            MapCatchBlock( context.StateNode.StateOrder, out var catches, out var switchCases );
+
+            return [
+                TryCatch(
+                    body.Count == 1
+                        ? body[0]
+                        : Block( body ),
+                    catches
+                ),
+                Switch( // Handle error
+                    TryStateVariable,
+                    Empty(),
+                    switchCases
+                )
+            ];
+        }
+    }
+
+    internal override void Optimize( HashSet<LabelTarget> references )
+    {
+        references.Add( TryNode.NodeLabel );
+
+        if ( FinallyNode != null )
+            references.Add( FinallyNode.NodeLabel );
+
+        for ( var index = 0; index < CatchBlocks.Count; index++ )
+        {
+            if ( CatchBlocks[index].UpdateBody is IStateNode state )
+                references.Add( state.NodeLabel );
+        }
     }
 
-    private void MapCatchBlock( out CatchBlock[] catches, out SwitchCase[] switchCases )
+    private void MapCatchBlock( int order, out CatchBlock[] catches, out SwitchCase[] switchCases )
     {
         var includeFinal = FinallyNode != null;
         var size = CatchBlocks.Count + (includeFinal ? 1 : 0);
@@ -58,9 +83,9 @@ private void MapCatchBlock( out CatchBlock[] catches, out SwitchCase[] switchCas
             catches[index] = catchBlock.Reduce( ExceptionVariable, TryStateVariable );
 
             switchCases[index] = SwitchCase(
-                (catchBlock.UpdateBody is NodeExpression nodeExpression)
-                    ? Goto( nodeExpression.NodeLabel )
-                    : Block( typeof( void ), catchBlock.UpdateBody ),
+                (catchBlock.UpdateBody is not IStateNode node)
+                    ? Block( typeof( void ), catchBlock.UpdateBody )
+                    : GotoOrFallThrough( order, node ),
                 Constant( catchBlock.CatchState ) );
         }
 
@@ -86,9 +111,9 @@ public void AddCatchBlock( CatchBlock handler, Expression updateBody, int catchS
         CatchBlocks.Add( new CatchBlockDefinition( handler, updateBody, catchState ) );
     }
 
-    internal record CatchBlockDefinition( CatchBlock Handler, Expression UpdateBody, int CatchState )
+    internal class CatchBlockDefinition( CatchBlock handler, Expression updateBody, int catchState )
     {
-        public CatchBlock Reduce( ParameterExpression exceptionVariable, ParameterExpression tryStateVariable )
+        public CatchBlock Reduce( Expression exceptionVariable, Expression tryStateVariable )
         {
             if ( Handler.Variable == null )
             {
@@ -108,5 +133,9 @@ public CatchBlock Reduce( ParameterExpression exceptionVariable, ParameterExpres
                     Assign( tryStateVariable, Constant( CatchState ) )
                 ) );
         }
+
+        public CatchBlock Handler { get; init; } = handler;
+        public Expression UpdateBody { get; internal set; } = updateBody;
+        public int CatchState { get; init; } = catchState;
     }
 }
diff --git a/src/Hyperbee.Expressions/Transformation/VariableResolver.cs b/src/Hyperbee.Expressions/Transformation/VariableResolver.cs
new file mode 100644
index 0000000..f7218fc
--- /dev/null
+++ b/src/Hyperbee.Expressions/Transformation/VariableResolver.cs
@@ -0,0 +1,231 @@
+using System.Linq.Expressions;
+using System.Runtime.CompilerServices;
+using static System.Linq.Expressions.Expression;
+
+namespace Hyperbee.Expressions.Transformation;
+
+internal sealed class VariableResolver : ExpressionVisitor
+{
+    internal static class VariableName
+    {
+        // use special names to prevent collisions
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static string Awaiter( int stateId, ref int variableId ) => $"__awaiter<{stateId}_{variableId++}>";
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static string Result( int stateId, ref int variableId ) => $"__result<{stateId}_{variableId++}>";
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static string Try( int stateId ) => $"__try<{stateId}>";
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static string Exception( int stateId ) => $"__ex<{stateId}>";
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static string Variable( string name, int stateId, ref int variableId ) => $"__{name}<{stateId}_{variableId++}>";
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static string ExternVariable( string name, int stateId, ref int variableId ) => $"__extern.{name}<{stateId}_{variableId++}>";
+
+        public const string FinalResult = "__final<>";
+    }
+
+    private const int InitialCapacity = 8;
+
+    private readonly Dictionary<ParameterExpression, ParameterExpression> _variableMap = new( InitialCapacity );
+    private readonly Dictionary<ParameterExpression, ParameterExpression> _externVariableMap = new( InitialCapacity );
+    private readonly HashSet<ParameterExpression> _variables;
+    private readonly Stack<ICollection<ParameterExpression>> _variableScope = new( InitialCapacity );
+    private readonly StateContext _states;
+
+    private readonly Dictionary<LabelTarget, Expression> _labels = [];
+
+    private int _variableId;
+
+    public VariableResolver( ParameterExpression[] variables, StateContext states )
+    {
+        _states = states;
+        _variables = [.. variables];
+    }
+
+    // Helpers
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public Expression GetResultVariable( Expression node, int stateId )
+    {
+        if ( node.Type == typeof( void ) )
+            return null;
+
+        return AddVariable( Parameter( node.Type, VariableName.Result( stateId, ref _variableId ) ) );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public Expression GetAwaiterVariable( Type type, int stateId )
+    {
+        return AddVariable( Variable( type, VariableName.Awaiter( stateId, ref _variableId ) ) );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public Expression GetTryVariable( int stateId )
+    {
+        return AddVariable( Variable( typeof( int ), VariableName.Try( stateId ) ) );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public Expression GetExceptionVariable( int stateId )
+    {
+        return AddVariable( Variable( typeof( object ), VariableName.Exception( stateId ) ) );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public ParameterExpression GetFinalResult( Type type )
+    {
+        return AddVariable( Variable( type, VariableName.FinalResult ) );
+    }
+
+    // Resolving Visitor
+
+    public Expression Resolve( Expression node )
+    {
+        return Visit( node );
+    }
+
+    internal void ResolveLabel( LabelTarget targetLabel, LabelTarget nodeLabel )
+    {
+        if ( targetLabel != null )
+            _labels[targetLabel] = Goto( nodeLabel );
+    }
+
+    internal bool TryResolveLabel( GotoExpression node, out Expression label )
+    {
+        return _labels.TryGetValue( node.Target, out label );
+    }
+
+    protected override Expression VisitBlock( BlockExpression node )
+    {
+        // TODO: feels like a downstream hack, see if there is a way to detect this earlier
+        var newVars = CreateLocalVariables();
+
+        _variableScope.Push( newVars );
+
+        var returnNode = base.VisitBlock( node.Update( newVars, node.Expressions ) );
+
+        _variableScope.Pop();
+
+        return returnNode;
+
+        List<ParameterExpression> CreateLocalVariables()
+        {
+            var vars = new List<ParameterExpression>();
+
+            foreach ( var variable in node.Variables )
+            {
+                if ( variable.Name!.StartsWith( "__extern." ) )
+                {
+                    vars.Add( variable );
+                    _externVariableMap.TryAdd( variable, variable );
+                    continue;
+                }
+
+                var newVar = Parameter(
+                    variable.Type,
+                    VariableName.ExternVariable( variable.Name, _states.TailState.StateId, ref _variableId )
+                );
+
+                _externVariableMap.TryAdd( variable, newVar );
+                vars.Add( newVar );
+            }
+
+            return vars;
+        }
+    }
+
+    protected override Expression VisitParameter( ParameterExpression node )
+    {
+        return TryAddVariable( node, CreateParameter, out var updatedVariable )
+            ? updatedVariable
+            : base.VisitParameter( node );
+    }
+
+    protected override Expression VisitExtension( Expression node )
+    {
+        if ( node is AsyncBlockExpression asyncBlockExpression )
+        {
+            asyncBlockExpression.ExternVariables = _variableScope.SelectMany( x => x ).ToList().AsReadOnly();
+        }
+
+        return base.VisitExtension( node );
+    }
+
+    protected override Expression VisitLabel( LabelExpression node )
+    {
+        if ( _labels.TryGetValue( node.Target, out var label ) )
+            return label;
+
+        return base.VisitLabel( node );
+    }
+
+    protected override Expression VisitGoto( GotoExpression node )
+    {
+        if ( _labels.TryGetValue( node.Target, out var label ) )
+            return label;
+
+        return base.VisitGoto( node );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public IReadOnlyCollection<Expression> GetMappedVariables()
+    {
+        return _variableMap.Values;
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void AddLocalVariables( IEnumerable<ParameterExpression> variables )
+    {
+        foreach ( var variable in variables )
+        {
+            _variables.Add( variable );
+        }
+    }
+
+    // helpers
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    private ParameterExpression CreateParameter( ParameterExpression parameter )
+    {
+        return Parameter( parameter.Type, VariableName.Variable( parameter.Name, _states.TailState.StateId, ref _variableId ) );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    private ParameterExpression AddVariable( ParameterExpression variable )
+    {
+        if ( _variableMap.TryGetValue( variable, out var existingVariable ) )
+            return existingVariable;
+
+        _variableMap[variable] = variable;
+        return variable;
+    }
+
+    private bool TryAddVariable(
+        ParameterExpression parameter,
+        Func<ParameterExpression, ParameterExpression> createParameter,
+        out ParameterExpression updatedParameterExpression
+    )
+    {
+        if ( _variableMap.TryGetValue( parameter, out updatedParameterExpression ) ||
+             _externVariableMap.TryGetValue( parameter, out updatedParameterExpression ) )
+        {
+            return true;
+        }
+
+        if ( _variables == null || !_variables.Contains( parameter ) )
+        {
+            return false;
+        }
+
+        updatedParameterExpression = createParameter( parameter );
+        _variableMap[parameter] = updatedParameterExpression;
+
+        return true;
+    }
+}
diff --git a/src/Hyperbee.Expressions/UsingExpression.cs b/src/Hyperbee.Expressions/UsingExpression.cs
index 841f9f4..e20c13a 100644
--- a/src/Hyperbee.Expressions/UsingExpression.cs
+++ b/src/Hyperbee.Expressions/UsingExpression.cs
@@ -10,7 +10,7 @@ public class UsingExpression : Expression
     internal UsingExpression( Expression disposable, Expression body )
     {
         if ( !typeof( IDisposable ).IsAssignableFrom( disposable.Type ) )
-            throw new ArgumentException( "The disposable expression must return an IDisposable.", nameof( disposable ) );
+            throw new ArgumentException( $"The disposable expression must return an {nameof( IDisposable )}.", nameof( disposable ) );
 
         Disposable = disposable;
         Body = body;
@@ -43,10 +43,11 @@ protected override Expression VisitChildren( ExpressionVisitor visitor )
         var newDisposable = visitor.Visit( Disposable );
         var newBody = visitor.Visit( Body );
 
-        if ( newDisposable != Disposable || newBody != Body )
-            return new UsingExpression( newDisposable, newBody );
+        if ( newDisposable == Disposable && newBody == Body )
+            return this;
+
+        return new UsingExpression( newDisposable, newBody );
 
-        return this;
     }
 }
 
diff --git a/src/Hyperbee.Expressions/Visitors/ExpressionFingerprinter.cs b/src/Hyperbee.Expressions/Visitors/ExpressionFingerprinter.cs
new file mode 100644
index 0000000..82ac127
--- /dev/null
+++ b/src/Hyperbee.Expressions/Visitors/ExpressionFingerprinter.cs
@@ -0,0 +1,557 @@
+using System.Buffers;
+using System.Collections.Concurrent;
+using System.Globalization;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Hyperbee.Expressions.Visitors;
+
+// ExpressionFingerprinter: Expression Fingerprinting
+//
+// ExpressionFingerprinter is a general-purpose visitor for any system that needs to uniquely
+// identify expressions.
+//
+// This visitor generates unique fingerprints for expression trees, providing a consistent and 
+// reusable hash-based identifier for each node in the tree. It captures both structure and constant
+// values, ensuring that each subexpression can be uniquely identified and compared. Fingerprinting
+// enables the recognition of repeated patterns or identical subexpressions across expression trees.
+//
+// ExpressionFingerprinter works by traversing from the leaves of the tree to the root, ensuring
+// that each subexpression's fingerprint is fully computed before it's included in the hash of a
+// larger expression. This approach makes it ideal for identifying and reusing identical subexpressions
+// at any depth of the tree.
+//
+// Key Features and Constraints:
+//
+// - Bottom-Up Traversal: By visiting nodes from the leaves to the root, each subexpression is 
+//   fully resolved and fingerprinted before it is integrated into the larger context. This ensures 
+//   consistent and precise identification of all parts of the tree.
+//
+// - Consistent Fingerprints: Each expression node, from constants to complex method calls, is assigned 
+//   a unique fingerprint. This allows for the comparison of nodes based solely on their fingerprints, 
+//   regardless of their original position in the expression tree.
+//
+// - Custom Hashing Support: The optional `GetHashBytes` delegate allows developers to define custom 
+//   hashing for specific constants, offering fine-grained control over fingerprint generation. 
+//   This flexibility is useful for optimizing performance or handling domain-specific requirements.
+
+public delegate byte[] GetHashBytes( ConstantExpression node );
+
+public class ExpressionFingerprinter : ExpressionVisitor, IDisposable
+{
+    private readonly MD5 _md5 = MD5.Create();
+    private readonly Stack<byte[]> _hashStack = new();
+    private readonly Dictionary<Expression, byte[]> _fingerprintCache = new();
+    private readonly BufferWriter _bufferWriter = new();
+
+    private static readonly byte[] NullBytes = BitConverter.GetBytes( 0 );
+
+    public GetHashBytes CustomHashProvider { get; set; }
+
+    public void Dispose()
+    {
+        GC.SuppressFinalize( this );
+
+        _bufferWriter.Dispose();
+        _md5.Dispose();
+    }
+
+    public byte[] ComputeFingerprint( Expression expression )
+    {
+        _md5.Initialize();
+        Visit( expression );
+        return _hashStack.Pop();
+    }
+
+    private void AddNodeHash( Expression node, Action<BufferWriter> writeAction )
+    {
+        if ( _fingerprintCache.TryGetValue( node, out var cachedHash ) )
+        {
+            _hashStack.Push( cachedHash );
+            return;
+        }
+
+        _bufferWriter.Clear();
+        writeAction( _bufferWriter );
+
+        var hash = CombineHashes( _hashStack, _bufferWriter.GetBuffer(), _bufferWriter.Length );
+
+        _fingerprintCache[node] = hash;
+        _hashStack.Clear();
+        _hashStack.Push( hash );
+    }
+
+    private byte[] CombineHashes( Stack<byte[]> hashStack, byte[] hashBuffer, int hashBufferLength )
+    {
+        _md5.Initialize();
+
+        if ( hashBufferLength > 0 )
+        {
+            _md5.TransformBlock( hashBuffer, 0, hashBufferLength, null, 0 );
+        }
+
+        foreach ( var stackHash in hashStack )
+        {
+            _md5.TransformBlock( stackHash, 0, stackHash.Length, null, 0 );
+        }
+
+        _md5.TransformFinalBlock( [], 0, 0 );
+        return _md5.Hash!;
+    }
+
+    public override Expression Visit( Expression node )
+    {
+        if ( node == null )
+            return null;
+
+        if ( !HasOverride( node ) )
+        {
+            AddNodeHash( node, writer => writer.Write( node.NodeType ) );
+        }
+
+        return base.Visit( node );
+    }
+
+    protected override Expression VisitBinary( BinaryExpression node )
+    {
+        var visitedNode = base.VisitBinary( node );
+
+        if ( !ReferenceEquals( visitedNode, node ) )
+            return visitedNode;
+
+        AddNodeHash( node, writer =>
+        {
+            writer.Write( node.NodeType );
+            writer.Write( node.IsLifted ? 1 : 0 );
+
+            if ( node.Method == null )
+                return;
+
+            writer.Write( node.Method.Name );
+            writer.Write( node.Method.DeclaringType );
+        } );
+
+        return node;
+    }
+
+    protected override Expression VisitMember( MemberExpression node )
+    {
+        var visitedNode = base.VisitMember( node );
+
+        if ( !ReferenceEquals( visitedNode, node ) )
+            return visitedNode;
+
+        AddNodeHash( node, writer =>
+        {
+            writer.Write( node.NodeType );
+            writer.Write( node.Member.MemberType );
+            writer.Write( node.Member.Name );
+        } );
+
+        return node;
+    }
+
+    protected override Expression VisitMethodCall( MethodCallExpression node )
+    {
+        var visitedNode = base.VisitMethodCall( node );
+
+        if ( !ReferenceEquals( visitedNode, node ) )
+            return visitedNode;
+
+        AddNodeHash( node, writer =>
+        {
+            writer.Write( node.NodeType );
+            writer.Write( node.Method.Name );
+            writer.Write( ':' );
+
+            if ( node.Method.IsGenericMethod )
+            {
+                var genericArgs = node.Method.GetGenericArguments();
+
+                for ( var index = 0; index < genericArgs.Length; index++ )
+                {
+                    var arg = genericArgs[index];
+                    writer.Write( arg );
+                }
+
+                writer.Write( ':' );
+            }
+
+            foreach ( var param in node.Method.GetParameters() )
+            {
+                writer.Write( param.ParameterType );
+            }
+        } );
+
+        return node;
+    }
+
+    protected override Expression VisitLambda<T>( Expression<T> node )
+    {
+        var visitedNode = base.VisitLambda( node );
+
+        if ( !ReferenceEquals( visitedNode, node ) )
+            return visitedNode;
+
+        AddNodeHash( node, writer =>
+        {
+            writer.Write( node.NodeType );
+            for ( var index = 0; index < node.Parameters.Count; index++ )
+            {
+                var param = node.Parameters[index];
+                writer.Write( param.Type );
+            }
+
+            writer.Write( ':' );
+            writer.Write( node.ReturnType );
+        } );
+
+        return node;
+    }
+
+    protected override Expression VisitInvocation( InvocationExpression node )
+    {
+        var visitedNode = base.VisitInvocation( node );
+
+        if ( !ReferenceEquals( visitedNode, node ) )
+            return visitedNode;
+
+        AddNodeHash( node, writer =>
+        {
+            writer.Write( node.NodeType );
+
+            foreach ( var arg in node.Arguments )
+            {
+                writer.Write( arg.Type );
+            }
+
+            writer.Write( ':' );
+            writer.Write( node.Type );
+        } );
+
+        return node;
+    }
+
+    protected override Expression VisitBlock( BlockExpression node )
+    {
+        var visitedNode = base.VisitBlock( node );
+
+        if ( !ReferenceEquals( visitedNode, node ) )
+            return visitedNode;
+
+        AddNodeHash( node, writer =>
+        {
+            writer.Write( node.NodeType );
+
+            foreach ( var variable in node.Variables )
+            {
+                writer.Write( variable.Name );
+                writer.Write( variable.Type );
+            }
+
+            writer.Write( ':' );
+            writer.Write( node.Type );
+        } );
+
+        return node;
+    }
+
+    protected override Expression VisitConstant( ConstantExpression node )
+    {
+        AddNodeHash( node, writer =>
+        {
+            switch ( node.Value )
+            {
+                case null:
+                    writer.Write( NullBytes );
+                    return;
+                case Guid guid:
+                    writer.Write( guid );
+                    return;
+                case IConvertible convertible:
+                    writer.Write( convertible );
+                    return;
+                default:
+                    if ( CustomHashProvider != null )
+                    {
+                        var hashBytes = CustomHashProvider( node );
+                        writer.Write( hashBytes );
+                    }
+                    else
+                    {
+                        ConstantHasher.AddToHash( _md5, node.Value );
+                    }
+
+                    break;
+            }
+        } );
+
+        return node;
+    }
+
+    private static bool HasOverride( Expression node )
+    {
+        return node switch
+        {
+            BinaryExpression or
+                ConstantExpression or
+                MemberExpression or
+                MethodCallExpression or
+                InvocationExpression or
+                LambdaExpression or
+                BlockExpression => true,
+            _ => false
+        };
+    }
+
+    private static class ConstantHasher
+    {
+        private static readonly ConcurrentDictionary<Type, (byte[] NameBytes, Func<object, object> Accessor)[]> __propertyCache
+            = new();
+
+        public static void AddToHash( MD5 md5, object value )
+        {
+            var visited = new HashSet<object>();
+            AddToHash( value, md5, visited );
+        }
+
+        private static void AddToHash( object value, HashAlgorithm md5, HashSet<object> visited )
+        {
+            if ( value == null )
+            {
+                md5.TransformBlock( NullBytes, 0, NullBytes.Length, null, 0 );
+                return;
+            }
+
+            if ( !visited.Add( value ) )
+                return;
+
+            switch ( value )
+            {
+                case DateTime dateTime:
+                    {
+                        var dateBytes = BitConverter.GetBytes( dateTime.ToBinary() );
+                        md5.TransformBlock( dateBytes, 0, dateBytes.Length, null, 0 );
+                        return;
+                    }
+                case IConvertible convertible:
+                    {
+                        var bytes = Encoding.UTF8.GetBytes( convertible.ToString( CultureInfo.InvariantCulture ) );
+                        md5.TransformBlock( bytes, 0, bytes.Length, null, 0 );
+                        return;
+                    }
+                case Guid guid:
+                    {
+                        var guidBytes = guid.ToByteArray();
+                        md5.TransformBlock( guidBytes, 0, guidBytes.Length, null, 0 );
+                        return;
+                    }
+            }
+
+            var type = value.GetType();
+            var typeBytesHeader = Encoding.UTF8.GetBytes( type.FullName! );
+            md5.TransformBlock( typeBytesHeader, 0, typeBytesHeader.Length, null, 0 );
+
+            var tuples = GetPropertyAccessors( type );
+
+            for ( var index = 0; index < tuples.Length; index++ )
+            {
+                var (propName, accessor) = tuples[index];
+                md5.TransformBlock( propName, 0, propName.Length, null, 0 );
+                AddToHash( accessor( value ), md5, visited );
+            }
+
+            visited.Remove( value );
+        }
+
+        private static (byte[] NameBytes, Func<object, object> Accessor)[] GetPropertyAccessors( Type type )
+        {
+            return __propertyCache.GetOrAdd( type, x =>
+            {
+                return x.GetProperties( BindingFlags.Public | BindingFlags.Instance )
+                    .Where( p => p.CanRead && p.GetIndexParameters().Length == 0 )
+                    .Select( p =>
+                    {
+                        var propName = Encoding.UTF8.GetBytes( p.Name );
+                        return (propName, CreatePropertyAccessor( p ));
+                    } )
+                    .ToArray();
+            } );
+        }
+
+        private static Func<object, object> CreatePropertyAccessor( PropertyInfo propertyInfo )
+        {
+            var instance = Expression.Parameter( typeof( object ), "instance" );
+            var castInstance = Expression.Convert( instance, propertyInfo.DeclaringType! );
+            var propertyAccess = Expression.Property( castInstance, propertyInfo );
+            var castResult = Expression.Convert( propertyAccess, typeof( object ) );
+
+            return Expression.Lambda<Func<object, object>>( castResult, instance ).Compile();
+        }
+    }
+
+    private class BufferWriter
+    {
+        private byte[] _buffer;
+
+        private readonly Dictionary<Type, int> _typeId = new();
+        private int _nextTypeId;
+
+        public byte[] GetBuffer() => _buffer;
+        public int Length => Position;
+
+        private int Position { get; set; }
+
+        public BufferWriter( int initialSize = 512 )
+        {
+            _buffer = ArrayPool<byte>.Shared.Rent( initialSize );
+        }
+
+        public void Clear()
+        {
+            Position = 0;
+        }
+
+        public void Dispose()
+        {
+            ArrayPool<byte>.Shared.Return( _buffer );
+            _buffer = null!;
+        }
+
+        public void Write( Type type )
+        {
+            if ( type == null )
+            {
+                Write( NullBytes );
+                return;
+            }
+
+            if ( !_typeId.TryGetValue( type, out var typeId ) )
+            {
+                typeId = _nextTypeId++;
+                _typeId[type] = typeId;
+            }
+
+            Write( typeId );
+        }
+
+        public void Write( Guid value )
+        {
+            EnsureCapacity( 16 ); // Guid is 16 bytes
+            value.TryWriteBytes( _buffer.AsSpan( Position ) );
+            Position += 16;
+        }
+
+        public void Write( ReadOnlySpan<byte> data )
+        {
+            EnsureCapacity( data.Length );
+            data.CopyTo( _buffer.AsSpan( Position ) );
+            Position += data.Length;
+        }
+
+        public void Write( string value )
+        {
+            if ( value == null )
+            {
+                Write( NullBytes );
+                return;
+            }
+
+            var byteCount = Encoding.UTF8.GetByteCount( value );
+            EnsureCapacity( byteCount );
+            Encoding.UTF8.GetBytes( value, _buffer.AsSpan( Position ) );
+            Position += byteCount;
+        }
+
+        public void Write( ExpressionType type )
+        {
+            Write( (int) type );
+        }
+
+        public void Write( IConvertible convertible )
+        {
+            switch ( Type.GetTypeCode( convertible.GetType() ) )
+            {
+                case TypeCode.Boolean:
+                    EnsureCapacity( 1 );
+                    _buffer[Position++] = convertible.ToBoolean( CultureInfo.InvariantCulture ) ? (byte) 1 : (byte) 0;
+                    break;
+
+                case TypeCode.Char:
+                    EnsureCapacity( 2 );
+                    BitConverter.TryWriteBytes( _buffer.AsSpan( Position ), convertible.ToChar( CultureInfo.InvariantCulture ) );
+                    Position += 2;
+                    break;
+
+                case TypeCode.Byte:
+                case TypeCode.SByte:
+                    EnsureCapacity( 1 );
+                    _buffer[Position++] = convertible.ToByte( CultureInfo.InvariantCulture );
+                    break;
+
+                case TypeCode.Int16:
+                case TypeCode.UInt16:
+                    EnsureCapacity( 2 );
+                    BitConverter.TryWriteBytes( _buffer.AsSpan( Position ), convertible.ToInt16( CultureInfo.InvariantCulture ) );
+                    Position += 2;
+                    break;
+
+                case TypeCode.Int32:
+                case TypeCode.UInt32:
+                    EnsureCapacity( 4 );
+                    BitConverter.TryWriteBytes( _buffer.AsSpan( Position ), convertible.ToInt32( CultureInfo.InvariantCulture ) );
+                    Position += 4;
+                    break;
+
+                case TypeCode.Int64:
+                case TypeCode.UInt64:
+                    EnsureCapacity( 8 );
+                    BitConverter.TryWriteBytes( _buffer.AsSpan( Position ), convertible.ToInt64( CultureInfo.InvariantCulture ) );
+                    Position += 8;
+                    break;
+
+                case TypeCode.Single:
+                    EnsureCapacity( 4 );
+                    BitConverter.TryWriteBytes( _buffer.AsSpan( Position ), convertible.ToSingle( CultureInfo.InvariantCulture ) );
+                    Position += 4;
+                    break;
+
+                case TypeCode.Double:
+                    EnsureCapacity( 8 );
+                    BitConverter.TryWriteBytes( _buffer.AsSpan( Position ), convertible.ToDouble( CultureInfo.InvariantCulture ) );
+                    Position += 8;
+                    break;
+
+                case TypeCode.DateTime:
+                    EnsureCapacity( 8 );
+                    BitConverter.TryWriteBytes( _buffer.AsSpan( Position ), convertible.ToDateTime( CultureInfo.InvariantCulture ).ToBinary() );
+                    Position += 8;
+                    break;
+
+                case TypeCode.String:
+                case TypeCode.Decimal:
+                default:
+                    var strValue = convertible.ToString( CultureInfo.InvariantCulture );
+                    var utf8Length = Encoding.UTF8.GetByteCount( strValue );
+                    EnsureCapacity( utf8Length );
+                    Encoding.UTF8.GetBytes( strValue, _buffer.AsSpan( Position ) );
+                    Position += utf8Length;
+                    break;
+            }
+        }
+
+        private void EnsureCapacity( int requiredBytes )
+        {
+            if ( Position + requiredBytes <= _buffer.Length )
+                return;
+
+            var buffer = ArrayPool<byte>.Shared.Rent( Position + requiredBytes );
+            _buffer.AsSpan( 0, Position ).CopyTo( buffer );
+            ArrayPool<byte>.Shared.Return( _buffer );
+            _buffer = buffer;
+        }
+    }
+}
+
diff --git a/src/Hyperbee.Expressions/Visitors/ExpressionMatcher.cs b/src/Hyperbee.Expressions/Visitors/ExpressionMatcher.cs
new file mode 100644
index 0000000..8e9bbd7
--- /dev/null
+++ b/src/Hyperbee.Expressions/Visitors/ExpressionMatcher.cs
@@ -0,0 +1,69 @@
+using System.Linq.Expressions;
+
+namespace Hyperbee.Expressions.Visitors;
+
+internal class ExpressionMatcher : ExpressionVisitor
+{
+    private readonly Dictionary<Expression, int> _countDictionary = [];
+    private readonly Func<Expression, bool> _matchPredicate;
+    private int _counter;
+
+    public ExpressionMatcher( Func<Expression, bool> matchPredicate )
+    {
+        _matchPredicate = matchPredicate ?? throw new ArgumentNullException( nameof( matchPredicate ) );
+    }
+
+    public int MatchCount( Expression expression )
+    {
+        if ( expression == null )
+            throw new ArgumentNullException( nameof( expression ) );
+
+        if ( _countDictionary.TryGetValue( expression, out var count ) )
+            return count;
+
+        _counter = 0;
+        Visit( expression );
+
+        return _counter;
+    }
+
+    public bool HasMatch( Expression expression )
+    {
+        return MatchCount( expression ) > 0;
+    }
+
+    public void Clear()
+    {
+        _countDictionary.Clear();
+        _counter = 0;
+    }
+
+    protected override Expression VisitLambda<T>( Expression<T> node )
+    {
+        return node;
+    }
+
+    public override Expression Visit( Expression node )
+    {
+        if ( node == null )
+            return null;
+
+        if ( _countDictionary.TryGetValue( node, out var dependencyCount ) )
+        {
+            _counter += dependencyCount;
+            return node;
+        }
+
+        var previousCounter = _counter;
+        _counter = 0;
+
+        base.Visit( node );
+
+        dependencyCount = _matchPredicate( node ) ? _counter + 1 : _counter;
+
+        _counter = previousCounter + dependencyCount;
+        _countDictionary[node] = dependencyCount;
+
+        return node;
+    }
+}
diff --git a/src/Hyperbee.Expressions/WhileExpression.cs b/src/Hyperbee.Expressions/WhileExpression.cs
index 952dd4e..891b3bb 100644
--- a/src/Hyperbee.Expressions/WhileExpression.cs
+++ b/src/Hyperbee.Expressions/WhileExpression.cs
@@ -73,12 +73,10 @@ protected override Expression VisitChildren( ExpressionVisitor visitor )
         var newTest = visitor.Visit( Test );
         var newBody = visitor.Visit( Body );
 
-        if ( newTest != Test || newBody != Body )
-        {
-            return new WhileExpression( newTest, newBody, BreakLabel, ContinueLabel );
-        }
+        if ( newTest == Test && newBody == Body )
+            return this;
 
-        return this;
+        return new WhileExpression( newTest, newBody, BreakLabel, ContinueLabel );
     }
 }
 
diff --git a/test/Hyperbee.Expressions.Benchmark/AsyncBenchmarks.cs b/test/Hyperbee.Expressions.Benchmark/AsyncBenchmarks.cs
index d2d01fa..3bc1269 100644
--- a/test/Hyperbee.Expressions.Benchmark/AsyncBenchmarks.cs
+++ b/test/Hyperbee.Expressions.Benchmark/AsyncBenchmarks.cs
@@ -1,7 +1,6 @@
 using System.Linq.Expressions;
 using BenchmarkDotNet.Attributes;
 using FastExpressionCompiler;
-
 using static System.Linq.Expressions.Expression;
 using static Hyperbee.Expressions.ExpressionExtensions;
 
@@ -13,6 +12,8 @@ public class AsyncBenchmarks
     private Func<Task<int>> _fastCompiledLambda = null!;
     private Expression<Func<Task<int>>> _lambda = null!;
 
+    private Expression _expression = null!;
+
     [GlobalSetup]
     public void Setup()
     {
@@ -22,7 +23,7 @@ public void Setup()
 
         var variable = Variable( typeof( int ), "variable" );
 
-        var asyncBlock =
+        _expression =
             BlockAsync(
                 [variable],
                 Assign( variable, Await( Call( asyncInitVariableMethodInfo ) ) ),
@@ -31,7 +32,7 @@ public void Setup()
                         Await( Call( asyncAddMethodInfo, variable, variable ) ) ) ),
                 variable );
 
-        _lambda = (Lambda<Func<Task<int>>>( asyncBlock ).Reduce() as Expression<Func<Task<int>>>)!;
+        _lambda = (Lambda<Func<Task<int>>>( _expression ).Reduce() as Expression<Func<Task<int>>>)!;
 
         _compiledLambda = _lambda.Compile();
 
@@ -39,14 +40,14 @@ public void Setup()
     }
 
     [Benchmark]
-    public async Task Hyperbee_AsyncBlock_CompileAndExecute()
+    public async Task Hyperbee_AsyncBlock_First_CompileAndExecute()
     {
         var compiled = _lambda.Compile();
         await compiled();
     }
 
     [Benchmark]
-    public async Task Hyperbee_AsyncBlock_FastCompileAndExecute()
+    public async Task Hyperbee_AsyncBlock_First_FastCompileAndExecute()
     {
         var compiled = _lambda.CompileFast();
         await compiled();
diff --git a/test/Hyperbee.Expressions.Benchmark/BenchmarkConfig.cs b/test/Hyperbee.Expressions.Benchmark/BenchmarkConfig.cs
index 05ccb98..840f3a4 100644
--- a/test/Hyperbee.Expressions.Benchmark/BenchmarkConfig.cs
+++ b/test/Hyperbee.Expressions.Benchmark/BenchmarkConfig.cs
@@ -16,6 +16,7 @@ public class Config : ManualConfig
         public Config()
         {
             AddJob( Job.ShortRun );
+
             AddExporter( MarkdownExporter.GitHub );
             AddValidator( JitOptimizationsValidator.DontFailOnError );
             AddLogger( ConsoleLogger.Default );
diff --git a/test/Hyperbee.Expressions.Benchmark/Hyperbee.Expressions.Benchmark.csproj b/test/Hyperbee.Expressions.Benchmark/Hyperbee.Expressions.Benchmark.csproj
index c9bb0d5..290fa85 100644
--- a/test/Hyperbee.Expressions.Benchmark/Hyperbee.Expressions.Benchmark.csproj
+++ b/test/Hyperbee.Expressions.Benchmark/Hyperbee.Expressions.Benchmark.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net9.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>disable</Nullable>
     <IsPackable>false</IsPackable>
@@ -10,7 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
-    <PackageReference Include="FastExpressionCompiler" Version="4.2.2" />
+    <PackageReference Include="FastExpressionCompiler" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Hyperbee.Expressions.Tests/AwaitTests.cs b/test/Hyperbee.Expressions.Tests/AwaitTests.cs
deleted file mode 100644
index 6770d52..0000000
--- a/test/Hyperbee.Expressions.Tests/AwaitTests.cs
+++ /dev/null
@@ -1,422 +0,0 @@
-using System.Linq.Expressions;
-using System.Reflection;
-
-namespace Hyperbee.Expressions.Tests;
-
-public enum ExpressionKind
-{
-    Lambda,
-    Method
-}
-
-[TestClass]
-public class AwaitTests
-{
-    private static async Task Delay()
-    {
-        await Task.Delay( 10 );
-    }
-
-    private static async Task<int> GetNumberAsync()
-    {
-        await Task.Delay( 10 );
-        return 42;
-    }
-
-    private static async Task<int> AddTwoNumbersAsync( int a, int b )
-    {
-        await Task.Delay( 10 );
-        return a + b;
-    }
-
-    private static async Task<int> AddThreeNumbersAsync( int a, int b, int c )
-    {
-        await Task.Delay( 10 );
-        return a + b + c;
-    }
-
-    private static async Task<string> SayHelloAsync( int a )
-    {
-        await Task.Delay( 10 );
-        return $"Hello {a}";
-    }
-
-    private static int IncrementValue( int a )
-    {
-        return a + 1;
-    }
-
-    private static async Task<int> ThrowExceptionAsync()
-    {
-        await Task.Delay( 10 );
-        throw new InvalidOperationException( "Simulated exception." );
-    }
-
-    private static MethodInfo GetMethodInfo( string name )
-    {
-        return typeof( AwaitTests ).GetMethod( name, BindingFlags.Static | BindingFlags.NonPublic )!;
-    }
-
-    private static Expression GetAsyncExpression( ExpressionKind kind, MethodInfo methodInfo, params Expression[] arguments )
-    {
-        switch ( kind )
-        {
-            case ExpressionKind.Lambda:
-                var (lambdaExpression, lambdaArguments) = GetLambdaExpression( methodInfo, arguments );
-                return Expression.Invoke( lambdaExpression, lambdaArguments );
-
-            case ExpressionKind.Method:
-                return Expression.Call( methodInfo, arguments );
-
-            default:
-                throw new ArgumentOutOfRangeException( nameof( kind ) );
-        }
-    }
-
-    private static (LambdaExpression Lambda, Expression[] Arguments) GetLambdaExpression( MethodInfo methodInfo, params Expression[] arguments )
-    {
-        if ( methodInfo.GetParameters().Length != arguments.Length )
-        {
-            throw new ArgumentException( "Number of arguments does not match the number of method parameters." );
-        }
-
-        var parameterExpressions = arguments.OfType<ParameterExpression>().ToArray();
-        var lambdaArguments = parameterExpressions.Cast<Expression>().ToArray();
-
-        var callExpression = Expression.Call( methodInfo, arguments );
-        var lambdaExpression = Expression.Lambda( callExpression, parameterExpressions );
-
-        return (lambdaExpression, lambdaArguments);
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public void TestAsyncExpression_NoParameters( ExpressionKind kind )
-    {
-        var methodInfo = GetMethodInfo( nameof( GetNumberAsync ) );
-
-        var asyncExpression = GetAsyncExpression( kind, methodInfo! );
-        var awaitExpression = ExpressionExtensions.Await( asyncExpression, configureAwait: false );
-
-        var lambda = Expression.Lambda<Func<int>>( awaitExpression );
-        var compiledLambda = lambda.Compile();
-
-        var result = compiledLambda();
-        Assert.AreEqual( 42, result, "The result should be 42." );
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public void TestAsyncExpression_NoResults( ExpressionKind kind )
-    {
-        var methodInfo = GetMethodInfo( nameof( Delay ) );
-
-        var asyncExpression = GetAsyncExpression( kind, methodInfo! );
-        var awaitExpression = ExpressionExtensions.Await( asyncExpression, configureAwait: false );
-
-        var lambda = Expression.Lambda<Action>( awaitExpression );
-        var compiledLambda = lambda.Compile();
-
-        compiledLambda();
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public void TestAsyncExpression_WithParameters( ExpressionKind kind )
-    {
-        var methodInfo = GetMethodInfo( nameof( AddThreeNumbersAsync ) );
-
-        var paramExpr1 = Expression.Parameter( typeof( int ), "a" );
-        var paramExpr2 = Expression.Parameter( typeof( int ), "b" );
-        var paramExpr3 = Expression.Parameter( typeof( int ), "c" );
-
-        var asyncExpression = GetAsyncExpression( kind, methodInfo!, paramExpr1, paramExpr2, paramExpr3 );
-        var awaitExpression = ExpressionExtensions.Await( asyncExpression, configureAwait: false );
-
-        var lambda = Expression.Lambda<Func<int, int, int, int>>( awaitExpression, paramExpr1, paramExpr2, paramExpr3 );
-        var compiledLambda = lambda.Compile();
-
-        var result = compiledLambda( 10, 20, 12 );
-        Assert.AreEqual( 42, result, "The result should be 42." );
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public void TestAsyncExpression_WithConstants( ExpressionKind kind )
-    {
-        var methodInfo = GetMethodInfo( nameof( AddThreeNumbersAsync ) );
-
-        var paramExpr1 = Expression.Constant( 10 );
-        var paramExpr2 = Expression.Constant( 20 );
-        var paramExpr3 = Expression.Constant( 12 );
-
-        var asyncExpression = GetAsyncExpression( kind, methodInfo!, paramExpr1, paramExpr2, paramExpr3 );
-        var awaitExpression = ExpressionExtensions.Await( asyncExpression, configureAwait: false );
-
-        var lambda = Expression.Lambda<Func<int>>( awaitExpression );
-        var compiledLambda = lambda.Compile();
-
-        var result = compiledLambda();
-        Assert.AreEqual( 42, result, "The result should be 42." );
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public void TestAsyncExpression_WithAsyncParameter( ExpressionKind kind )
-    {
-        // var result = await SayHelloAsync( await AddTwoNumbersAsync( 10, 32 ) );
-
-        var addTwoNumbersMethod = GetMethodInfo( nameof( AddTwoNumbersAsync ) );
-        var sayHelloMethod = GetMethodInfo( nameof( SayHelloAsync ) );
-
-        var paramA = Expression.Parameter( typeof( int ), "a" );
-        var paramB = Expression.Parameter( typeof( int ), "b" );
-
-        var asyncExpressionAdd = GetAsyncExpression( kind, addTwoNumbersMethod, paramA, paramB );
-        var awaitExpressionAdd = ExpressionExtensions.Await( asyncExpressionAdd, configureAwait: false );
-
-        var asyncExpressionSayHello = GetAsyncExpression( kind, sayHelloMethod, awaitExpressionAdd );
-        var awaitExpressionSayHello = ExpressionExtensions.Await( asyncExpressionSayHello, configureAwait: false );
-
-        var lambda = Expression.Lambda<Func<int, int, string>>( awaitExpressionSayHello, paramA, paramB );
-        var compiledLambda = lambda.Compile();
-
-        var result = compiledLambda( 10, 32 );
-
-        Assert.AreEqual( "Hello 42", result, "The result should be 'Hello 42'." );
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public void TestAsyncExpression_WithMethodCallParameters( ExpressionKind kind )
-    {
-        // var result0 = IncrementValue( 11 );  
-        // var result1 = await AddThreeNumbersAsync( 10, 20, result0 );
-
-        var incrementMethodInfo = GetMethodInfo( nameof( IncrementValue ) );
-        var methodInfo = GetMethodInfo( nameof( AddThreeNumbersAsync ) );
-
-        var paramExpr1 = Expression.Parameter( typeof( int ), "a" );
-        var paramExpr2 = Expression.Parameter( typeof( int ), "b" );
-        var paramExpr3 = Expression.Parameter( typeof( int ), "c" );
-
-        var incrementValueCall = Expression.Call( incrementMethodInfo!, paramExpr3 );
-
-        var asyncExpression = GetAsyncExpression( kind, methodInfo!, paramExpr1, paramExpr2, incrementValueCall );
-        var awaitExpression = ExpressionExtensions.Await( asyncExpression, configureAwait: false );
-
-        var lambda = Expression.Lambda<Func<int, int, int, int>>( awaitExpression, paramExpr1, paramExpr2, paramExpr3 );
-        var compiledLambda = lambda.Compile();
-
-        var result = compiledLambda( 10, 20, 11 ); // Pass 10, 20, and 11 as parameters; IncrementValue will increment 11
-        Assert.AreEqual( 42, result, "The result should be 42." );
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public void TestMultipleAsyncExpressions_SeparateAwaits( ExpressionKind kind )
-    {
-        var methodInfo1 = GetMethodInfo( nameof( GetNumberAsync ) );
-        var methodInfo2 = GetMethodInfo( nameof( AddThreeNumbersAsync ) );
-
-        var paramExpr1 = Expression.Parameter( typeof( int ), "a" );
-        var paramExpr2 = Expression.Parameter( typeof( int ), "b" );
-        var paramExpr3 = Expression.Parameter( typeof( int ), "c" );
-
-        var asyncExpression1 = GetAsyncExpression( kind, methodInfo1! );
-        var asyncExpression2 = GetAsyncExpression( kind, methodInfo2!, paramExpr1, paramExpr2, paramExpr3 );
-
-        var awaitExpression1 = ExpressionExtensions.Await( asyncExpression1, configureAwait: false );
-        var awaitExpression2 = ExpressionExtensions.Await( asyncExpression2, configureAwait: false );
-
-        var lambda1 = Expression.Lambda<Func<int>>( awaitExpression1 );
-        var lambda2 = Expression.Lambda<Func<int, int, int, int>>( awaitExpression2, paramExpr1, paramExpr2, paramExpr3 );
-
-        var compiledLambda1 = lambda1.Compile();
-        var compiledLambda2 = lambda2.Compile();
-
-        var result1 = compiledLambda1();
-        var result2 = compiledLambda2( 10, 20, 12 );
-
-        Assert.AreEqual( 42, result1, "The first result should be 42." );
-        Assert.AreEqual( 42, result2, "The second result should be 42." );
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public async Task TestScopedAwaitExpressions( ExpressionKind kind )
-    {
-        var addTwoNumbersMethod = GetMethodInfo( nameof( AddTwoNumbersAsync ) );
-
-        // Create AsyncExpression for AddTwoNumbers
-        var paramA = Expression.Parameter( typeof( int ), "a" );
-        var paramB = Expression.Parameter( typeof( int ), "b" );
-
-        var asyncAddTwoNumbers = GetAsyncExpression( kind, addTwoNumbersMethod!, paramA, paramB );
-        var awaitAddTwoNumbers = ExpressionExtensions.Await( asyncAddTwoNumbers, configureAwait: false );
-
-        var resultFromAdd = Expression.Variable( typeof( int ), "resultFromAdd" );
-
-        // Create the "Hello " + resultFromAdd expression
-        var helloStringExpression = Expression.Constant( "Hello " );
-        var resultToStringExpression = Expression.Call( resultFromAdd, typeof( object ).GetMethod( "ToString", Type.EmptyTypes )! );
-        var helloConcatExpression = Expression.Call(
-            typeof( string ).GetMethod( "Concat", [typeof( string ), typeof( string )] )!,
-            helloStringExpression,
-            resultToStringExpression
-        );
-
-        // Wrap the concatenated string in Task.FromResult
-        var taskFromResultMethod = typeof( Task ).GetMethod( "FromResult" )!.MakeGenericMethod( typeof( string ) );
-        var taskWrappedExpression = Expression.Call( taskFromResultMethod, helloConcatExpression );
-
-        // Combine the expressions in a block
-        var combinedExpression = Expression.Block(
-            [resultFromAdd],
-            Expression.Assign( resultFromAdd, awaitAddTwoNumbers ),
-            taskWrappedExpression
-        );
-
-        // Compile the nested expression into a lambda and execute it
-        var lambda = Expression.Lambda<Func<int, int, Task<string>>>( combinedExpression, paramA, paramB );
-
-        var asyncLambda = Expression.Invoke( lambda, paramA, paramB );
-        var compiledLambda = Expression.Lambda<Func<int, int, Task<string>>>( asyncLambda, paramA, paramB ).Compile();
-
-        var result = await compiledLambda( 32, 10 );
-
-        // Assert the result
-        Assert.AreEqual( "Hello 42", result, "The result should be 'Hello 42'." );
-    }
-
-    [TestMethod]
-    public async Task TestMultipleAsyncExpressions_WithDeepNestingAsync()
-    {
-        var incrementExpression = ToExpression( Increment );
-
-        var paramA = Expression.Parameter( typeof( Task<int> ), "a" );
-
-        var l1 = Expression.Invoke( incrementExpression, paramA );
-        var l2 = Expression.Invoke( incrementExpression, l1 );
-        var l3 = Expression.Invoke( incrementExpression, l2 );
-
-        var compiled = Expression.Lambda<Func<Task<int>, Task<int>>>( l3, paramA ).Compile();
-        var expressionResult = await compiled( Task.FromResult( 2 ) );
-
-        var runtimeResult = await Increment( Increment( Increment( Task.FromResult( 2 ) ) ) );
-
-        Assert.AreEqual( runtimeResult, expressionResult );
-
-        return;
-
-        static Expression<Func<Task<int>, Task<int>>> ToExpression( Func<Task<int>, Task<int>> func ) => task => func( task );
-
-        static async Task<int> Increment( Task<int> previousTask )
-        {
-            int previousResult = await previousTask;
-            return previousResult + 1;
-        }
-    }
-
-    [TestMethod]
-    public async Task TestMultipleAsyncExpressions_WithDeepNestingAsyncAwait()
-    {
-        var incrementExpression = ToExpression( Increment );
-
-        var paramA = Expression.Parameter( typeof( int ), "a" );
-
-        var l1 = ExpressionExtensions.Await( Expression.Invoke( incrementExpression, paramA ), configureAwait: false );
-        var l2 = ExpressionExtensions.Await( Expression.Invoke( incrementExpression, l1 ), configureAwait: false );
-        var l3 = Expression.Invoke( incrementExpression, l2 );
-
-        var compiled = Expression.Lambda<Func<int, Task<int>>>( l3, paramA ).Compile();
-        var expressionResult = await compiled( 2 );
-
-        var runtimeResult = await Increment( await Increment( await Increment( 2 ) ) );
-
-        Assert.AreEqual( runtimeResult, expressionResult );
-
-        return;
-
-        static Expression<Func<int, Task<int>>> ToExpression( Func<int, Task<int>> func ) => task => func( task );
-
-        static async Task<int> Increment( int previous )
-        {
-            await Task.Delay( 10 );
-            return previous + 1;
-        }
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public void TestChainedAwaitExpressions( ExpressionKind kind )
-    {
-        var addTwoNumbersMethod = GetMethodInfo( nameof( AddTwoNumbersAsync ) );
-        var sayHelloMethod = GetMethodInfo( nameof( SayHelloAsync ) );
-
-        // Create AsyncExpression and AwaitExpression for AddTwoNumbers
-        var paramA = Expression.Parameter( typeof( int ), "a" );
-        var paramB = Expression.Parameter( typeof( int ), "b" );
-
-        var asyncAddTwoNumbers = GetAsyncExpression( kind, addTwoNumbersMethod!, paramA, paramB );
-        var awaitAddTwoNumbers = ExpressionExtensions.Await( asyncAddTwoNumbers, configureAwait: false );
-
-        var resultAddTwoNumbers = Expression.Variable( typeof( int ), "resultAddTwoNumbers" );
-
-        // Create AsyncExpression and AwaitExpression for SayHello
-        var asyncSayHello = GetAsyncExpression( kind, sayHelloMethod!, resultAddTwoNumbers );
-        var awaitSayHello = ExpressionExtensions.Await( asyncSayHello, configureAwait: false );
-
-        // Combine both expressions in a block
-        var combinedExpression = Expression.Block(
-            [resultAddTwoNumbers],
-            Expression.Assign( resultAddTwoNumbers, awaitAddTwoNumbers ),
-            awaitSayHello
-        );
-
-        // Compile and execute
-        var lambda = Expression.Lambda<Func<int, int, string>>( combinedExpression, paramA, paramB );
-        var compiledLambda = lambda.Compile();
-
-        var result = compiledLambda( 32, 10 );
-
-        Assert.AreEqual( "Hello 42", result, "The result should be 'Hello 42'." );
-    }
-
-    [DataTestMethod]
-    [DataRow( ExpressionKind.Lambda )]
-    [DataRow( ExpressionKind.Method )]
-    public void TestAsyncExpression_ExceptionHandling( ExpressionKind kind )
-    {
-        var methodInfo = GetMethodInfo( nameof( ThrowExceptionAsync ) );
-
-        var asyncThrowException = GetAsyncExpression( kind, methodInfo! );
-        var awaitThrowException = ExpressionExtensions.Await( asyncThrowException, configureAwait: false );
-
-        var lambda = Expression.Lambda<Func<int>>( awaitThrowException );
-        var compiledLambda = lambda.Compile();
-
-        try
-        {
-            _ = compiledLambda();
-            Assert.Fail( "An exception was not thrown." );
-        }
-        catch ( InvalidOperationException ex )
-        {
-            Assert.AreEqual( "Simulated exception.", ex.Message, "The exception message should match." );
-        }
-        catch ( Exception ex )
-        {
-            Assert.Fail( $"Unexpected exception of type {ex.GetType()} was thrown." );
-        }
-    }
-}
diff --git a/test/Hyperbee.Expressions.Tests/AwaiterTests.cs b/test/Hyperbee.Expressions.Tests/AwaiterTests.cs
new file mode 100644
index 0000000..737e588
--- /dev/null
+++ b/test/Hyperbee.Expressions.Tests/AwaiterTests.cs
@@ -0,0 +1,372 @@
+using System.Linq.Expressions;
+using System.Reflection;
+using static System.Linq.Expressions.Expression;
+using static Hyperbee.Expressions.ExpressionExtensions;
+
+namespace Hyperbee.Expressions.Tests;
+
+public enum ExpressionKind
+{
+    Lambda,
+    Method
+}
+
+[TestClass]
+public class AwaiterTests
+{
+    private static async Task Delay()
+    {
+        await Task.Delay( 10 );
+    }
+
+    private static async Task<int> GetNumberAsync()
+    {
+        await Task.Delay( 10 );
+        return 42;
+    }
+
+    private static async Task<int> AddTwoNumbersAsync( int a, int b )
+    {
+        await Task.Delay( 10 );
+        return a + b;
+    }
+
+    private static async Task<int> AddThreeNumbersAsync( int a, int b, int c )
+    {
+        await Task.Delay( 10 );
+        return a + b + c;
+    }
+
+    private static async Task<string> SayHelloAsync( int a )
+    {
+        await Task.Delay( 10 );
+        return $"Hello {a}";
+    }
+
+    private static int IncrementValue( int a )
+    {
+        return a + 1;
+    }
+
+    private static async Task<int> ThrowExceptionAsync()
+    {
+        await Task.Delay( 10 );
+        throw new InvalidOperationException( "Simulated exception." );
+    }
+
+    private static MethodInfo GetMethodInfo( string name )
+    {
+        return typeof( AwaiterTests ).GetMethod( name, BindingFlags.Static | BindingFlags.NonPublic )!;
+    }
+
+    [TestMethod]
+    public void GetAwaiterResult_NoParameters()
+    {
+        var methodInfo = GetMethodInfo( nameof( GetNumberAsync ) );
+
+        var asyncExpression = Call( methodInfo );
+        var awaitExpression = Await( asyncExpression, configureAwait: false );
+
+        var lambda = Lambda<Func<int>>( awaitExpression );
+        var compiledLambda = lambda.Compile();
+
+        var result = compiledLambda();
+        Assert.AreEqual( 42, result, "The result should be 42." );
+    }
+
+    [TestMethod]
+    public void GetAwaiterResult_NoResults()
+    {
+        var methodInfo = GetMethodInfo( nameof( Delay ) );
+
+        var asyncExpression = Call( methodInfo );
+        var awaitExpression = Await( asyncExpression, configureAwait: false );
+
+        var lambda = Lambda<Action>( awaitExpression );
+        var compiledLambda = lambda.Compile();
+
+        compiledLambda();
+    }
+
+    [TestMethod]
+    public void GetAwaiterResult_WithParameters()
+    {
+        var methodInfo = GetMethodInfo( nameof( AddThreeNumbersAsync ) );
+
+        var paramExpr1 = Parameter( typeof( int ), "a" );
+        var paramExpr2 = Parameter( typeof( int ), "b" );
+        var paramExpr3 = Parameter( typeof( int ), "c" );
+
+        var asyncExpression = Call( methodInfo!, paramExpr1, paramExpr2, paramExpr3 );
+        var awaitExpression = Await( asyncExpression, configureAwait: false );
+
+        var lambda = Lambda<Func<int, int, int, int>>( awaitExpression, paramExpr1, paramExpr2, paramExpr3 );
+        var compiledLambda = lambda.Compile();
+
+        var result = compiledLambda( 10, 20, 12 );
+        Assert.AreEqual( 42, result, "The result should be 42." );
+    }
+
+    [TestMethod]
+    public void GetAwaiterResult_WithConstants()
+    {
+        var methodInfo = GetMethodInfo( nameof( AddThreeNumbersAsync ) );
+
+        var paramExpr1 = Constant( 10 );
+        var paramExpr2 = Constant( 20 );
+        var paramExpr3 = Constant( 12 );
+
+        var asyncExpression = Call( methodInfo!, paramExpr1, paramExpr2, paramExpr3 );
+        var awaitExpression = Await( asyncExpression, configureAwait: false );
+
+        var lambda = Lambda<Func<int>>( awaitExpression );
+        var compiledLambda = lambda.Compile();
+
+        var result = compiledLambda();
+        Assert.AreEqual( 42, result, "The result should be 42." );
+    }
+
+    [TestMethod]
+    public void GetAwaiterResult_WithAsyncParameter()
+    {
+        // var result = await SayHelloAsync( await AddTwoNumbersAsync( 10, 32 ) );
+
+        var addTwoNumbersMethod = GetMethodInfo( nameof( AddTwoNumbersAsync ) );
+        var sayHelloMethod = GetMethodInfo( nameof( SayHelloAsync ) );
+
+        var paramA = Parameter( typeof( int ), "a" );
+        var paramB = Parameter( typeof( int ), "b" );
+
+        var asyncExpressionAdd = Call( addTwoNumbersMethod, paramA, paramB );
+        var awaitExpressionAdd = Await( asyncExpressionAdd, configureAwait: false );
+
+        var asyncExpressionSayHello = Call( sayHelloMethod, awaitExpressionAdd );
+        var awaitExpressionSayHello = Await( asyncExpressionSayHello, configureAwait: false );
+
+        var lambda = Lambda<Func<int, int, string>>( awaitExpressionSayHello, paramA, paramB );
+        var compiledLambda = lambda.Compile();
+
+        var result = compiledLambda( 10, 32 );
+
+        Assert.AreEqual( "Hello 42", result, "The result should be 'Hello 42'." );
+    }
+
+    [TestMethod]
+    public void GetAwaiterResult_WithMethodCallParameters()
+    {
+        // var result0 = IncrementValue( 11 );  
+        // var result1 = await AddThreeNumbersAsync( 10, 20, result0 );
+
+        var incrementMethodInfo = GetMethodInfo( nameof( IncrementValue ) );
+        var methodInfo = GetMethodInfo( nameof( AddThreeNumbersAsync ) );
+
+        var paramExpr1 = Parameter( typeof( int ), "a" );
+        var paramExpr2 = Parameter( typeof( int ), "b" );
+        var paramExpr3 = Parameter( typeof( int ), "c" );
+
+        var incrementValueCall = Call( incrementMethodInfo!, paramExpr3 );
+
+        var asyncExpression = Call( methodInfo!, paramExpr1, paramExpr2, incrementValueCall );
+        var awaitExpression = Await( asyncExpression, configureAwait: false );
+
+        var lambda = Lambda<Func<int, int, int, int>>( awaitExpression, paramExpr1, paramExpr2, paramExpr3 );
+        var compiledLambda = lambda.Compile();
+
+        var result = compiledLambda( 10, 20, 11 ); // Pass 10, 20, and 11 as parameters; IncrementValue will increment 11
+        Assert.AreEqual( 42, result, "The result should be 42." );
+    }
+
+    [TestMethod]
+    public void GetAwaiterResult_MultipleAsyncExpressions_SeparateAwaits()
+    {
+        var methodInfo1 = GetMethodInfo( nameof( GetNumberAsync ) );
+        var methodInfo2 = GetMethodInfo( nameof( AddThreeNumbersAsync ) );
+
+        var paramExpr1 = Parameter( typeof( int ), "a" );
+        var paramExpr2 = Parameter( typeof( int ), "b" );
+        var paramExpr3 = Parameter( typeof( int ), "c" );
+
+        var asyncExpression1 = Call( methodInfo1 );
+        var asyncExpression2 = Call( methodInfo2!, paramExpr1, paramExpr2, paramExpr3 );
+
+        var awaitExpression1 = Await( asyncExpression1, configureAwait: false );
+        var awaitExpression2 = Await( asyncExpression2, configureAwait: false );
+
+        var lambda1 = Lambda<Func<int>>( awaitExpression1 );
+        var lambda2 = Lambda<Func<int, int, int, int>>( awaitExpression2, paramExpr1, paramExpr2, paramExpr3 );
+
+        var compiledLambda1 = lambda1.Compile();
+        var compiledLambda2 = lambda2.Compile();
+
+        var result1 = compiledLambda1();
+        var result2 = compiledLambda2( 10, 20, 12 );
+
+        Assert.AreEqual( 42, result1, "The first result should be 42." );
+        Assert.AreEqual( 42, result2, "The second result should be 42." );
+    }
+
+    [TestMethod]
+    public async Task GetAwaiterResult_ExternAwaitExpressions()
+    {
+        var addTwoNumbersMethod = GetMethodInfo( nameof( AddTwoNumbersAsync ) );
+
+        // Create AsyncExpression for AddTwoNumbers
+        var paramA = Parameter( typeof( int ), "a" );
+        var paramB = Parameter( typeof( int ), "b" );
+
+        var asyncAddTwoNumbers = Call( addTwoNumbersMethod!, paramA, paramB );
+        var awaitAddTwoNumbers = Await( asyncAddTwoNumbers, configureAwait: false );
+
+        var resultFromAdd = Variable( typeof( int ), "resultFromAdd" );
+
+        // Create the "Hello " + resultFromAdd expression
+        var helloStringExpression = Constant( "Hello " );
+        var resultToStringExpression = Call( resultFromAdd, typeof( object ).GetMethod( "ToString", Type.EmptyTypes )! );
+        var helloConcatExpression = Call(
+            typeof( string ).GetMethod( "Concat", [typeof( string ), typeof( string )] )!,
+            helloStringExpression,
+            resultToStringExpression
+        );
+
+        // Wrap the concatenated string in Task.FromResult
+        var taskFromResultMethod = typeof( Task ).GetMethod( "FromResult" )!.MakeGenericMethod( typeof( string ) );
+        var taskWrappedExpression = Call( taskFromResultMethod, helloConcatExpression );
+
+        // Combine the expressions in a block
+        var combinedExpression = Block(
+            [resultFromAdd],
+            Assign( resultFromAdd, awaitAddTwoNumbers ),
+            taskWrappedExpression
+        );
+
+        // Compile the nested expression into a lambda and execute it
+        var lambda = Lambda<Func<int, int, Task<string>>>( combinedExpression, paramA, paramB );
+
+        var asyncLambda = Invoke( lambda, paramA, paramB );
+        var compiledLambda = Lambda<Func<int, int, Task<string>>>( asyncLambda, paramA, paramB ).Compile();
+
+        var result = await compiledLambda( 32, 10 );
+
+        // Assert the result
+        Assert.AreEqual( "Hello 42", result, "The result should be 'Hello 42'." );
+    }
+
+    [TestMethod]
+    public async Task GetAwaiterResult_MultipleAsyncExpressions_WithDeepNestingAsync()
+    {
+        var incrementExpression = ToExpression( Increment );
+
+        var paramA = Parameter( typeof( Task<int> ), "a" );
+
+        var l1 = Invoke( incrementExpression, paramA );
+        var l2 = Invoke( incrementExpression, l1 );
+        var l3 = Invoke( incrementExpression, l2 );
+
+        var compiled = Lambda<Func<Task<int>, Task<int>>>( l3, paramA ).Compile();
+        var expressionResult = await compiled( Task.FromResult( 2 ) );
+
+        var runtimeResult = await Increment( Increment( Increment( Task.FromResult( 2 ) ) ) );
+
+        Assert.AreEqual( runtimeResult, expressionResult );
+
+        return;
+
+        static Expression<Func<Task<int>, Task<int>>> ToExpression( Func<Task<int>, Task<int>> func ) => task => func( task );
+
+        static async Task<int> Increment( Task<int> previousTask )
+        {
+            int previousResult = await previousTask;
+            return previousResult + 1;
+        }
+    }
+
+    [TestMethod]
+    public async Task GetAwaiterResult_MultipleAsyncExpressions_WithDeepNestingAsyncAwait()
+    {
+        var incrementExpression = ToExpression( Increment );
+
+        var paramA = Parameter( typeof( int ), "a" );
+
+        var l1 = Await( Invoke( incrementExpression, paramA ), configureAwait: false );
+        var l2 = Await( Invoke( incrementExpression, l1 ), configureAwait: false );
+        var l3 = Invoke( incrementExpression, l2 );
+
+        var compiled = Lambda<Func<int, Task<int>>>( l3, paramA ).Compile();
+        var expressionResult = await compiled( 2 );
+
+        var runtimeResult = await Increment( await Increment( await Increment( 2 ) ) );
+
+        Assert.AreEqual( runtimeResult, expressionResult );
+
+        return;
+
+        static Expression<Func<int, Task<int>>> ToExpression( Func<int, Task<int>> func ) => task => func( task );
+
+        static async Task<int> Increment( int previous )
+        {
+            await Task.Delay( 10 );
+            return previous + 1;
+        }
+    }
+
+    [TestMethod]
+    public void GetAwaiterResult_ChainedAwaitExpressions()
+    {
+        var addTwoNumbersMethod = GetMethodInfo( nameof( AddTwoNumbersAsync ) );
+        var sayHelloMethod = GetMethodInfo( nameof( SayHelloAsync ) );
+
+        // Create AsyncExpression and AwaitExpression for AddTwoNumbers
+        var paramA = Parameter( typeof( int ), "a" );
+        var paramB = Parameter( typeof( int ), "b" );
+
+        var asyncAddTwoNumbers = Call( addTwoNumbersMethod!, paramA, paramB );
+        var awaitAddTwoNumbers = Await( asyncAddTwoNumbers, configureAwait: false );
+
+        var resultAddTwoNumbers = Variable( typeof( int ), "resultAddTwoNumbers" );
+
+        // Create AsyncExpression and AwaitExpression for SayHello
+        var asyncSayHello = Call( sayHelloMethod!, resultAddTwoNumbers );
+        var awaitSayHello = Await( asyncSayHello, configureAwait: false );
+
+        // Combine both expressions in a block
+        var combinedExpression = Block(
+            [resultAddTwoNumbers],
+            Assign( resultAddTwoNumbers, awaitAddTwoNumbers ),
+            awaitSayHello
+        );
+
+        // Compile and execute
+        var lambda = Lambda<Func<int, int, string>>( combinedExpression, paramA, paramB );
+        var compiledLambda = lambda.Compile();
+
+        var result = compiledLambda( 32, 10 );
+
+        Assert.AreEqual( "Hello 42", result, "The result should be 'Hello 42'." );
+    }
+
+    [TestMethod]
+    public void GetAwaiterResult_ExceptionHandling()
+    {
+        var methodInfo = GetMethodInfo( nameof( ThrowExceptionAsync ) );
+
+        var asyncThrowException = Call( methodInfo );
+        var awaitThrowException = Await( asyncThrowException, configureAwait: false );
+
+        var lambda = Lambda<Func<int>>( awaitThrowException );
+        var compiledLambda = lambda.Compile();
+
+        try
+        {
+            _ = compiledLambda();
+            Assert.Fail( "An exception was not thrown." );
+        }
+        catch ( InvalidOperationException ex )
+        {
+            Assert.AreEqual( "Simulated exception.", ex.Message, "The exception message should match." );
+        }
+        catch ( Exception ex )
+        {
+            Assert.Fail( $"Unexpected exception of type {ex.GetType()} was thrown." );
+        }
+    }
+}
diff --git a/test/Hyperbee.Expressions.Tests/BlockAsyncBasicTests.cs b/test/Hyperbee.Expressions.Tests/BlockAsyncBasicTests.cs
index 7c93253..ed82457 100644
--- a/test/Hyperbee.Expressions.Tests/BlockAsyncBasicTests.cs
+++ b/test/Hyperbee.Expressions.Tests/BlockAsyncBasicTests.cs
@@ -1,4 +1,6 @@
 using System.Linq.Expressions;
+using System.Reflection;
+using Hyperbee.Expressions.Tests.TestSupport;
 using static System.Linq.Expressions.Expression;
 using static Hyperbee.Expressions.ExpressionExtensions;
 
@@ -7,11 +9,16 @@ namespace Hyperbee.Expressions.Tests;
 [TestClass]
 public class BlockAsyncBasicTests
 {
-    [TestMethod]
-    public async Task BlockAsync_ShouldAwaitSuccessfully_WithCompletedTask()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAwaitSuccessfully_WithCompletedTask( bool immediateFlag )
     {
         // Arrange
-        var block = BlockAsync( Await( Constant( Task.FromResult( 1 ) ) ) );
+        var block = BlockAsync( Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) ) );
         var lambda = Lambda<Func<Task<int>>>( block );
         var compiledLambda = lambda.Compile();
 
@@ -22,6 +29,30 @@ public async Task BlockAsync_ShouldAwaitSuccessfully_WithCompletedTask()
         Assert.AreEqual( 1, result );
     }
 
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAwaitMultipleSuccessfully_WithCompletedTask( bool immediateFlag )
+    {
+        // Arrange
+        var block = BlockAsync( Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) ),
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 2 )
+                    ) ) );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        //Assert
+        Assert.AreEqual( 2, result );
+    }
+
     [TestMethod]
     public async Task BlockAsync_ShouldAwaitSuccessfully_WithDelayedTask()
     {
@@ -38,14 +69,23 @@ public async Task BlockAsync_ShouldAwaitSuccessfully_WithDelayedTask()
         Assert.AreEqual( 5, result );
     }
 
-    [TestMethod]
-    public async Task BlockAsync_ShouldAwaitMultipleTasks_WithDifferentResults()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAwaitMultipleTasks_WithDifferentResults( bool immediateFlag )
     {
         // Arrange
         var block = BlockAsync(
-            Await( Constant( Task.FromResult( 1 ) ) ),
-            Await( Constant( Task.FromResult( 2 ) ) )
+            Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) ),
+            Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 2 )
+                    ) )
         );
+
         var lambda = Lambda<Func<Task<int>>>( block );
         var compiledLambda = lambda.Compile();
 
@@ -88,15 +128,17 @@ public async Task BlockAsync_ShouldHandleCanceledTask_WithCancellation()
         await compiledLambda();
     }
 
-    [TestMethod]
-    public async Task BlockAsync_ShouldAwaitNestedBlockAsync_WithNestedTasks()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAwaitNestedBlockAsync_WithNestedTasks( bool immediateFlag )
     {
         // Arrange
         var innerBlock = BlockAsync(
-            Await( Constant( Task.FromResult( 2 ) ) )
+            Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 2 ) ) )
         );
         var block = BlockAsync(
-            Await( Constant( Task.FromResult( 1 ) ) ),
+            Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 1 ) ) ),
             Await( innerBlock )
         );
         var lambda = Lambda<Func<Task<int>>>( block );
@@ -106,16 +148,87 @@ public async Task BlockAsync_ShouldAwaitNestedBlockAsync_WithNestedTasks()
         var result = await compiledLambda();
 
         // Assert
-        Assert.AreEqual( 2, result ); // Result from the nested block
+        Assert.AreEqual( 2, result );
     }
 
-    [TestMethod]
-    public async Task BlockAsync_ShouldHandleSyncAndAsync_WithMixedOperations()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAwaitNestedBlockAsync_WithNestedLambdas( bool immediateFlag )
+    {
+        // Arrange
+        var innerBlock = Lambda<Func<Task<int>>>(
+            BlockAsync(
+                Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 2 ) ) )
+            )
+        );
+
+        var block = BlockAsync(
+            Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 1 ) ) ),
+            Await( Invoke( innerBlock ) )
+        );
+
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 2, result );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldShareVariablesBetweenBlocks_WithNestedAwaits( bool immediateFlag )
+    {
+        // Arrange
+        var var1 = Variable( typeof( int ), "var1" );
+        var var2 = Variable( typeof( int ), "var2" );
+
+        // uses variables from both outer blocks
+        var mostInnerBlock = Lambda<Func<Task>>(
+            BlockAsync(
+                Assign( var1, Add( var1, var2 ) ),
+                Await( AsyncHelper.Completable(
+                        Constant( immediateFlag )
+                    ) )
+            ) );
+
+        var innerBlock = Lambda<Func<Task<int>>>(
+            BlockAsync(
+                [var2], // in scoped here and most inner block
+                Assign( var2, Add( var1, Constant( 1 ) ) ),
+                Await( Invoke( mostInnerBlock ) ),
+                var1
+            ) );
+
+        var block = BlockAsync(
+            [var1], // in scope for all blocks
+            Assign( var1, Constant( 3 ) ),
+            Await( Invoke( innerBlock ) )
+        );
+
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 7, result );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldHandleSyncAndAsync_WithMixedOperations( bool immediateFlag )
     {
         // Arrange
         var block = BlockAsync(
             Constant( 10 ),
-            Await( Constant( Task.FromResult( 20 ) ) )
+            Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 20 ) ) )
         );
         var lambda = Lambda<Func<Task<int>>>( block );
         var compiledLambda = lambda.Compile();
@@ -142,8 +255,35 @@ public async Task BlockAsync_ShouldAwaitSuccessfully_WithTask()
         Assert.IsTrue( true ); // If no exception, the test is successful
     }
 
-    [TestMethod]
-    public async Task BlockAsync_ShouldPreserveVariableAssignment_BeforeAndAfterAwait()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAwaitSuccessfully_WithReturnLabel( bool immediateFlag )
+    {
+        // Arrange
+        var returnLabel = Label( typeof( int ) );
+        var block = BlockAsync(
+            IfThenElse(
+                Constant( true ),
+                Return( returnLabel, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 10 ) ) ) ),
+                Return( returnLabel, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 20 ) ) ) )
+            ),
+            Label( returnLabel, Constant( 30 ) )
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda(); // Should complete without exception
+
+        // Assert
+        Assert.AreEqual( 10, result ); // The last operation is asynchronous and returns 10
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldPreserveVariableAssignment_BeforeAndAfterAwait( bool immediateFlag )
     {
         // Arrange
         var resultValue = Parameter( typeof( int ), "result" );
@@ -151,7 +291,9 @@ public async Task BlockAsync_ShouldPreserveVariableAssignment_BeforeAndAfterAwai
         var block = BlockAsync(
             [resultValue],
             Assign( resultValue, Constant( 5 ) ),
-            Await( Constant( Task.Delay( 100 ) ) ),
+            Await( AsyncHelper.Completable(
+                        Constant( immediateFlag )
+                    ) ),
             Assign( resultValue, Add( resultValue, Constant( 10 ) ) ),
             resultValue // Return the result
         );
@@ -166,8 +308,10 @@ public async Task BlockAsync_ShouldPreserveVariableAssignment_BeforeAndAfterAwai
         Assert.AreEqual( 15, result );
     }
 
-    [TestMethod]
-    public async Task BlockAsync_ShouldPreserveVariablesInNestedBlock_WithAwaits()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldPreserveVariablesInNestedBlock_WithAwaits( bool immediateFlag )
     {
         // Arrange
         // NOTE: this test is also verifying the hoisting visitor and reuse of names
@@ -185,7 +329,7 @@ public async Task BlockAsync_ShouldPreserveVariablesInNestedBlock_WithAwaits()
                 Block(
                     Assign( otherValue1, Condition( Constant( false ), Constant( 100 ), Block( Constant( 150 ) ) ) ),
                     Assign( otherValue2, Constant( "200" ) ),
-                    Await( Constant( Task.Delay( 100 ) ) ),
+                    Await( AsyncHelper.Completable( Constant( immediateFlag ) ) ),
                     innerValue ),
                 Condition( Constant( false ), Assign( innerValue, Constant( "200" ) ), Assign( otherValue2, Constant( "250" ) ) )
             ),
@@ -201,7 +345,7 @@ public async Task BlockAsync_ShouldPreserveVariablesInNestedBlock_WithAwaits()
             outerValue
         );
 
-        var lambda = Lambda<Func<int, Task<int>>>( block, [outerValue] );
+        var lambda = Lambda<Func<int, Task<int>>>( block, outerValue );
         var compiledLambda = lambda.Compile();
 
         // Act
@@ -238,4 +382,250 @@ public async Task BlockAsync_ShouldPreserveVariables_WithNestedAwaits()
         // Assert
         Assert.AreEqual( 10, result );
     }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAllowLambdaParameters( bool immediateFlag )
+    {
+        var var1 = Variable( typeof( int ), "var1" );
+        var param1 = Parameter( typeof( Func<Task<int>> ), "param1" );
+
+        var parameterAsync = Lambda<Func<Task<int>>>(
+            BlockAsync(
+                Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 15 )
+                    ) )
+            )
+        );
+
+        var innerLambda = Lambda<Func<Func<Task<int>>, Task<int>>>(
+            BlockAsync(
+                [var1],
+                Assign( var1, Await( Invoke( param1 ) ) ),
+                var1
+            ),
+            parameters: [param1]
+        );
+
+        var asyncBlock = BlockAsync(
+            Await( Invoke( innerLambda, parameterAsync ) )
+        );
+
+        var lambda = Lambda<Func<Task<int>>>( asyncBlock );
+
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 15, result );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAllowParallelBlocks_WithTaskWhenAll( bool immediateFlag )
+    {
+        // Arrange
+        var tracker = Variable( typeof( int[] ), "tracker" );
+        var temp = Variable( typeof( int ), "temp" );
+
+        var tasks = Variable( typeof( List<Task> ), "tasks" );
+        var i = Variable( typeof( int ), "i" );
+
+        var delayMethod = typeof( Task ).GetMethod( nameof( Task.Delay ), BindingFlags.Public | BindingFlags.Static, [typeof( int )] );
+
+        var taskRun = Call(
+            typeof( Task ).GetMethod( nameof( Task.Run ), [typeof( Func<Task> )] )!,
+            Lambda<Func<Task>>(
+                BlockAsync(
+                    Await( Call( delayMethod, Constant( 10 ) ) ),
+                    Assign( ArrayAccess( tracker, temp ), temp )
+                )
+            )
+        );
+
+        var initIncrement = Assign( i, Constant( 0 ) );
+        var condition = LessThan( i, Constant( 5 ) );
+        var iteration = PostIncrementAssign( i );
+
+        var block = BlockAsync(
+            [tracker, tasks, i],
+            Assign( tracker, NewArrayBounds( typeof( int ), Constant( 5 ) ) ),
+            Assign( tasks, New( typeof( List<Task> ).GetConstructors()[0] ) ),
+            For( initIncrement, condition, iteration,
+                Block(
+                    [temp],
+                    Assign( temp, i ),
+                    Call( tasks, typeof( List<Task> ).GetMethod( nameof( List<Task>.Add ) ), taskRun )
+                )
+            ),
+            Await( Call( typeof( Task ).GetMethod( nameof( Task.WhenAll ), [typeof( IEnumerable<Task> )] ), tasks ), false ),
+            tracker
+        );
+
+        var lambda = Lambda<Func<Task<int[]>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 5, result.Length );
+        Assert.AreEqual( 0, result[0] );
+        Assert.AreEqual( 1, result[1] );
+        Assert.AreEqual( 2, result[2] );
+        Assert.AreEqual( 3, result[3] );
+        Assert.AreEqual( 4, result[4] );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAllowNestedBlocks_WithoutAsync( bool immediateFlag )
+    {
+        // Arrange
+        var innerVar = Variable( typeof( int ), "innerVar" );
+        var middleVar = Variable( typeof( int ), "middleVar" );
+        var outerVar = Variable( typeof( int ), "outerVar" );
+
+        var blockAsync = BlockAsync(
+            [outerVar],
+            Block(
+                [middleVar],
+                Await(
+                    BlockAsync(
+                        [innerVar],
+                        Assign( outerVar, Await( AsyncHelper.Completable(
+                            Constant( immediateFlag ),
+                            Constant( 3 )
+                        ) ) ),
+                        Assign( innerVar, Constant( 1 ) ),
+                        Assign( middleVar, Constant( 2 ) )
+                    )
+                ),
+                Assign( middleVar, Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 4 )
+                    ) ) ),
+                Assign( outerVar, Add( outerVar, middleVar ) )
+            ),
+            Await(
+                AsyncHelper.Completable( Constant( immediateFlag ) )
+            ),
+            outerVar
+        );
+
+        // Act
+        var lambda = Lambda<Func<Task<int>>>( blockAsync );
+
+        var compiledLambda = lambda.Compile();
+
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 7, result );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAwaitSuccessfully_WithBlockConditional( bool immediateFlag )
+    {
+        // Arrange
+        var block = BlockAsync(
+            Block(
+                Constant( 5 ),
+                Condition( Constant( true ),
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) ),
+                    Constant( 0 )
+                )
+            )
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 1, result );
+    }
+
+    public class TestContext
+    {
+        public int Id { get; set; }
+    }
+
+    private sealed class Disposable( Action dispose ) : IDisposable
+    {
+        public static readonly ConstructorInfo ConstructorInfo = typeof( Disposable ).GetConstructors()[0];
+
+        private int _disposed;
+        private Action Disposer { get; } = dispose;
+
+        public void Dispose()
+        {
+            if ( Interlocked.CompareExchange( ref _disposed, 1, 0 ) == 0 )
+                Disposer.Invoke();
+        }
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task BlockAsync_ShouldAwaitSuccessfully_WithNestedLambdaArgument( bool immediateFlag )
+    {
+        // Arrange
+        var control = Constant( new TestContext() );
+        var idVariable = Variable( typeof( int ), "originalId" );
+        var idProperty = Property( control, "Id" );
+        var exception = Variable( typeof( Exception ), "exception" );
+
+        var disposableBlock = Block(
+            [idVariable],
+            Assign( idVariable, idProperty ),
+            TryCatch(
+                Block(
+                    Assign( idProperty, Constant( 10 ) ),
+                    New( Disposable.ConstructorInfo,
+                        Lambda<Action>(
+                            Block(
+                                Assign( idProperty, idVariable )
+                            )
+                        ) )
+                ),
+                Catch(
+                    exception,
+                    Block(
+                        [exception],
+                        Assign( idProperty, idVariable ),
+                        Throw( exception, typeof( Disposable ) )
+                    )
+                )
+            )
+        );
+
+        // Act
+        var lambda = Lambda<Func<Task<int>>>( BlockAsync(
+             Using( disposableBlock,
+                 Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 3 )
+                    ) ) )
+             ) );
+
+        var compiledLambda = lambda.Compile();
+
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 3, result );
+    }
 }
diff --git a/test/Hyperbee.Expressions.Tests/BlockAsyncConditionalTests.cs b/test/Hyperbee.Expressions.Tests/BlockAsyncConditionalTests.cs
index a873d8a..8e1077a 100644
--- a/test/Hyperbee.Expressions.Tests/BlockAsyncConditionalTests.cs
+++ b/test/Hyperbee.Expressions.Tests/BlockAsyncConditionalTests.cs
@@ -1,4 +1,5 @@
-using static System.Linq.Expressions.Expression;
+using Hyperbee.Expressions.Tests.TestSupport;
+using static System.Linq.Expressions.Expression;
 using static Hyperbee.Expressions.ExpressionExtensions;
 
 namespace Hyperbee.Expressions.Tests;
@@ -6,14 +7,21 @@ namespace Hyperbee.Expressions.Tests;
 [TestClass]
 public class BlockAsyncConditionalTests
 {
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenCondition()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenCondition( bool immediateFlag )
     {
         // Arrange: Condition depends on awaited value
-        var condition = Await( Constant( Task.FromResult( true ) ) );
+        var condition = Await( AsyncHelper.Completable(
+            Constant( immediateFlag ),
+            Constant( true )
+        ) );
+
         var block = BlockAsync(
             IfThen( condition, Constant( 1 ) )
         );
+
         var lambda = Lambda<Func<Task>>( block );
         var compiledLambda = lambda.Compile();
 
@@ -24,14 +32,51 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenCondition()
         Assert.IsTrue( true ); // No exception means condition and block executed successfully
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenElseTrueBranch()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithConditionalAssignment( bool immediateFlag )
+    {
+        // Arrange: IfTrue branch contains an awaited task
+        var var = Variable( typeof( int ), "var" );
+        var condition = Constant( true );
+
+        var block = BlockAsync(
+            [var],
+            Assign( var,
+                Condition( condition,
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) ),
+                    Constant( 0 )
+                )
+            ),
+            var
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 1, result );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenElseTrueBranch( bool immediateFlag )
     {
         // Arrange: IfTrue branch contains an awaited task
         var condition = Constant( true );
         var block = BlockAsync(
             Condition( condition,
-                Await( Constant( Task.FromResult( 1 ) ) ),
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 1 )
+                ) ),
                 Constant( 0 )
             )
         );
@@ -45,15 +90,20 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenElseTrueBranch()
         Assert.AreEqual( 1, result );
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenElseFalseBranch()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenElseFalseBranch( bool immediateFlag )
     {
         // Arrange: IfFalse branch contains an awaited task
         var condition = Constant( false );
         var block = BlockAsync(
             Condition( condition,
                 Constant( 0 ),
-                Await( Constant( Task.FromResult( 2 ) ) )
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 2 )
+                ) )
             )
         );
         var lambda = Lambda<Func<Task<int>>>( block );
@@ -66,14 +116,21 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenElseFalseBranch()
         Assert.AreEqual( 2, result );
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithConditionalInTest()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithConditionalInTest( bool immediateFlag )
     {
         // Arrange: Test depends on awaited value
-        var test = Await( Constant( Task.FromResult( true ) ) );
+        var test = Await( AsyncHelper.Completable(
+            Constant( immediateFlag ),
+            Constant( true )
+        ) );
+
         var block = BlockAsync(
             Condition( test, Constant( 1 ), Constant( 0 ) )
         );
+
         var lambda = Lambda<Func<Task<int>>>( block );
         var compiledLambda = lambda.Compile();
 
@@ -84,15 +141,23 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithConditionalInTest()
         Assert.AreEqual( 1, result );
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInTrueAndFalseBranches()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInTrueAndFalseBranches( bool immediateFlag )
     {
         // Arrange: Both branches return values from awaited tasks
         var condition = Constant( true );
         var block = BlockAsync(
             Condition( condition,
-                Await( Constant( Task.FromResult( 10 ) ) ),
-                Await( Constant( Task.FromResult( 20 ) ) )
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 10 )
+                ) ),
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 20 )
+                ) )
             )
         );
         var lambda = Lambda<Func<Task<int>>>( block );
@@ -105,14 +170,22 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInTrueAndFalseBran
         Assert.AreEqual( 10, result ); // Condition is true, so the true branch should be awaited
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeAndAfterConditional()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeAndAfterConditional( bool immediateFlag )
     {
         // Arrange: Await a task before and after a conditional expression
         var block = BlockAsync(
-            Await( Constant( Task.FromResult( 5 ) ) ),
+            Await( AsyncHelper.Completable(
+                Constant( immediateFlag ),
+                Constant( 5 )
+            ) ),
             Condition( Constant( true ), Constant( 10 ), Constant( 0 ) ),
-            Await( Constant( Task.FromResult( 15 ) ) )
+            Await( AsyncHelper.Completable(
+                Constant( immediateFlag ),
+                Constant( 15 )
+            ) )
         );
         var lambda = Lambda<Func<Task<int>>>( block );
         var compiledLambda = lambda.Compile();
@@ -124,15 +197,20 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeAndAfterCond
         Assert.AreEqual( 15, result ); // Last awaited value should be 15
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithFalseCondition()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithFalseCondition( bool immediateFlag )
     {
         // Arrange: False condition should lead to the false branch being executed
         var condition = Constant( false );
         var block = BlockAsync(
             Condition( condition,
                 Constant( 10 ),
-                Await( Constant( Task.FromResult( 20 ) ) )
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 20 )
+                ) )
             )
         );
         var lambda = Lambda<Func<Task<int>>>( block );
@@ -145,18 +223,32 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithFalseCondition()
         Assert.AreEqual( 20, result ); // False branch should be awaited and return 20
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithComplexConditionalLogic()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithComplexConditionalLogic( bool immediateFlag )
     {
         // Arrange: Two conditionals where both branches return awaited values
         var block = BlockAsync(
             Condition( Constant( true ),
-                Await( Constant( Task.FromResult( 10 ) ) ),
-                Await( Constant( Task.FromResult( 5 ) ) )
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 10 )
+                ) ),
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 5 )
+                ) )
             ),
             Condition( Constant( false ),
-                Await( Constant( Task.FromResult( 1 ) ) ),
-                Await( Constant( Task.FromResult( 2 ) ) )
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 1 )
+                ) ),
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 2 )
+                ) )
             )
         );
         var lambda = Lambda<Func<Task<int>>>( block );
@@ -169,8 +261,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithComplexConditionalLogic
         Assert.AreEqual( 2, result ); // Second condition is false, so the false branch returns 2
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithNestedConditionals()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithNestedConditionals( bool immediateFlag )
     {
         // Arrange: Conditionals nested inside each other
         var block = BlockAsync(
@@ -178,8 +272,14 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithNestedConditionals()
                 Constant( true ),
                 Condition(
                     Constant( false ),
-                    Await( Constant( Task.FromResult( 5 ) ) ),
-                    Await( Constant( Task.FromResult( 10 ) ) )
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 5 )
+                    ) ),
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 10 )
+                    ) )
                 ),
                 Constant( 0 )
             )
@@ -194,16 +294,24 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithNestedConditionals()
         Assert.AreEqual( 10, result ); // The true branch contains another conditional, false branch executed
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithConditionalReturningTask()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithConditionalReturningTask( bool immediateFlag )
     {
         // Arrange: The result of the conditional is an awaited Task
         var block = BlockAsync(
             Await(
                 Condition(
                     Constant( true ),
-                    Constant( Task.FromResult( 15 ) ),
-                    Constant( Task.FromResult( 20 ) )
+                    AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 15 )
+                    ),
+                    AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 20 )
+                    )
                 )
             )
         );
@@ -235,5 +343,4 @@ public async Task AsyncBlock_ShouldThrowException_WithNullTaskInConditional()
         // Act & Assert
         await compiledLambda();
     }
-
 }
diff --git a/test/Hyperbee.Expressions.Tests/BlockAsyncLoopTests.cs b/test/Hyperbee.Expressions.Tests/BlockAsyncLoopTests.cs
index c9b20f4..c62938f 100644
--- a/test/Hyperbee.Expressions.Tests/BlockAsyncLoopTests.cs
+++ b/test/Hyperbee.Expressions.Tests/BlockAsyncLoopTests.cs
@@ -1,4 +1,5 @@
-using static System.Linq.Expressions.Expression;
+using Hyperbee.Expressions.Tests.TestSupport;
+using static System.Linq.Expressions.Expression;
 using static Hyperbee.Expressions.ExpressionExtensions;
 
 namespace Hyperbee.Expressions.Tests;
@@ -6,8 +7,10 @@ namespace Hyperbee.Expressions.Tests;
 [TestClass]
 public class BlockAsyncLoopTests
 {
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeBreak()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeBreak( bool immediateFlag )
     {
         // Arrange: Await before break in a loop
         var loopCount = Variable( typeof( int ), "count" );
@@ -17,7 +20,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeBreak()
             Assign( loopCount, Constant( 0 ) ),
             Loop(
                 Block(
-                    Await( Constant( Task.FromResult( 1 ) ) ), // Await before break
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) ), // Await before break
                     IfThen(
                         Equal( loopCount, Constant( 1 ) ),
                         Break( breakLabel )
@@ -39,8 +45,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeBreak()
         Assert.AreEqual( 1, result ); // Loop should break after 1 iteration
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitAfterLoop()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitAfterLoop( bool immediateFlag )
     {
         // Arrange: Await after break in a loop
         var loopCount = Variable( typeof( int ), "count" );
@@ -60,7 +68,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitAfterLoop()
                 breakLabel,
                 null
             ),
-            Await( Constant( Task.FromResult( 5 ) ) ), // Await after loop ends
+            Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 5 )
+                    ) ), // Await after loop ends
             loopCount
         );
         var lambda = Lambda<Func<Task<int>>>( block );
@@ -73,8 +84,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitAfterLoop()
         Assert.AreEqual( 2, result ); // Loop breaks after 2 iterations
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeContinue()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeContinue( bool immediateFlag )
     {
         // Arrange: Await before continue in a loop
         var loopCount = Variable( typeof( int ), "count" );
@@ -85,9 +98,11 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeContinue()
             Assign( loopCount, Constant( 0 ) ),
             Loop(
                 Block(
-
                     Assign( loopCount, Add( loopCount, Constant( 1 ) ) ),
-                    Await( Constant( Task.FromResult( 1 ) ) ),
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) ),
                     IfThen(
                         LessThan( loopCount, Constant( 2 ) ),
                         Continue( continueLabel )
@@ -109,8 +124,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeContinue()
         Assert.AreEqual( 2, result ); // Loop continues past the first iteration
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitAfterContinue()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitAfterContinue( bool immediateFlag )
     {
         // Arrange: Await after continue in a loop
         var loopCount = Variable( typeof( int ), "count" );
@@ -126,7 +143,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitAfterContinue()
                         Equal( loopCount, Constant( 1 ) ),
                         Continue( continueLabel )
                     ),
-                    Await( Constant( Task.FromResult( 3 ) ) ),
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 3 )
+                    ) ),
                     Break( breakLabel )
                 ),
                 breakLabel,
@@ -144,8 +164,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitAfterContinue()
         Assert.AreEqual( 2, result ); // Loop processes all iterations
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithMultipleAwaitsInLoop()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithMultipleAwaitsInLoop( bool immediateFlag )
     {
         // Arrange: Multiple awaits in a loop
         var loopCount = Variable( typeof( int ), "count" );
@@ -155,9 +177,15 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithMultipleAwaitsInLoop()
             Assign( loopCount, Constant( 0 ) ),
             Loop(
                 Block(
-                    Await( Constant( Task.FromResult( 1 ) ) ),
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) ),
                     Assign( loopCount, Add( loopCount, Constant( 1 ) ) ),
-                    Await( Constant( Task.FromResult( 3 ) ) ),
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 3 )
+                    ) ),
                     Break( breakLabel )
                 ),
                 breakLabel,
@@ -175,8 +203,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithMultipleAwaitsInLoop()
         Assert.AreEqual( 1, result ); // Loop processes all iterations
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithBreakAndContinueLabels()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithBreakAndContinueLabels( bool immediateFlag )
     {
         // Arrange: Use both breakLabel and continueLabel in the loop
         var loopCount = Variable( typeof( int ), "count" );
@@ -189,7 +219,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithBreakAndContinueLabels(
             Loop(
                 Block(
                     Assign( loopCount, Add( loopCount, Constant( 1 ) ) ),
-                    Await( Constant( Task.FromResult( 1 ) ) ),
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) ),
                     IfThen(
                         Equal( loopCount, Constant( 3 ) ),
                         Break( breakLabel )
diff --git a/test/Hyperbee.Expressions.Tests/BlockAsyncSwitchTests.cs b/test/Hyperbee.Expressions.Tests/BlockAsyncSwitchTests.cs
index adb6739..54e98f6 100644
--- a/test/Hyperbee.Expressions.Tests/BlockAsyncSwitchTests.cs
+++ b/test/Hyperbee.Expressions.Tests/BlockAsyncSwitchTests.cs
@@ -1,4 +1,5 @@
-using static System.Linq.Expressions.Expression;
+using Hyperbee.Expressions.Tests.TestSupport;
+using static System.Linq.Expressions.Expression;
 using static Hyperbee.Expressions.ExpressionExtensions;
 
 namespace Hyperbee.Expressions.Tests;
@@ -6,11 +7,16 @@ namespace Hyperbee.Expressions.Tests;
 [TestClass]
 public class BlockAsyncSwitchTests
 {
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchValue()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchValue( bool immediateFlag )
     {
         // Arrange: Await in the switch value
-        var switchValue = Await( Constant( Task.FromResult( 1 ) ) );
+        var switchValue = Await( AsyncHelper.Completable(
+            Constant( immediateFlag ),
+            Constant( 1 )
+        ) );
         var block = BlockAsync(
             Switch(
                 switchValue,
@@ -29,15 +35,20 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchValue()
         Assert.AreEqual( 10, result ); // Awaited switch value should match the first case
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInDefaultBody()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInDefaultBody( bool immediateFlag )
     {
         // Arrange: Default case contains an awaited task
         var switchValue = Constant( 3 ); // No case matches this value
         var block = BlockAsync(
             Switch(
                 switchValue,
-                Await( Constant( Task.FromResult( 99 ) ) ), // Default body
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 99 )
+                ) ), // Default body
                 SwitchCase( Constant( 10 ), Constant( 1 ) ),
                 SwitchCase( Constant( 20 ), Constant( 2 ) )
             )
@@ -52,8 +63,10 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInDefaultBody()
         Assert.AreEqual( 99, result ); // Default body should return 99
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchCaseBody()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchCaseBody( bool immediateFlag )
     {
         // Arrange: One of the case bodies contains an awaited task
         var switchValue = Constant( 1 );
@@ -61,7 +74,13 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchCaseBody()
             Switch(
                 switchValue,
                 Constant( 0 ),
-                SwitchCase( Await( Constant( Task.FromResult( 100 ) ) ), Constant( 1 ) ),
+                SwitchCase(
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 100 )
+                    ) ),
+                    Constant( 1 )
+                ),
                 SwitchCase( Constant( 200 ), Constant( 2 ) )
             )
         );
@@ -75,16 +94,24 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchCaseBody()
         Assert.AreEqual( 100, result ); // Case 1 body should be awaited and return 100
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchValueAndCaseBody()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchValueAndCaseBody( bool immediateFlag )
     {
         // Arrange: Await both in switch value and case body
-        var switchValue = Await( Constant( Task.FromResult( 2 ) ) );
+        var switchValue = Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 2 ) ) );
         var block = BlockAsync(
             Switch(
                 switchValue,
                 Constant( 0 ),
-                SwitchCase( Await( Constant( Task.FromResult( 50 ) ) ), Constant( 2 ) ),
+                SwitchCase(
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 50 )
+                    ) ),
+                    Constant( 2 )
+                ),
                 SwitchCase( Constant( 20 ), Constant( 3 ) )
             )
         );
@@ -98,15 +125,23 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInSwitchValueAndCa
         Assert.AreEqual( 50, result ); // Case 2 body should be awaited and return 50
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithNestedSwitchesAndAwaits()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithNestedSwitchesAndAwaits( bool immediateFlag )
     {
         // Arrange: Outer and inner switch cases involve awaited tasks
         var switchValue = Constant( 1 );
         var nestedSwitch = Switch(
             Constant( 1 ),
             Constant( 0 ),
-            SwitchCase( Await( Constant( Task.FromResult( 30 ) ) ), Constant( 1 ) ),
+            SwitchCase(
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 30 )
+                ) ),
+                Constant( 1 )
+            ),
             SwitchCase( Constant( 50 ), Constant( 2 ) )
         );
 
@@ -127,16 +162,25 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithNestedSwitchesAndAwaits
         Assert.AreEqual( 30, result ); // First case of nested switch should return 30
     }
 
-    [TestMethod]
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
     [ExpectedException( typeof( ArgumentException ) )]
-    public async Task AsyncBlock_ShouldThrowException_WithAwaitInSwitchCaseTestValues()
+    public async Task AsyncBlock_ShouldThrowException_WithAwaitInSwitchCaseTestValues( bool immediateFlag )
     {
         // Arrange: Switch case test values cannot contain awaited tasks
         var block = Switch(
             Constant( 1 ),
             Constant( 0 ),
-            SwitchCase( Constant( 10 ),
-                Await( BlockAsync( Await( Constant( Task.FromResult( 1 ) ) ) ) ) ),
+            SwitchCase(
+                Constant( 10 ),
+                Await( BlockAsync(
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 1 )
+                    ) )
+                ) )
+            ),
             SwitchCase( Constant( 20 ), Constant( 2 ) )
         );
         var lambda = Lambda<Func<Task<int>>>( block );
@@ -146,12 +190,17 @@ public async Task AsyncBlock_ShouldThrowException_WithAwaitInSwitchCaseTestValue
         await compiledLambda();
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldUseAwaitedValue_WithComplexExpressionInSwitchTestValues()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldUseAwaitedValue_WithComplexExpressionInSwitchTestValues( bool immediateFlag )
     {
         // Arrange: Complex expression affects the switch value
         var switchValue = Add(
-            Await( Constant( Task.FromResult( 2 ) ) ),
+            Await( AsyncHelper.Completable(
+                Constant( immediateFlag ),
+                Constant( 2 )
+            ) ),
             Constant( 1 )
         );
         var block = BlockAsync(
@@ -196,19 +245,24 @@ public async Task AsyncBlock_ShouldHandleTaskDelaySuccessfully_InSwitchCase()
         Assert.AreEqual( 100, result ); // Awaiting a delayed task should return 100 after completion
     }
 
-    [TestMethod]
-    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeAndAfterSwitch()
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitBeforeAndAfterSwitch( bool immediateFlag )
     {
         // Arrange: Awaiting tasks before and after the switch expression
         var block = BlockAsync(
-            Await( Constant( Task.FromResult( 5 ) ) ),
+            Await( AsyncHelper.Completable(
+                Constant( immediateFlag ),
+                Constant( 5 )
+            ) ),
             Switch(
                 Constant( 1 ),
                 Constant( 0 ),
                 SwitchCase( Constant( 10 ), Constant( 1 ) ),
                 SwitchCase( Constant( 20 ), Constant( 2 ) )
             ),
-            Await( Constant( Task.FromResult( 15 ) ) )
+            Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 15 ) ) )
         );
         var lambda = Lambda<Func<Task<int>>>( block );
         var compiledLambda = lambda.Compile();
diff --git a/test/Hyperbee.Expressions.Tests/BlockAsyncTryCatchTests.cs b/test/Hyperbee.Expressions.Tests/BlockAsyncTryCatchTests.cs
index b22047d..754860c 100644
--- a/test/Hyperbee.Expressions.Tests/BlockAsyncTryCatchTests.cs
+++ b/test/Hyperbee.Expressions.Tests/BlockAsyncTryCatchTests.cs
@@ -1,318 +1,366 @@
-using static System.Linq.Expressions.Expression;
+using Hyperbee.Expressions.Tests.TestSupport;
+using static System.Linq.Expressions.Expression;
 using static Hyperbee.Expressions.ExpressionExtensions;
 
-namespace Hyperbee.Expressions.Tests
+namespace Hyperbee.Expressions.Tests;
+
+[TestClass]
+public class BlockAsyncTryCatchTests
 {
-    [TestClass]
-    public class BlockAsyncTryCatchTests
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInTryBlock( bool immediateFlag )
     {
-        [TestMethod]
-        public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInTryBlock()
-        {
-            // Arrange: Await in the try block
-            var exceptionParam = Parameter( typeof( Exception ), "ex" );
-            var block = BlockAsync(
-                TryCatch(
-                    Await( Constant( Task.FromResult( 10 ) ) ),
-                    Catch( exceptionParam, Constant( 0 ) )
-                )
-            );
-            var lambda = Lambda<Func<Task<int>>>( block );
-            var compiledLambda = lambda.Compile();
-
-            // Act
-            var result = await compiledLambda();
-
-            // Assert
-            Assert.AreEqual( 10, result );
-        }
-
-        [TestMethod]
-        public async Task AsyncBlock_ShouldCatchExceptionSuccessfully_WithAwaitInCatchBlock()
-        {
-            // Arrange: Await in the catch block
-            var exceptionParam = Parameter( typeof( Exception ), "ex" );
-            var resultValue = Parameter( typeof( int ) );
-            var block = BlockAsync(
-                [resultValue],
-                TryCatch(
-                    Block(
-                        Throw( Constant( new Exception() ) ),
-                        Constant( 1 )
-                    ),
-                    Catch(
-                        exceptionParam,
-                        Assign( resultValue, Await( Constant( Task.FromResult( 99 ) ) ) )
-                    )
-                ),
-                resultValue
-            );
-            var lambda = Lambda<Func<Task<int>>>( block );
-            var compiledLambda = lambda.Compile();
-
-            // Act
-            var result = await compiledLambda();
-
-            // Assert
-            Assert.AreEqual( 99, result );
-
-        }
-
-        [TestMethod]
-        public async Task AsyncBlock_ShouldHandleExceptionSuccessfully_WithTryCatchFinally()
-        {
-            // Arrange: Await in both catch and finally blocks
-            var exceptionParam = Parameter( typeof( Exception ), "ex" );
-            var resultValue = Parameter( typeof( int ) );
-            var block = BlockAsync(
-                [resultValue],
-                TryCatchFinally(
-                    Block(
-                        Throw( Constant( new Exception() ) ),
-                        Constant( 1 )
-                    ),
-                    Assign( resultValue,
-                        Await( Constant(
-                            Task.FromResult( 50 ) ) ) ), // This Await will still be executed after the exception
-                    Catch( exceptionParam,
-                        Assign( resultValue, Await( Constant( Task.FromResult( 30 ) ) ) )
-                    )
-                ),
-                resultValue
-            );
-            var lambda = Lambda<Func<Task<int>>>( block );
-            var compiledLambda = lambda.Compile();
-
-            // Act
-            var result = await compiledLambda();
-
-            // Assert
-            Assert.AreEqual( 50, result ); // Catch block handles the exception and returns 30
-        }
-
-        [TestMethod]
-        public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInTryAndFinallyBlocks()
-        {
-            // Arrange: Await in both try and finally blocks
-            var resultValue = Parameter( typeof( int ) );
-            var block = BlockAsync(
-                [resultValue],
-                TryFinally(
-                    Assign( resultValue, Await( Constant( Task.FromResult( 15 ) ) ) ), // Try block
-                    Assign( resultValue, Constant( 25 ) ) // Finally block
+        // Arrange: Await in the try block
+        var exceptionParam = Parameter( typeof( Exception ), "ex" );
+        var block = BlockAsync(
+            TryCatch(
+                Await( AsyncHelper.Completable(
+                    Constant( immediateFlag ),
+                    Constant( 10 )
+                ) ),
+                Catch( exceptionParam, Constant( 0 ) )
+            )
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 10, result );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldCatchExceptionSuccessfully_WithAwaitInCatchBlock( bool immediateFlag )
+    {
+        // Arrange: Await in the catch block
+        var exceptionParam = Parameter( typeof( Exception ), "ex" );
+        var resultValue = Parameter( typeof( int ) );
+        var block = BlockAsync(
+            [resultValue],
+            TryCatch(
+                Block(
+                    Throw( Constant( new Exception() ) ),
+                    Constant( 1 )
                 ),
-                resultValue
-            );
-            var lambda = Lambda<Func<Task<int>>>( block );
-            var compiledLambda = lambda.Compile();
-
-            // Act
-            var result = await compiledLambda();
-
-            // Assert
-            Assert.AreEqual( 25, result ); // Catch block handles the exception and returns 30
-        }
-
-        [TestMethod]
-        public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInTryCatchAndFinallyBlocks()
-        {
-            // Arrange: Await in Try, Catch, and Finally blocks
-            var resultValue = Parameter( typeof( int ) );
-            var exceptionParam = Parameter( typeof( Exception ), "ex" );
-            var block = BlockAsync(
-                [resultValue],
-                TryCatchFinally(
-                    Assign( resultValue, Await( Constant( Task.FromResult( 10 ) ) ) ), // Try block
-                    Assign( resultValue, Await( Constant( Task.FromResult( 30 ) ) ) ), // Finally block
-                    Catch( exceptionParam,
-                        Assign( resultValue, Await( Constant( Task.FromResult( 20 ) ) ) ) // Catch block
-                    )
+                Catch(
+                    exceptionParam,
+                    Assign( resultValue, Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 99 )
+                    ) ) )
+                )
+            ),
+            resultValue
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 99, result );
+
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldHandleExceptionSuccessfully_WithTryCatchFinally( bool immediateFlag )
+    {
+        // Arrange: Await in both catch and finally blocks
+        var exceptionParam = Parameter( typeof( Exception ), "ex" );
+        var resultValue = Parameter( typeof( int ) );
+        var block = BlockAsync(
+            [resultValue],
+            TryCatchFinally(
+                Block(
+                    Throw( Constant( new Exception() ) ),
+                    Constant( 1 )
                 ),
-                resultValue
-            );
-            var lambda = Lambda<Func<Task<int>>>( block );
-            var compiledLambda = lambda.Compile();
-
-            // Act
-            var result = await compiledLambda();
-
-            // Assert
-            Assert.AreEqual( 30, result ); // Finally block should execute and return 30
-        }
-
-        [TestMethod]
-        public async Task AsyncBlock_ShouldCatchMultipleExceptionsInNestedTryBlocks()
-        {
-            // Arrange: Multiple exceptions in nested Try-Catch blocks
-            var resultValue = Parameter( typeof( int ) );
-            var outerExceptionParam = Parameter( typeof( Exception ), "outerEx" );
-            var innerExceptionParam = Parameter( typeof( Exception ), "innerEx" );
-
-            var block = BlockAsync(
-                [resultValue],
-                TryCatch(
-                    Block(
-                        Throw( Constant( new Exception( "Outer Exception" ) ) ),
-                        TryCatch(
-                            Block(
-                                Throw( Constant( new Exception( "Inner Exception" ) ) ),
-                                Constant( 0 )
-                            ),
-                            Catch( innerExceptionParam, Assign( resultValue, Await( Constant( Task.FromResult( 20 ) ) ) ) )
+                Assign( resultValue,
+                    Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 50 )
+                    ) ) ), // This Await will still be executed after the exception
+                Catch( exceptionParam,
+                    Assign( resultValue, Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 30 )
+                    ) ) )
+                )
+            ),
+            resultValue
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 50, result ); // Catch block handles the exception and returns 30
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInTryAndFinallyBlocks( bool immediateFlag )
+    {
+        // Arrange: Await in both try and finally blocks
+        var resultValue = Parameter( typeof( int ) );
+        var block = BlockAsync(
+            [resultValue],
+            TryFinally(
+                Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 15 ) ) ) ), // Try block
+                Assign( resultValue, Constant( 25 ) ) // Finally block
+            ),
+            resultValue
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 25, result ); // Catch block handles the exception and returns 30
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithAwaitInTryCatchAndFinallyBlocks( bool immediateFlag )
+    {
+        // Arrange: Await in Try, Catch, and Finally blocks
+        var resultValue = Parameter( typeof( int ) );
+        var exceptionParam = Parameter( typeof( Exception ), "ex" );
+        var block = BlockAsync(
+            [resultValue],
+            TryCatchFinally(
+                Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 10 ) ) ) ), // Try block
+                Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 30 ) ) ) ), // Finally block
+                Catch( exceptionParam,
+                    Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 20 ) ) ) ) // Catch block
+                )
+            ),
+            resultValue
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 30, result ); // Finally block should execute and return 30
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldCatchMultipleExceptionsInNestedTryBlocks( bool immediateFlag )
+    {
+        // Arrange: Multiple exceptions in nested Try-Catch blocks
+        var resultValue = Parameter( typeof( int ) );
+        var outerExceptionParam = Parameter( typeof( Exception ), "outerEx" );
+        var innerExceptionParam = Parameter( typeof( Exception ), "innerEx" );
+
+        var block = BlockAsync(
+            [resultValue],
+            TryCatch(
+                Block(
+                    Throw( Constant( new Exception( "Outer Exception" ) ) ),
+                    TryCatch(
+                        Block(
+                            Throw( Constant( new Exception( "Inner Exception" ) ) ),
+                            Constant( 0 )
                         ),
-                        Constant( 0 )
+                        Catch( innerExceptionParam, Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 20 ) ) ) ) )
                     ),
-                    Catch( outerExceptionParam, Assign( resultValue, Constant( 50 ) ) )
+                    Constant( 0 )
                 ),
-                resultValue
-            );
-            var lambda = Lambda<Func<Task<int>>>( block );
-            var compiledLambda = lambda.Compile();
-
-            // Act
-            var result = await compiledLambda();
-
-            // Assert
-            Assert.AreEqual( 50, result ); // Outer catch handles the exception
-        }
-
-        [TestMethod]
-        public async Task AsyncBlock_ShouldAwaitSuccessfully_WithComplexNestedTryBlock()
-        {
-            // Arrange: Await in the try block
-            var resultValue = Parameter( typeof( int ) );
-            var block = BlockAsync(
-                [resultValue],
-                Await( Constant( Task.FromResult( 0 ) ) ),
-                TryCatch(
-                    Block(
-                        Assign( resultValue, Await( Constant( Task.FromResult( 10 ) ) ) ),
-                        TryCatch(
-                            Block(
-                                Assign( resultValue, Await( Constant( Task.FromResult( 20 ) ) ) ),
-                                TryCatch(
-                                    Assign( resultValue, Await( Constant( Task.FromResult( 30 ) ) ) ),
-                                    Catch( typeof( Exception ), Assign( resultValue, Constant( 1 ) ) )
-                                ) ),
-                            Catch( typeof( Exception ), Assign( resultValue, Constant( 2 ) ) )
-                        ),
-                        Assign( resultValue, Await( Constant( Task.FromResult( 40 ) ) ) ),
-                        TryCatch(
-                            Block(
-                                Assign( resultValue, Await( Constant( Task.FromResult( 50 ) ) ) ),
-                                TryCatch(
-                                    Assign( resultValue, Await( Constant( Task.FromResult( 60 ) ) ) ),
-                                    Catch( typeof( Exception ), Assign( resultValue, Constant( 3 ) ) )
-                                ) )
-                            ,
-                            Catch( typeof( Exception ), Assign( resultValue, Constant( 4 ) ) )
-
-                        ) ),
-                    Catch( typeof( Exception ), Assign( resultValue, Constant( 6 ) ) )
-                ),
-                resultValue
-            );
-            var lambda = Lambda<Func<Task<int>>>( block );
-            var compiledLambda = lambda.Compile();
-
-            // Act
-            var result = await compiledLambda();
-
-            // Assert
-            Assert.AreEqual( 60, result );
-        }
-
-        [TestMethod]
-        public async Task AsyncBlock_ShouldAwaitSuccessfully_WithComplexNestedTryFinallyBlock()
-        {
-            // Arrange: Await in the try block
-            var resultValue = Parameter( typeof( int ) );
-            var block = BlockAsync(
-                [resultValue],
-                Await( Constant( Task.FromResult( 0 ) ) ),
-                TryCatchFinally(
-                    Block(
-                        Assign( resultValue, Await( Constant( Task.FromResult( 10 ) ) ) ),
-                        TryCatch(
-                            Block(
-                                Assign( resultValue, Await( Constant( Task.FromResult( 20 ) ) ) ),
-                                TryCatch(
-                                    Assign( resultValue, Await( Constant( Task.FromResult( 30 ) ) ) ),
-                                    Catch( typeof( Exception ), Assign( resultValue, Constant( 1 ) ) )
-                                ) ),
-                            Catch( typeof( Exception ), Assign( resultValue, Constant( 2 ) ) )
-                        ),
-                        Assign( resultValue, Await( Constant( Task.FromResult( 40 ) ) ) ),
-                        TryCatch(
-                            Block(
-                                Assign( resultValue, Await( Constant( Task.FromResult( 50 ) ) ) ),
-                                TryCatch(
-                                    Assign( resultValue, Await( Constant( Task.FromResult( 60 ) ) ) ),
-                                    Catch( typeof( Exception ), Assign( resultValue, Constant( 3 ) ) )
-                                ) )
-                            ,
-                            Catch( typeof( Exception ), Assign( resultValue, Constant( 4 ) ) )
-
-                        ) ),
+                Catch( outerExceptionParam, Assign( resultValue, Constant( 50 ) ) )
+            ),
+            resultValue
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 50, result ); // Outer catch handles the exception
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithComplexNestedTryBlock( bool immediateFlag )
+    {
+        // Arrange: Await in the try block
+        var resultValue = Parameter( typeof( int ) );
+        var block = BlockAsync(
+            [resultValue],
+            Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 0 ) ) ),
+            TryCatch(
+                Block(
+                    Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 10 ) ) ) ),
                     TryCatch(
-                        Assign( resultValue, Await( Constant( Task.FromResult( 40 ) ) ) ),  // Finally block should be result
-                        Catch( typeof( Exception ), Assign( resultValue, Constant( 5 ) ) )
+                        Block(
+                            Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 20 ) ) ) ),
+                            TryCatch(
+                                Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 30 ) ) ) ),
+                                Catch( typeof( Exception ), Assign( resultValue, Constant( 1 ) ) )
+                            ) ),
+                        Catch( typeof( Exception ), Assign( resultValue, Constant( 2 ) ) )
                     ),
-                    Catch( typeof( Exception ), Assign( resultValue, Constant( 6 ) ) )
-                ),
-                resultValue
-            );
-            var lambda = Lambda<Func<Task<int>>>( block );
-            var compiledLambda = lambda.Compile();
-
-            // Act
-            var result = await compiledLambda();
-
-            // Assert
-            Assert.AreEqual( 40, result );
-        }
-
-        [TestMethod]
-        public async Task AsyncBlock_ShouldAwaitSuccessfully_WithNestedTryCatchAndDelayedAwait()
-        {
-            // Arrange: Nested TryCatch with delayed await tasks (non-completed)
-            var resultValue = Parameter( typeof( int ) );
-
-            var delayedTask1 = Task.Delay( 100 ).ContinueWith( _ => 10 );
-            var delayedTask2 = Task.Delay( 200 ).ContinueWith( _ => 20 );
-            var delayedTask3 = Task.Delay( 300 ).ContinueWith( _ => 30 );
-
-            var block = BlockAsync(
-                [resultValue],
-                TryCatch(
-                    Block(
-                        // Await the first delayed task in the outer try
-                        Assign( resultValue, Await( Constant( delayedTask1 ) ) ),
-                        TryCatch(
-                            Block(
-                                // Await the second delayed task in the inner try
-                                Assign( resultValue, Await( Constant( delayedTask2 ) ) ),
-                                TryCatch(
-                                    // Await the third delayed task in the innermost try
-                                    Assign( resultValue, Await( Constant( delayedTask3 ) ) ),
-                                    Catch( typeof( Exception ), Assign( resultValue, Constant( 99 ) ) )
-                                )
-                            ),
-                            Catch( typeof( Exception ), Assign( resultValue, Constant( 50 ) ) )
-                        )
+                    Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 40 ) ) ) ),
+                    TryCatch(
+                        Block(
+                            Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 50 ) ) ) ),
+                            TryCatch(
+                                Assign( resultValue, Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 60 ) ) ) ),
+                                Catch( typeof( Exception ), Assign( resultValue, Constant( 3 ) ) )
+                            ) )
+                        ,
+                        Catch( typeof( Exception ), Assign( resultValue, Constant( 4 ) ) )
+
+                    ) ),
+                Catch( typeof( Exception ), Assign( resultValue, Constant( 6 ) ) )
+            ),
+            resultValue
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 60, result );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithComplexNestedTryFinallyBlock( bool immediateFlag )
+    {
+        // Arrange: Await in the try block
+        var resultValue = Parameter( typeof( int ) );
+        var block = BlockAsync(
+            [resultValue],
+            Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 0 ) ) ),
+            TryCatchFinally(
+                Block(
+                    Assign( resultValue, Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 10 )
+                    ) ) ),
+                    TryCatch(
+                        Block(
+                            Assign( resultValue, Await( AsyncHelper.Completable(
+                                Constant( immediateFlag ),
+                                Constant( 20 )
+                            ) ) ),
+                            TryCatch(
+                                Assign( resultValue, Await( AsyncHelper.Completable(
+                                    Constant( immediateFlag ),
+                                    Constant( 30 )
+                                ) ) ),
+                                Catch( typeof( Exception ), Assign( resultValue, Constant( 1 ) ) )
+                            ) ),
+                        Catch( typeof( Exception ), Assign( resultValue, Constant( 2 ) ) )
                     ),
-                    Catch( typeof( Exception ), Assign( resultValue, Constant( 25 ) ) )
+                    Assign( resultValue, Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 40 )
+                    ) ) ),
+                    TryCatch(
+                        Block(
+                            Assign( resultValue, Await( AsyncHelper.Completable(
+                                Constant( immediateFlag ),
+                                Constant( 50 )
+                            ) ) ),
+                            TryCatch(
+                                Assign( resultValue, Await( AsyncHelper.Completable(
+                                    Constant( immediateFlag ),
+                                    Constant( 60 )
+                                ) ) ),
+                                Catch( typeof( Exception ), Assign( resultValue, Constant( 3 ) ) )
+                            ) )
+                        ,
+                        Catch( typeof( Exception ), Assign( resultValue, Constant( 4 ) ) )
+
+                    ) ),
+                TryCatch(
+                    Assign( resultValue, Await( AsyncHelper.Completable(
+                        Constant( immediateFlag ),
+                        Constant( 40 )
+                    ) ) ),  // Finally block should be result
+                    Catch( typeof( Exception ), Assign( resultValue, Constant( 5 ) ) )
                 ),
-                resultValue
-            );
-            var lambda = Lambda<Func<Task<int>>>( block );
-            var compiledLambda = lambda.Compile();
-
-            // Act
-            var result = await compiledLambda();
+                Catch( typeof( Exception ), Assign( resultValue, Constant( 6 ) ) )
+            ),
+            resultValue
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 40, result );
+    }
 
-            // Assert
-            Assert.AreEqual( 30, result ); // Ensure the final delayed task completes and continues correctly
-        }
+    [TestMethod]
+    public async Task AsyncBlock_ShouldAwaitSuccessfully_WithNestedTryCatchAndDelayedAwait()
+    {
+        // Arrange: Nested TryCatch with delayed await tasks (non-completed)
+        var resultValue = Parameter( typeof( int ) );
+
+        var delayedTask1 = Task.Delay( 100 ).ContinueWith( _ => 10 );
+        var delayedTask2 = Task.Delay( 200 ).ContinueWith( _ => 20 );
+        var delayedTask3 = Task.Delay( 300 ).ContinueWith( _ => 30 );
+
+        var block = BlockAsync(
+            [resultValue],
+            TryCatch(
+                Block(
+                    // Await the first delayed task in the outer try
+                    Assign( resultValue, Await( Constant( delayedTask1 ) ) ),
+                    TryCatch(
+                        Block(
+                            // Await the second delayed task in the inner try
+                            Assign( resultValue, Await( Constant( delayedTask2 ) ) ),
+                            TryCatch(
+                                // Await the third delayed task in the innermost try
+                                Assign( resultValue, Await( Constant( delayedTask3 ) ) ),
+                                Catch( typeof( Exception ), Assign( resultValue, Constant( 99 ) ) )
+                            )
+                        ),
+                        Catch( typeof( Exception ), Assign( resultValue, Constant( 50 ) ) )
+                    )
+                ),
+                Catch( typeof( Exception ), Assign( resultValue, Constant( 25 ) ) )
+            ),
+            resultValue
+        );
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 30, result ); // Ensure the final delayed task completes and continues correctly
     }
 }
diff --git a/test/Hyperbee.Expressions.Tests/CustomAwaiterTests.cs b/test/Hyperbee.Expressions.Tests/CustomAwaiterTests.cs
index ce416f3..cc82c75 100644
--- a/test/Hyperbee.Expressions.Tests/CustomAwaiterTests.cs
+++ b/test/Hyperbee.Expressions.Tests/CustomAwaiterTests.cs
@@ -1,9 +1,12 @@
 using System.Linq.Expressions;
 using System.Runtime.CompilerServices;
+using Hyperbee.Expressions.Tests.TestSupport;
+using static System.Linq.Expressions.Expression;
+using static Hyperbee.Expressions.ExpressionExtensions;
 
 namespace Hyperbee.Expressions.Tests;
 
-public readonly struct LazyAwaiter<T> : ICriticalNotifyCompletion //INotifyCompletion
+public class LazyAwaiter<T> : ICriticalNotifyCompletion
 {
     private readonly Lazy<T> _lazy;
 
@@ -34,11 +37,11 @@ public void TestCustomAwaiter_Await()
 
         Expression<Func<int>> valueExpression = () => 42;
         var lazyConstructor = typeof( Lazy<int> ).GetConstructor( [typeof( Func<int> )] );
-        var lazyExpression = Expression.New( lazyConstructor!, valueExpression );
+        var lazyExpression = New( lazyConstructor!, valueExpression );
 
-        var awaitExpression = ExpressionExtensions.Await( lazyExpression, configureAwait: false );
+        var awaitExpression = Await( lazyExpression, configureAwait: false );
 
-        var lambda = Expression.Lambda<Func<int>>( awaitExpression );
+        var lambda = Lambda<Func<int>>( awaitExpression );
         var compiledLambda = lambda.Compile();
 
         var result = compiledLambda();
@@ -54,17 +57,81 @@ public async Task TestCustomAwaiter_AsyncBlock()
 
         Expression<Func<int>> valueExpression = () => 42;
         var lazyConstructor = typeof( Lazy<int> ).GetConstructor( [typeof( Func<int> )] );
-        var lazyExpression = Expression.New( lazyConstructor!, valueExpression );
+        var lazyExpression = New( lazyConstructor!, valueExpression );
 
-        var block = ExpressionExtensions.BlockAsync(
-            ExpressionExtensions.Await( lazyExpression, configureAwait: false )
+        var block = BlockAsync(
+            Await( lazyExpression, configureAwait: false )
         );
 
-        var lambda = Expression.Lambda<Func<Task<int>>>( block );
+        var lambda = Lambda<Func<Task<int>>>( block );
         var compiledLambda = lambda.Compile();
 
         var result = await compiledLambda();
 
         Assert.AreEqual( 42, result, "The result should be 42." );
     }
+
+    [DataTestMethod]
+    [DataRow( true )] // Immediate completion
+    [DataRow( false )] // Deferred completion
+    public async Task TestCustomAwaiter_TaskLike( bool immediateFlag )
+    {
+        // Arrange
+        var resultValue = Parameter( typeof( int ), "result" );
+
+        var block = BlockAsync(
+            [resultValue],
+            Assign( resultValue, Constant( 5 ) ),
+            Await(
+                AsyncHelper.Completable(
+                    Constant( immediateFlag )
+                )
+            ),
+            Assign( resultValue, Add( resultValue, Constant( 37 ) ) ),
+            resultValue
+        );
+
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 42, result, "The result should be 42." );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )] // Immediate completion
+    [DataRow( false )] // Deferred completion
+    public async Task TestCustomAwaiter_TaskResultLike( bool immediateFlag )
+    {
+        // Arrange
+        var resultValue = Parameter( typeof( int ), "result" );
+
+        var block = BlockAsync(
+            [resultValue],
+            Assign( resultValue,
+                Add(
+                    Await(
+                        AsyncHelper.Completable(
+                            Constant( immediateFlag ),
+                            Constant( 37 )
+                        )
+                    ),
+                    Constant( 5 )
+                )
+            ),
+            resultValue
+        );
+
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile();
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 42, result, "The result should be 42." );
+    }
 }
diff --git a/test/Hyperbee.Expressions.Tests/DebugExpressionTests.cs b/test/Hyperbee.Expressions.Tests/DebugExpressionTests.cs
new file mode 100644
index 0000000..7fbf369
--- /dev/null
+++ b/test/Hyperbee.Expressions.Tests/DebugExpressionTests.cs
@@ -0,0 +1,124 @@
+using static System.Linq.Expressions.Expression;
+using static Hyperbee.Expressions.ExpressionExtensions;
+
+namespace Hyperbee.Expressions.Tests;
+
+[TestClass]
+public class DebugExpressionTests
+{
+    [TestMethod]
+    public void DebugExpression_Should_Invoke_DebugDelegate_Unconditionally()
+    {
+        // Arrange
+        var called = false;
+        void DebugAction( string message ) => called = message == "Test Message";
+
+        var message = Constant( "Test Message" );
+        var debugExpr = Debug( DebugAction, [message] );
+
+        // Act
+        var lambda = Lambda<Action>( debugExpr ).Compile();
+        lambda();
+
+        // Assert
+        Assert.IsTrue( called, "Debug delegate should have been invoked." );
+    }
+
+    [TestMethod]
+    public void DebugExpression_Should_Invoke_DebugDelegate_Unconditionally1()
+    {
+        // Arrange
+        var called = false;
+        void DebugAction( string message1, string message2 ) => called = message1 == "Test Message 1" && message2 == "Test Message 2";
+
+        var message1 = Constant( "Test Message 1" );
+        var message2 = Constant( "Test Message 2" );
+        var debugExpr = Debug( DebugAction, [message1, message2] );
+
+        // Act
+        var lambda = Lambda<Action>( debugExpr ).Compile();
+        lambda();
+
+        // Assert
+        Assert.IsTrue( called, "Debug delegate should have been invoked." );
+    }
+
+    [TestMethod]
+    public void DebugExpression_Should_Invoke_DebugDelegate_When_Condition_Is_True()
+    {
+        // Arrange
+        var called = false;
+        void DebugAction( int value ) => called = value == 42;
+
+        var value = Constant( 42 );
+        var condition = Constant( true );
+        var debugExpr = Debug( DebugAction, condition, value );
+
+        // Act
+        var lambda = Lambda<Action>( debugExpr ).Compile();
+        lambda();
+
+        // Assert
+        Assert.IsTrue( called, "Debug delegate should have been invoked when condition is true." );
+    }
+
+    [TestMethod]
+    public void DebugExpression_Should_Not_Invoke_DebugDelegate_When_Condition_Is_False()
+    {
+        // Arrange
+        var called = false;
+        void DebugAction( int value ) => called = value == 42;
+
+        var value = Constant( 42 );
+        var condition = Constant( false );
+        var debugExpr = Debug( DebugAction, condition, value );
+
+        // Act
+        var lambda = Lambda<Action>( debugExpr ).Compile();
+        lambda();
+
+        // Assert
+        Assert.IsFalse( called, "Debug delegate should not have been invoked when condition is false." );
+    }
+
+    [TestMethod]
+    [ExpectedException( typeof( ArgumentException ) )]
+    public void DebugExpression_Should_Throw_If_Condition_Is_Not_Boolean()
+    {
+        // Arrange
+        void DebugAction( int value )
+        {
+        }
+
+        var invalidCondition = Constant( 42 );
+
+        // Act
+        _ = Debug( DebugAction, invalidCondition, Constant( 10 ) );
+
+        // Assert: Exception is expected
+    }
+
+    [TestMethod]
+    public void DebugExpression_Should_Work_Within_Complex_Block()
+    {
+        // Arrange
+        var called = false;
+        void DebugAction( int value ) => called = value == 15;
+
+        var x = Parameter( typeof( int ), "x" );
+        var y = Parameter( typeof( int ), "y" );
+        var sum = Add( x, y );
+
+        var debugExpr = Debug( DebugAction, sum );
+
+        var block = Block( debugExpr, sum );
+
+        // Act
+        var lambda = Lambda<Func<int, int, int>>( block, x, y ).Compile();
+        var result = lambda( 10, 5 );
+
+        // Assert
+        Assert.IsTrue( called, "Debug delegate should have been invoked within the block." );
+        Assert.AreEqual( 15, result, "Block should correctly compute the sum." );
+    }
+}
diff --git a/test/Hyperbee.Expressions.Tests/ExpressionDependencyMatcherTests.cs b/test/Hyperbee.Expressions.Tests/ExpressionDependencyMatcherTests.cs
new file mode 100644
index 0000000..cf128a1
--- /dev/null
+++ b/test/Hyperbee.Expressions.Tests/ExpressionDependencyMatcherTests.cs
@@ -0,0 +1,46 @@
+using Hyperbee.Expressions.Tests.TestSupport;
+using Hyperbee.Expressions.Visitors;
+using static System.Linq.Expressions.Expression;
+using static Hyperbee.Expressions.ExpressionExtensions;
+
+namespace Hyperbee.Expressions.Tests;
+
+[TestClass]
+public class ExpressionDependencyMatcherTests
+{
+    [TestMethod]
+    public void ExpressionDependencyMatcher_ShouldFindAwaits()
+    {
+        // Arrange
+
+        var awaitExpr1 = Await( AsyncHelper.Completable(
+            Constant( false ),
+            Constant( 1 )
+        ) );
+
+        var awaitExpr2 = Await( AsyncHelper.Completable(
+            Constant( false ),
+            Constant( 2 )
+        ) );
+
+        var blockAsyncExpr = BlockAsync(
+            awaitExpr1,
+            awaitExpr2
+        );
+
+        var rootExpr = Block( blockAsyncExpr );
+        var counter = new ExpressionMatcher( expr => expr is AsyncBlockExpression || expr is AwaitExpression );
+
+        // Act
+        var rootExprCount = counter.MatchCount( rootExpr );
+        var blockAsyncExprCount = counter.MatchCount( blockAsyncExpr );
+        var awaitExpr1Count = counter.MatchCount( awaitExpr1 );
+        var awaitExpr2Count = counter.MatchCount( awaitExpr2 );
+
+        // Assert
+        Assert.AreEqual( 3, rootExprCount );
+        Assert.AreEqual( 3, blockAsyncExprCount );
+        Assert.AreEqual( 1, awaitExpr1Count );
+        Assert.AreEqual( 1, awaitExpr2Count );
+    }
+}
diff --git a/test/Hyperbee.Expressions.Tests/ForEachTests.cs b/test/Hyperbee.Expressions.Tests/ForEachTests.cs
index 716664d..e12dbcb 100644
--- a/test/Hyperbee.Expressions.Tests/ForEachTests.cs
+++ b/test/Hyperbee.Expressions.Tests/ForEachTests.cs
@@ -1,4 +1,6 @@
-using System.Linq.Expressions;
+using Hyperbee.Expressions.Tests.TestSupport;
+using static System.Linq.Expressions.Expression;
+using static Hyperbee.Expressions.ExpressionExtensions;
 
 namespace Hyperbee.Expressions.Tests;
 
@@ -9,16 +11,16 @@ public class ForEachExpressionTests
     public void ForEachExpression_ShouldIterateOverCollection()
     {
         // Arrange
-        var list = Expression.Constant( new List<int> { 1, 2, 3, 4, 5 } );
-        var element = Expression.Variable( typeof( int ), "element" );
+        var list = Constant( new List<int> { 1, 2, 3, 4, 5 } );
+        var element = Variable( typeof( int ), "element" );
 
         var writeLineMethod = typeof( Console ).GetMethod( "WriteLine", [typeof( int )] );
-        var body = Expression.Call( writeLineMethod!, element );
+        var body = Call( writeLineMethod!, element );
 
-        var forEachExpr = ExpressionExtensions.ForEach( list, element, body );
+        var forEachExpr = ForEach( list, element, body );
 
         // Act
-        var lambda = Expression.Lambda<Action>( forEachExpr );
+        var lambda = Lambda<Action>( forEachExpr );
         var compiledLambda = lambda.Compile();
 
         compiledLambda();
@@ -30,20 +32,20 @@ public void ForEachExpression_ShouldIterateOverCollection()
     public void ForEachExpression_ShouldBreakOnCondition()
     {
         // Arrange
-        var list = Expression.Constant( new List<int> { 1, 2, 3, 4, 5 } );
-        var element = Expression.Variable( typeof( int ), "element" );
+        var list = Constant( new List<int> { 1, 2, 3, 4, 5 } );
+        var element = Variable( typeof( int ), "element" );
 
         var writeLineMethod = typeof( Console ).GetMethod( "WriteLine", [typeof( int )] )!;
 
-        var forEachExpr = ExpressionExtensions.ForEach( list, element, ( breakLabel, continueLabel ) =>
-            Expression.IfThenElse(
-                Expression.Equal( element, Expression.Constant( 3 ) ),
-                Expression.Break( breakLabel ),
-                Expression.Call( writeLineMethod, element )
+        var forEachExpr = ForEach( list, element, ( breakLabel, continueLabel ) =>
+            IfThenElse(
+                Equal( element, Constant( 3 ) ),
+                Break( breakLabel ),
+                Call( writeLineMethod, element )
         ) );
 
         // Act
-        var lambda = Expression.Lambda<Action>( forEachExpr );
+        var lambda = Lambda<Action>( forEachExpr );
         var compiledLambda = lambda.Compile();
 
         compiledLambda();
@@ -55,35 +57,72 @@ public void ForEachExpression_ShouldBreakOnCondition()
     public void ForEachExpression_ShouldUseCustomBreakAndContinueLabels()
     {
         // Arrange
-        var list = Expression.Constant( new List<int> { 1, 2, 3, 4, 5 } );
-        var element = Expression.Variable( typeof( int ), "element" );
+        var list = Constant( new List<int> { 1, 2, 3, 4, 5 } );
+        var element = Variable( typeof( int ), "element" );
 
-        var customBreakLabel = Expression.Label( "customBreak" );
-        var customContinueLabel = Expression.Label( "customContinue" );
+        var customBreakLabel = Label( "customBreak" );
+        var customContinueLabel = Label( "customContinue" );
 
-        // Body: If element == 4, break; if element == 2, continue
-        var breakCondition = Expression.Equal( element, Expression.Constant( 4 ) );
-        var continueCondition = Expression.Equal( element, Expression.Constant( 2 ) );
+        var breakCondition = Equal( element, Constant( 4 ) );
+        var continueCondition = Equal( element, Constant( 2 ) );
 
         var writeLineMethod = typeof( Console ).GetMethod( "WriteLine", [typeof( int )] )!;
 
-        var body = Expression.Block(
-            Expression.IfThen( continueCondition, Expression.Continue( customContinueLabel ) ),
-            Expression.IfThenElse(
+        var body = Block(
+            IfThen( continueCondition, Continue( customContinueLabel ) ),
+            IfThenElse(
                 breakCondition,
-                Expression.Break( customBreakLabel ),
-                Expression.Call( writeLineMethod, element )
+                Break( customBreakLabel ),
+                Call( writeLineMethod, element )
             )
         );
 
-        var forEachExpr = ExpressionExtensions.ForEach( list, element, body, customBreakLabel, customContinueLabel );
+        var forEachExpr = ForEach( list, element, body, customBreakLabel, customContinueLabel );
 
         // Act
-        var lambda = Expression.Lambda<Action>( forEachExpr );
+        var lambda = Lambda<Action>( forEachExpr );
         var compiledLambda = lambda.Compile();
 
         compiledLambda();
 
-        // Assert: No assertion needed
+        // Assert: No assert needed
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task ForEachExpression_ShouldIterateOverCollection_WithAwaits( bool immediateFlag )
+    {
+        // Arrange
+        var list = Constant( new List<int> { 1, 2, 3, 4, 5 } );
+        var element = Variable( typeof( int ), "element" );
+        var result = Variable( typeof( int ), "result" );
+
+        var body = Block(
+                        Assign( result,
+                            Add( result, Await( AsyncHelper.Completable(
+                                Constant( immediateFlag ),
+                                Constant( 1 )
+                            )
+                        ) ) )
+                    );
+
+        var forEachExpr = BlockAsync(
+            [result],
+            Block(
+                Assign( result, Constant( 2 ) ),
+                ForEach( list, element, body )
+            ),
+            result
+        );
+
+        // Act
+        var lambda = Lambda<Func<Task<int>>>( forEachExpr );
+        var compiledLambda = lambda.Compile();
+
+        var total = await compiledLambda();
+
+        // Assert:
+        Assert.AreEqual( 7, total );
     }
 }
diff --git a/test/Hyperbee.Expressions.Tests/ForExpressionTests.cs b/test/Hyperbee.Expressions.Tests/ForExpressionTests.cs
index c9b987d..e4449c2 100644
--- a/test/Hyperbee.Expressions.Tests/ForExpressionTests.cs
+++ b/test/Hyperbee.Expressions.Tests/ForExpressionTests.cs
@@ -1,4 +1,5 @@
-using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
+using static Hyperbee.Expressions.ExpressionExtensions;
 
 namespace Hyperbee.Expressions.Tests;
 
@@ -9,26 +10,26 @@ public class ForExpressionTests
     public void ForExpression_ShouldLoopCorrectly()
     {
         // Arrange
-        var counter = Expression.Variable( typeof( int ), "counter" );
-        var counterInit = Expression.Assign( counter, Expression.Constant( 0 ) );
+        var counter = Variable( typeof( int ), "counter" );
+        var counterInit = Assign( counter, Constant( 0 ) );
 
-        var condition = Expression.LessThan( counter, Expression.Constant( 5 ) );
-        var iteration = Expression.PostIncrementAssign( counter );
+        var condition = LessThan( counter, Constant( 5 ) );
+        var iteration = PostIncrementAssign( counter );
 
         var writeLineMethod = typeof( Console ).GetMethod( "WriteLine", [typeof( int )] );
-        var body = Expression.Call( writeLineMethod!, counter );
+        var body = Call( writeLineMethod!, counter );
 
-        var forExpr = ExpressionExtensions.For( counterInit, condition, iteration, body );
+        var forExpr = For( counterInit, condition, iteration, body );
 
         // Wrap in a block to capture the counter value
-        var block = Expression.Block(
+        var block = Block(
             [counter],
             forExpr,
             counter // Return counter
         );
 
         // Act
-        var lambda = Expression.Lambda<Func<int>>( block );
+        var lambda = Lambda<Func<int>>( block );
         var compiledLambda = lambda.Compile();
 
         var result = compiledLambda();
@@ -41,30 +42,29 @@ public void ForExpression_ShouldLoopCorrectly()
     public void ForExpression_ShouldSupportCustomBreak()
     {
         // Arrange
-
         var writeLine = typeof( Console ).GetMethod( "WriteLine", [typeof( int )] )!;
 
-        var counter = Expression.Variable( typeof( int ), "counter" );
-        var counterInit = Expression.Assign( counter, Expression.Constant( 0 ) );
+        var counter = Variable( typeof( int ), "counter" );
+        var counterInit = Assign( counter, Constant( 0 ) );
 
-        var condition = Expression.LessThan( counter, Expression.Constant( 10 ) );
-        var iteration = Expression.PostIncrementAssign( counter );
+        var condition = LessThan( counter, Constant( 10 ) );
+        var iteration = PostIncrementAssign( counter );
 
-        var forExpr = ExpressionExtensions.For( counterInit, condition, iteration, ( breakLabel, continueLabel ) =>
-            Expression.IfThenElse(
-                Expression.Equal( counter, Expression.Constant( 5 ) ),
-                Expression.Break( breakLabel ), // Use break label when counter == 5
-                Expression.Call( writeLine, counter )
+        var forExpr = For( counterInit, condition, iteration, ( breakLabel, continueLabel ) =>
+            IfThenElse(
+                Equal( counter, Constant( 5 ) ),
+                Break( breakLabel ), // break when counter == 5
+                Call( writeLine, counter )
         ) );
 
-        var block = Expression.Block(
+        var block = Block(
             [counter],
             forExpr,
-            counter // Return counter
+            counter
         );
 
         // Act
-        var lambda = Expression.Lambda<Func<int>>( block );
+        var lambda = Lambda<Func<int>>( block );
         var compiledLambda = lambda.Compile();
 
         var result = compiledLambda();
diff --git a/test/Hyperbee.Expressions.Tests/Hyperbee.Expressions.Tests.csproj b/test/Hyperbee.Expressions.Tests/Hyperbee.Expressions.Tests.csproj
index 8fdaed3..06604c9 100644
--- a/test/Hyperbee.Expressions.Tests/Hyperbee.Expressions.Tests.csproj
+++ b/test/Hyperbee.Expressions.Tests/Hyperbee.Expressions.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>disable</Nullable>
     <IsPackable>false</IsPackable>
@@ -13,9 +13,10 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.6.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.6.2" />
+    <PackageReference Include="FastExpressionCompiler" Version="5.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.6.4" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.6.4" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Hyperbee.Expressions.Tests/LoweringVisitorTests.cs b/test/Hyperbee.Expressions.Tests/LoweringVisitorTests.cs
deleted file mode 100644
index e5fdad9..0000000
--- a/test/Hyperbee.Expressions.Tests/LoweringVisitorTests.cs
+++ /dev/null
@@ -1,701 +0,0 @@
-using System.Linq.Expressions;
-using System.Reflection;
-using Hyperbee.Expressions.Transformation;
-using Hyperbee.Expressions.Transformation.Transitions;
-using static System.Linq.Expressions.Expression;
-using static Hyperbee.Expressions.ExpressionExtensions;
-
-namespace Hyperbee.Expressions.Tests;
-
-[TestClass]
-public class LoweringVisitorTests
-{
-    static int Test( int a, int b ) => a + b;
-    static async Task<int> TestAsync( int a, int b ) => await Task.FromResult( a + b );
-
-    public static MethodInfo GetMethod( string name ) => typeof( LoweringVisitorTests ).GetMethod( name, BindingFlags.Static | BindingFlags.NonPublic );
-
-
-    [TestMethod]
-    public void Lowering_ShouldHaveSingleNode_WhenAssigningVariable()
-    {
-        // Arrange
-        var varExpr = Variable( typeof( int ), "x" );
-        var assignExpr = Assign( varExpr, Add( varExpr, Constant( 2 ) ) );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( [varExpr], assignExpr );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 1, variables: 1 );
-
-        AssertTransition.AssertLabel( result.Scopes[0].Nodes[0].NodeLabel, "ST_0000", typeof( void ) );
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[0] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WhenBlockHasMultipleAwaits()
-    {
-        // Arrange
-        var blockAwaits = Block(
-            Constant( "before await1" ),
-            Await( Constant( Task.FromResult( "await1" ) ) ),
-            Constant( "after await1" ),
-
-            Constant( "before await2" ),
-            Await( Constant( Task.FromResult( "await2" ) ) ),
-            Constant( "after await2" )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( blockAwaits );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 5, variables: 4, jumps: 2 );
-        AssertTransition.AssertLabel( result.Scopes[0].Nodes[0].NodeLabel, "ST_0000", typeof( void ) );
-
-        var firstBefore = AssertTransition.AssertAwait( result.Scopes[0].Nodes[0].Transition, "ST_0002" );
-        var firstAfter = AssertTransition.AssertAwaitResult( firstBefore.Transition, "ST_0001" );
-        var secondBefore = AssertTransition.AssertAwait( firstAfter.Transition, "ST_0004" );
-        var secondAfter = AssertTransition.AssertAwaitResult( secondBefore.Transition, "ST_0003" );
-        AssertTransition.AssertFinal( secondAfter );
-
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[3] );
-
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithIfThen()
-    {
-        // Arrange
-        var ifThenElseExpr = Block(
-            Constant( 0 ),
-            IfThen(
-                Constant( true ),
-                Block(
-                    Constant( "before nested if" ),
-                    IfThenElse( Constant( false ), Constant( 1.1 ), Block( Constant( 1.2 ), Constant( 1.3 ) ) ),
-                    Constant( "after nested if" )
-                ) ),
-            Constant( 2 )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( ifThenElseExpr );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 6 );
-        AssertTransition.AssertLabel( result.Scopes[0].Nodes[0].NodeLabel, "ST_0000", typeof( void ) );
-
-        var (ifThenTrue, ifThenFalse) =
-            AssertTransition.AssertConditional( result.Scopes[0].Nodes[0].Transition, "ST_0002", "ST_0001" );
-        var (ifThenElseTrue, ifThenElseFalse) =
-            AssertTransition.AssertConditional( ifThenTrue.Transition, "ST_0004", "ST_0005" );
-        Assert.IsNull( ifThenFalse.Transition ); // No else block
-
-        Assert.AreEqual( 1, ifThenElseTrue.Expressions.Count );
-        var joinNode = AssertTransition.AssertGoto( ifThenElseTrue.Transition, "ST_0003" );
-        var finalNodes = AssertTransition.AssertGoto( joinNode.Transition, "ST_0001" );
-        AssertTransition.AssertFinal( finalNodes );
-
-        Assert.AreEqual( 2, ifThenElseFalse.Expressions.Count );
-        joinNode = AssertTransition.AssertGoto( ifThenElseFalse.Transition, "ST_0003" );
-        finalNodes = AssertTransition.AssertGoto( joinNode.Transition, "ST_0001" );
-        AssertTransition.AssertFinal( finalNodes );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldNotGatherVariables_WhenUsedWithinBlock()
-    {
-        // Arrange
-        var methodInfo = GetMethod( nameof( Test ) )!;
-
-        var aParam = Parameter( typeof( int ), "a" );
-        var bParam = Parameter( typeof( int ), "b" );
-        var variables = Block(
-            [aParam, bParam],
-            Constant( "before parameters" ),
-            Assign( aParam, Constant( 1 ) ),
-            Assign( bParam, Constant( 2 ) ),
-            Constant( "after parameters" ),
-            Call( methodInfo, aParam, bParam )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( variables );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 1, variables: 0 );
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[0] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldNotGatherVariables_WhenUsedWithinNestedBlocks()
-    {
-        // Arrange
-        var methodInfo = GetMethod( nameof( Test ) );
-
-        var aParam = Parameter( typeof( int ), "a" );
-        var b2Param = Parameter( typeof( int ), "b" );  // Same name, inner scope
-        var childBlock = Block(
-            [aParam, b2Param],
-            Constant( "before nested parameters" ),
-            Assign( aParam, Constant( 3 ) ),
-            Assign( b2Param, Constant( 4 ) ),
-            Constant( "after nested parameters" ),
-            Call( methodInfo, aParam, b2Param )
-        );
-
-        var bParam = Parameter( typeof( int ), "b" );
-        var variables = Block(
-            [aParam, bParam],
-            Constant( "before parameters" ),
-            Assign( aParam, Constant( 1 ) ),
-            Assign( bParam, Constant( 2 ) ),
-            Constant( "after parameters" ),
-            childBlock
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( variables );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 1, variables: 0 );
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[0] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithConditionalParameters()
-    {
-        // Arrange
-        var methodInfo = GetMethod( nameof( Test ) );
-
-        var aParam = Parameter( typeof( int ), "a" );
-        var bParam = Parameter( typeof( int ), "b" );
-        var conditionalParameters = Block(
-            [aParam, bParam],
-            Constant( "before if" ),
-            IfThenElse( Constant( true ),
-                Block(
-                    Constant( "before nested parameters" ),
-                    Assign( aParam, Constant( 3 ) ),
-                    Assign( bParam, Constant( 4 ) ),
-                    Constant( "after nested parameters" ),
-                    Call( methodInfo, aParam, bParam )
-                ),
-                Block(
-                    Constant( "before nested parameters" ),
-                    Assign( aParam, Constant( 5 ) ),
-                    Assign( bParam, Constant( 6 ) ),
-                    Constant( "after nested parameters" ),
-                    Call( methodInfo, aParam, bParam )
-                )
-            ),
-            Constant( "after if" )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( conditionalParameters );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 4 );
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[1] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithNestedSwitch()
-    {
-        var switchBlock = Block(
-            Constant( "before switch" ),
-            Switch(
-                Constant( "switchTest" ),
-                Constant( 1.1 ),
-                [
-                    SwitchCase( Constant( 1.2 ), Constant( "TestValue1" ) ),
-                    SwitchCase( Block(
-                        Constant( "nested switch" ),
-                        Switch(
-                            Constant( "nestedSwitchTest" ),
-                            Constant( 2.1 ),
-                            [
-                                SwitchCase( Constant( 2.2 ), Constant( "NestedTestValue1" ) ),
-                                SwitchCase( Constant( 2.3 ), Constant( "NestedTestValue2" ) )
-                            ]
-                        ),
-                        Constant( 1.3 )
-                    ), Constant( "TestValue2" ) ),
-                    SwitchCase( Constant( 1.4 ), Constant( "TestValue3" ) )
-                ]
-            ),
-            Constant( "after switch" )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( switchBlock );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 10, variables: 2 );
-
-        AssertTransition.AssertSwitch( result.Scopes[0].Nodes[0].Transition,
-            defaultLabel: "ST_0002",
-            "ST_0003", "ST_0004", "ST_0009" );
-
-        AssertTransition.AssertSwitch( result.Scopes[0].Nodes[4].Transition,
-            defaultLabel: "ST_0006",
-            "ST_0007", "ST_0008" );
-
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[1] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithSwitch()
-    {
-        var gotoLabel = Label( "goto" );
-        var switchBlock = Block(
-            Constant( "before switch" ),
-            Switch(
-                Constant( "switchTest" ),
-                SwitchCase( Goto( gotoLabel ), Constant( "TestValue1" ) ),
-                SwitchCase( Goto( gotoLabel ), Constant( "TestValue1" ) ),
-                SwitchCase( Goto( gotoLabel ), Constant( "TestValue3" ) )
-            ),
-            Label( gotoLabel )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( switchBlock );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 5, variables: 0 );
-
-        AssertTransition.AssertSwitch( result.Scopes[0].Nodes[0].Transition,
-            defaultLabel: null,
-            "ST_0002", "ST_0003", "ST_0004" );
-
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[1] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithDefaultSwitch()
-    {
-        var switchBlock = Block(
-            Constant( "before switch" ),
-            Switch(
-                Constant( "switchTest" ),
-                Constant( 1.1 ),
-                [
-                    SwitchCase( Constant( 1.2 ), Constant( "TestValue1" ) ),
-                    SwitchCase( Constant( 1.3 ), Constant( "TestValue1" ) ),
-                    SwitchCase( Constant( 1.4 ), Constant( "TestValue3" ) )
-                ]
-            ),
-            Constant( "after switch" )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( switchBlock );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 6, variables: 1 );
-
-        AssertTransition.AssertSwitch( result.Scopes[0].Nodes[0].Transition,
-            defaultLabel: "ST_0002",
-            "ST_0003", "ST_0004", "ST_0005" );
-
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[1] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithSwitchAwaits()
-    {
-        var switchBlock = Block(
-            Constant( "before switch" ),
-            Switch(
-                Await( Constant( Task.FromResult( "await switch Test" ) ) ),
-                Constant( 1.1 ),
-                SwitchCase( Constant( 1.2 ), Constant( "TestValue1" ) ),
-                SwitchCase( Await( Constant( Task.FromResult( 1.3 ) ) ), Constant( "TestValue2" ) ),
-                SwitchCase( Constant( 1.4 ), Constant( "TestValue3" ) )
-            ),
-            Constant( "after switch" )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( switchBlock );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 10, variables: 5, jumps: 2 );
-
-        AssertTransition.AssertSwitch( result.Scopes[0].Nodes[1].Transition,
-            defaultLabel: "ST_0004",
-            "ST_0005", "ST_0006", "ST_0009" );
-
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[3] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithAwaitAssignments()
-    {
-        // Arrange
-        var methodInfo = GetMethod( nameof( Test ) );
-
-        var aParam = Parameter( typeof( int ), "a" );
-        var bParam = Parameter( typeof( int ), "b" );
-        var methodWithParameter = Block(
-            [aParam, bParam],
-            Constant( "before parameters" ),
-            Assign( aParam, Await( Constant( Task.FromResult( 1 ) ) ) ),
-            Assign( bParam, Await( Constant( Task.FromResult( 2 ) ) ) ),
-            Constant( "after parameters" ),
-            Call( methodInfo, aParam, bParam )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( methodWithParameter );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 9, variables: 8, jumps: 4 );
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[7] );
-
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithNestedBlockAndAwaitParameters()
-    {
-        // Arrange
-        var methodInfo = GetMethod( nameof( TestAsync ) );
-
-        var aParam = Parameter( typeof( int ), "a" );
-        var bParam = Parameter( typeof( int ), "b" );
-        var methodWithParameter = Block(
-            [aParam, bParam],
-            Constant( "before parameters" ),
-            Assign( aParam, Constant( 1 ) ),
-            Assign( bParam, Constant( 2 ) ),
-            Constant( "after parameters" ),
-            Await( Call( methodInfo, aParam, bParam ) )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( methodWithParameter );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 3, variables: 2, jumps: 1 );
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[1] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithMethodAwaits()
-    {
-        // Arrange
-        var methodInfo = GetMethod( nameof( TestAsync ) );
-
-        var callExpr = Block(
-            Constant( "before await" ),
-            Await( Call( methodInfo,
-                Constant( 1 ),
-                Constant( 2 ) ) ),
-            Constant( "after await" )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( callExpr );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 3, variables: 2, jumps: 1 );
-
-        AssertTransition.AssertAwait( result.Scopes[0].Nodes[0].Transition, "ST_0002" );
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[1] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithMethodAwaitArguments()
-    {
-        // Arrange
-        var methodInfo = GetMethod( nameof( Test ) );
-
-        var callExpr = Block( Call(
-            methodInfo,
-            Await( Constant( Task.FromResult( 1 ) ) ),
-            Await( Constant( Task.FromResult( 2 ) ) ) )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( callExpr );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 5, variables: 4, jumps: 2 );
-
-        AssertTransition.AssertAwait( result.Scopes[0].Nodes[0].Transition, "ST_0002" );
-        AssertTransition.AssertAwait( result.Scopes[0].Nodes[1].Transition, "ST_0004" );
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[3] );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithLoop()
-    {
-        // Arrange
-        var breakLabel = Label( typeof( bool ), "breakLoop" );
-        var continueLabel = Label( "continueLoop" );
-        var whileBlockExpr = Block(
-            Constant( "before loop" ),
-            Loop(
-                Block(
-                    Constant( "loop body before" ),
-                    IfThenElse( Constant( true ),
-                        Break( breakLabel, Constant( false ) ),
-                        Continue( continueLabel )
-                    ),
-                    Constant( "loop body after" ) ),
-                breakLabel,
-                continueLabel ),
-            Constant( "after loop" )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( whileBlockExpr );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 6, variables: 1 );
-
-        AssertTransition.AssertLoop( result.Scopes[0].Nodes[0].Transition, "ST_0002" );
-
-        AssertTransition.AssertGoto( result.Scopes[0].Nodes[3].Transition, "ST_0002" );
-        AssertTransition.AssertGoto( result.Scopes[0].Nodes[4].Transition, "ST_0003" );
-        AssertTransition.AssertGoto( result.Scopes[0].Nodes[5].Transition, "ST_0003" );
-
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[1] );
-
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithTryCatch()
-    {
-        // Arrange
-        var tryCatchExpr = Block(
-            Constant( "before try" ),
-            TryCatch(
-                Block(
-                    Constant( "try body before exception" ),
-                    Throw( Constant( new Exception( "Test Exception" ) ) ),
-                    Constant( "try body after exception" ) ),
-                Catch( typeof( Exception ), Block(
-                    Constant( "Exception catch body" ) ) ),
-                Catch( typeof( ArgumentException ), Block(
-                    Constant( "ArgumentException catch body" ) ) ) ),
-            Constant( "after try" )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( tryCatchExpr );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 4, variables: 3 );
-
-        AssertTransition.AssertTryCatch( result.Scopes[0].Nodes[0].Transition, null,
-            typeof( Exception ),
-            typeof( ArgumentException ) );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithTryCatchFinally()
-    {
-        // Arrange
-        var tryCatchExpr = Block(
-            Constant( "before try" ),
-            TryCatchFinally(
-                Block(
-                    Constant( "try body before exception" ),
-                    Throw( Constant( new Exception( "Test Exception" ) ) ),
-                    Constant( "try body after exception" ) ),
-                Block(
-                    Constant( "finally block" ) ),
-                Catch( typeof( Exception ), Block(
-                    Constant( "Exception catch body" ) ) ),
-                Catch( typeof( ArgumentException ), Block(
-                    Constant( "ArgumentException catch body" ) ) ) ),
-            Constant( "after try" )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( tryCatchExpr );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 5, variables: 3 );
-
-        AssertTransition.AssertTryCatch( result.Scopes[0].Nodes[0].Transition, "ST_0002",
-            typeof( Exception ),
-            typeof( ArgumentException ) );
-    }
-
-    [TestMethod]
-    public void Lowering_ShouldBranch_WithComplexConditions()
-    {
-        // Arrange
-        var ifThenElseExpr = Block(
-            Constant( 0 ),
-            IfThen(
-                Await( Constant( Task.FromResult( true ) ) ),
-                Block(
-                    Constant( "before await" ),
-                    Await( Constant( Task.FromResult( "await" ) ) ),
-                    Constant( "before if" ),
-                    IfThenElse( Constant( false ), Constant( 1.1 ), Block( Constant( 1.2 ), Constant( 1.3 ) ) ),
-                    Constant( "after if" ),
-                    Switch(
-                        Await( Constant( Task.FromResult( "AwaitTestValue2" ) ) ),
-                        Constant( 3.1 ),
-                        [
-                            SwitchCase( Constant( 3.2 ), Constant( "TestValue1" ) ),
-                            SwitchCase( Constant( 3.3 ), Await( Constant( Task.FromResult( "AwaitTestValue2" ) ) ) ),
-                            SwitchCase( Constant( 3.4 ), Constant( "TestValue3" ) )
-                        ]
-                    ),
-                    Constant( 4 )
-                ) ),
-            Constant( 5 )
-        );
-
-        // Act
-        var visitor = new LoweringVisitor();
-        var result = visitor.Transform( ifThenElseExpr );
-
-        // Assert
-        AssertTransition.AssertResult( result, nodes: 17, variables: 7, jumps: 3 );
-        AssertTransition.AssertFinal( result.Scopes[0].Nodes[3] );
-    }
-
-    public static class AssertTransition
-    {
-
-        public static class TransitionType
-        {
-            public static Type Goto => typeof( GotoTransition );
-            public static Type Await => typeof( AwaitTransition );
-            public static Type AwaitResult => typeof( AwaitResultTransition );
-            public static Type Conditional => typeof( ConditionalTransition );
-            public static Type Loop => typeof( LoopTransition );
-            public static Type Switch => typeof( SwitchTransition );
-            public static Type TryCatch => typeof( TryCatchTransition );
-        }
-
-        public static void AssertResult( LoweringResult result, int nodes = 0, int variables = 0, int jumps = 0 )
-        {
-            Assert.AreEqual( nodes, result.Scopes[0].Nodes.Count );
-            Assert.AreEqual( variables, result.Variables.Length );
-            Assert.AreEqual( jumps, result.Scopes[0].JumpCases.Count );
-        }
-
-        public static NodeExpression AssertGoto( Transition transition, string labelName )
-        {
-            Assert.AreEqual( TransitionType.Goto, transition.GetType() );
-            var gotoTransition = (GotoTransition) transition;
-            Assert.AreEqual( labelName, gotoTransition.TargetNode.NodeLabel.Name );
-            return gotoTransition.TargetNode;
-        }
-
-        public static NodeExpression AssertAwait( Transition transition, string completionLabel )
-        {
-            Assert.AreEqual( TransitionType.Await, transition.GetType() );
-            var awaitTransition = (AwaitTransition) transition;
-            Assert.AreEqual( completionLabel, awaitTransition.CompletionNode.NodeLabel.Name );
-            return awaitTransition.CompletionNode;
-        }
-
-        public static NodeExpression AssertAwaitResult( Transition transition, string labelName )
-        {
-            Assert.AreEqual( TransitionType.AwaitResult, transition.GetType() );
-            var awaitTransition = (AwaitResultTransition) transition;
-            Assert.AreEqual( labelName, awaitTransition.TargetNode.NodeLabel.Name );
-            return awaitTransition.TargetNode;
-        }
-
-        public static NodeExpression AssertLoop( Transition transition, string labelName )
-        {
-            Assert.AreEqual( TransitionType.Loop, transition.GetType() );
-            var loopTransition = (LoopTransition) transition;
-            Assert.AreEqual( labelName, loopTransition.BodyNode.NodeLabel.Name );
-            return loopTransition.BodyNode;
-        }
-
-        public static (NodeExpression IfTrueNode, NodeExpression IfFalseNode) AssertConditional(
-            Transition transition,
-            string trueLabelName,
-            string falseLabelName )
-        {
-            Assert.AreEqual( TransitionType.Conditional, transition.GetType() );
-            var conditionalTransition = (ConditionalTransition) transition;
-            Assert.AreEqual( trueLabelName, conditionalTransition.IfTrue.NodeLabel.Name );
-            Assert.AreEqual( falseLabelName, conditionalTransition.IfFalse.NodeLabel.Name );
-            return (conditionalTransition.IfTrue, conditionalTransition.IfFalse);
-        }
-
-        public static void AssertTryCatch(
-            Transition transition,
-            string finalLabel,
-            params Type[] catchTests )
-        {
-            Assert.AreEqual( TransitionType.TryCatch, transition.GetType() );
-            var tryCatchTransition = (TryCatchTransition) transition;
-
-            Assert.AreEqual( catchTests.Length, tryCatchTransition.CatchBlocks.Count );
-            for ( var i = 0; i < tryCatchTransition.CatchBlocks.Count; i++ )
-            {
-                Assert.AreEqual( catchTests[i], tryCatchTransition.CatchBlocks[i].Handler.Test );
-            }
-
-            if ( finalLabel != null || tryCatchTransition.FinallyNode != null )
-            {
-                Assert.AreEqual( finalLabel, tryCatchTransition.FinallyNode.NodeLabel.Name );
-            }
-        }
-
-        public static void AssertSwitch(
-            Transition transition,
-            string defaultLabel,
-            params string[] caseLabels )
-        {
-            Assert.AreEqual( TransitionType.Switch, transition.GetType() );
-            var switchTransition = (SwitchTransition) transition;
-
-            Assert.AreEqual( caseLabels.Length, switchTransition.CaseNodes.Count );
-            for ( var i = 0; i < switchTransition.CaseNodes.Count; i++ )
-            {
-                Assert.AreEqual( caseLabels[i], switchTransition.CaseNodes[i].Body.NodeLabel.Name );
-            }
-
-            if ( defaultLabel != null || switchTransition.DefaultNode != null )
-            {
-                Assert.AreEqual( defaultLabel, switchTransition.DefaultNode.NodeLabel.Name );
-            }
-        }
-        public static void AssertLabel( LabelTarget label, string expectedName, Type expectedType )
-        {
-            Assert.AreEqual( expectedName, label.Name );
-            Assert.AreEqual( expectedType, label.Type );
-        }
-
-        public static void AssertFinal( NodeExpression finalNode )
-        {
-            Assert.IsTrue( finalNode.Transition == null );
-        }
-
-    }
-}
diff --git a/test/Hyperbee.Expressions.Tests/StringFormatExpressionTests.cs b/test/Hyperbee.Expressions.Tests/StringFormatExpressionTests.cs
new file mode 100644
index 0000000..da5fea0
--- /dev/null
+++ b/test/Hyperbee.Expressions.Tests/StringFormatExpressionTests.cs
@@ -0,0 +1,74 @@
+using System.Linq.Expressions;
+
+namespace Hyperbee.Expressions.Tests;
+
+[TestClass]
+public class StringFormatExpressionTests
+{
+    [TestMethod]
+    public void StringFormatExpression_Should_Return_Format_When_No_Arguments()
+    {
+        // Arrange
+        var format = Expression.Constant( "Hello, world!" );
+
+        var formatExpr = ExpressionExtensions.StringFormat( format, [] );
+
+        // Act
+        var lambda = Expression.Lambda<Func<string>>( formatExpr ).Compile();
+        var result = lambda();
+
+        // Assert
+        Assert.AreEqual( "Hello, world!", result, "Should return the format string when no arguments are provided." );
+    }
+
+    [TestMethod]
+    public void StringFormatExpression_Should_Format_String_With_Arguments()
+    {
+        // Arrange
+        var format = Expression.Constant( "Hello, {0}! You have {1} new messages." );
+        var arg1 = Expression.Constant( "Alice" );
+        var arg2 = Expression.Constant( 5 );
+
+        var formatExpr = ExpressionExtensions.StringFormat( format, [arg1, arg2] );
+
+        // Act
+        var lambda = Expression.Lambda<Func<string>>( formatExpr ).Compile();
+        var result = lambda();
+
+        // Assert
+        Assert.AreEqual( "Hello, Alice! You have 5 new messages.", result, "Should correctly format the string." );
+    }
+
+    [TestMethod]
+    [ExpectedException( typeof( ArgumentException ) )]
+    public void StringFormatExpression_Should_Throw_If_Format_Is_Not_String()
+    {
+        // Arrange
+        var invalidFormat = Expression.Constant( 42 );
+
+        // Act
+        _ = ExpressionExtensions.StringFormat( invalidFormat, Expression.Constant( 10 ) );
+
+        // Assert: Exception is expected
+    }
+    [TestMethod]
+    public void StringFormatExpression_Should_Work_Within_Complex_Block()
+    {
+        // Arrange
+        var format = Expression.Constant( "The sum of {0} and {1} is {2}" );
+        var x = Expression.Parameter( typeof( int ), "x" );
+        var y = Expression.Parameter( typeof( int ), "y" );
+        var sum = Expression.Add( x, y );
+
+        var formatExpr = ExpressionExtensions.StringFormat( format, [x, y, sum] );
+
+        var block = Expression.Block( formatExpr );
+
+        // Act
+        var lambda = Expression.Lambda<Func<int, int, string>>( block, x, y ).Compile();
+        var result = lambda( 10, 20 );
+
+        // Assert
+        Assert.AreEqual( "The sum of 10 and 20 is 30", result, "Should correctly format the string within a block." );
+    }
+}
diff --git a/test/Hyperbee.Expressions.Tests/TestSupport/AwaitHelper.cs b/test/Hyperbee.Expressions.Tests/TestSupport/AwaitHelper.cs
new file mode 100644
index 0000000..023eb17
--- /dev/null
+++ b/test/Hyperbee.Expressions.Tests/TestSupport/AwaitHelper.cs
@@ -0,0 +1,75 @@
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Hyperbee.Expressions.Tests.TestSupport;
+
+internal static class AsyncHelper
+{
+    public static Expression Completable( Expression completeimmediateFlagExpression, Expression resultExpression )
+    {
+        var resultType = resultExpression.Type;
+
+        var asyncHelperMethod = typeof( AsyncHelper ).GetMethod(
+            nameof( CompletableResultAsync ),
+            BindingFlags.Static | BindingFlags.NonPublic
+        )!.MakeGenericMethod( resultType );
+
+        return Expression.Call(
+            asyncHelperMethod,
+            completeimmediateFlagExpression,
+            resultExpression
+        );
+    }
+
+    public static Expression Completable( Expression completeimmediateFlagExpression )
+    {
+        var asyncHelperMethod = typeof( AsyncHelper ).GetMethod(
+            nameof( CompletableAsync ),
+            BindingFlags.Static | BindingFlags.NonPublic
+        );
+
+        return Expression.Call(
+            asyncHelperMethod!,
+            completeimmediateFlagExpression
+        );
+    }
+
+    private static DeferredTaskCompletionSource CompletableAsync( bool completeimmediateFlag )
+    {
+        var deferredTcs = new DeferredTaskCompletionSource();
+
+        if ( completeimmediateFlag )
+        {
+            deferredTcs.SetResult();
+            return deferredTcs;
+        }
+
+        Task.Run( () =>
+        {
+            deferredTcs.WaitForSignal();
+            deferredTcs.SetResult();
+        } );
+
+        return deferredTcs;
+    }
+
+    private static DeferredTaskCompletionSource<T> CompletableResultAsync<T>( bool completeimmediateFlag, T result )
+    {
+        var deferredTcs = new DeferredTaskCompletionSource<T>();
+
+        if ( completeimmediateFlag )
+        {
+            deferredTcs.SetResult( result );
+            return deferredTcs;
+        }
+
+        Task.Run( () =>
+        {
+            deferredTcs.WaitForSignal();
+            deferredTcs.SetResult( result );
+        } );
+
+        return deferredTcs;
+    }
+}
+
diff --git a/test/Hyperbee.Expressions.Tests/TestSupport/DeferredTaskCompletionSource.cs b/test/Hyperbee.Expressions.Tests/TestSupport/DeferredTaskCompletionSource.cs
new file mode 100644
index 0000000..8c2ae5a
--- /dev/null
+++ b/test/Hyperbee.Expressions.Tests/TestSupport/DeferredTaskCompletionSource.cs
@@ -0,0 +1,128 @@
+
+using System.Runtime.CompilerServices;
+
+namespace Hyperbee.Expressions.Tests.TestSupport;
+
+internal sealed class DeferredTaskCompletionSource : ICriticalNotifyCompletion
+{
+    private readonly ManualResetEventSlim _completedEvent = new();
+    private readonly TaskCompletionSource _tcs = new();
+
+    public Task Task => _tcs.Task;
+
+    public bool IsCompleted
+    {
+        get
+        {
+            // We set the event after the first time the property is accessed.
+            // This effectively defers the completion of the task until later
+            // by ensuring that the first call to the property getter returns false.
+
+            if ( _completedEvent.IsSet )
+                return _tcs.Task.IsCompleted;
+
+            _completedEvent.Set();
+            return false;
+        }
+    }
+
+    public void OnCompleted( Action continuation )
+    {
+        _tcs.Task.GetAwaiter().OnCompleted( continuation );
+    }
+
+    public void UnsafeOnCompleted( Action continuation )
+    {
+        _tcs.Task.GetAwaiter().UnsafeOnCompleted( continuation );
+    }
+
+    public void GetResult()
+    {
+        _tcs.Task.GetAwaiter().GetResult();
+    }
+
+    public void WaitForSignal()
+    {
+        _completedEvent.Wait();
+    }
+
+    public void SetResult()
+    {
+        if ( !_completedEvent.IsSet )
+            _completedEvent.Set();
+
+        _tcs.SetResult();
+    }
+
+    public void SetException( Exception exception )
+    {
+        if ( !_completedEvent.IsSet )
+            _completedEvent.Set();
+
+        _tcs.SetException( exception );
+    }
+
+    public DeferredTaskCompletionSource GetAwaiter() => this;
+}
+
+internal sealed class DeferredTaskCompletionSource<T> : ICriticalNotifyCompletion
+{
+    private readonly ManualResetEventSlim _completedEvent = new();
+    private readonly TaskCompletionSource<T> _tcs = new();
+
+    public Task<T> Task => _tcs.Task;
+
+    public bool IsCompleted
+    {
+        get
+        {
+            // We set the event after the first time the property is accessed.
+            // This effectively defers the completion of the task until later
+            // by ensuring that the first call to the property getter returns false.
+
+            if ( _completedEvent.IsSet )
+                return _tcs.Task.IsCompleted;
+
+            _completedEvent.Set();
+            return false;
+        }
+    }
+
+    public void OnCompleted( Action continuation )
+    {
+        _tcs.Task.GetAwaiter().OnCompleted( continuation );
+    }
+
+    public void UnsafeOnCompleted( Action continuation )
+    {
+        _tcs.Task.GetAwaiter().UnsafeOnCompleted( continuation );
+    }
+
+    public T GetResult()
+    {
+        return _tcs.Task.GetAwaiter().GetResult();
+    }
+
+    public void WaitForSignal()
+    {
+        _completedEvent.Wait();
+    }
+
+    public void SetResult( T result )
+    {
+        if ( !_completedEvent.IsSet )
+            _completedEvent.Set();
+
+        _tcs.SetResult( result );
+    }
+
+    public void SetException( Exception exception )
+    {
+        if ( !_completedEvent.IsSet )
+            _completedEvent.Set();
+
+        _tcs.SetException( exception );
+    }
+
+    public DeferredTaskCompletionSource<T> GetAwaiter() => this;
+}
diff --git a/test/Hyperbee.Expressions.Tests/TestSupport/ExpressionExtensions.cs b/test/Hyperbee.Expressions.Tests/TestSupport/ExpressionExtensions.cs
new file mode 100644
index 0000000..4c64058
--- /dev/null
+++ b/test/Hyperbee.Expressions.Tests/TestSupport/ExpressionExtensions.cs
@@ -0,0 +1,13 @@
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Hyperbee.Expressions.Tests.TestSupport;
+
+public static class ExpressionExtensions
+{
+    public static string GetDebugView( this Expression expression )
+    {
+        var debugViewProperty = typeof( Expression ).GetProperty( "DebugView", BindingFlags.Instance | BindingFlags.NonPublic );
+        return debugViewProperty?.GetValue( expression ) as string ?? string.Empty;
+    }
+}
diff --git a/test/Hyperbee.Expressions.Tests/UsingExpressionTests.cs b/test/Hyperbee.Expressions.Tests/UsingExpressionTests.cs
index 1398602..b8a932a 100644
--- a/test/Hyperbee.Expressions.Tests/UsingExpressionTests.cs
+++ b/test/Hyperbee.Expressions.Tests/UsingExpressionTests.cs
@@ -1,4 +1,6 @@
-using System.Linq.Expressions;
+using Hyperbee.Expressions.Tests.TestSupport;
+using static System.Linq.Expressions.Expression;
+using static Hyperbee.Expressions.ExpressionExtensions;
 
 namespace Hyperbee.Expressions.Tests;
 
@@ -17,7 +19,6 @@ public void Dispose()
 
     private bool _wasBodyExecuted;
 
-    // Helper method used in the body expression
     public void SetWasBodyExecuted()
     {
         _wasBodyExecuted = true;
@@ -34,14 +35,14 @@ public void UsingExpression_ShouldDisposeResource_AfterUse()
     {
         // Arrange
         var resource = new TestDisposableResource();
-        var disposableExpression = Expression.Constant( resource, typeof( TestDisposableResource ) );
+        var disposableExpression = Constant( resource, typeof( TestDisposableResource ) );
 
-        var bodyExpression = Expression.Empty(); // Actual body is unimportant
+        var bodyExpression = Empty(); // Actual body is unimportant
 
         // Act
-        var usingExpression = ExpressionExtensions.Using( disposableExpression, bodyExpression );
+        var usingExpression = Using( disposableExpression, bodyExpression );
 
-        var lambda = Expression.Lambda<Action>( usingExpression );
+        var lambda = Lambda<Action>( usingExpression );
         var compiledLambda = lambda.Compile();
 
         compiledLambda();
@@ -55,18 +56,18 @@ public void UsingExpression_ShouldExecuteBodyExpression()
     {
         // Arrange
         var resource = new TestDisposableResource();
-        var disposableExpression = Expression.Constant( resource, typeof( TestDisposableResource ) );
+        var disposableExpression = Constant( resource, typeof( TestDisposableResource ) );
 
         // Create a body expression that sets 'wasBodyExecuted' to true
-        var bodyExpression = Expression.Call(
-            Expression.Constant( this ),
+        var bodyExpression = Call(
+            Constant( this ),
             typeof( UsingExpressionTests ).GetMethod( nameof( SetWasBodyExecuted ) )!
         );
 
         // Act
-        var usingExpression = ExpressionExtensions.Using( disposableExpression, bodyExpression );
+        var usingExpression = Using( disposableExpression, bodyExpression );
 
-        var lambda = Expression.Lambda<Action>( usingExpression );
+        var lambda = Lambda<Action>( usingExpression );
         var compiledLambda = lambda.Compile();
 
         compiledLambda();
@@ -75,15 +76,66 @@ public void UsingExpression_ShouldExecuteBodyExpression()
         Assert.IsTrue( _wasBodyExecuted, "The body expression should be executed." );
     }
 
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task UsingExpression_ShouldExecuteAsyncExpression( bool immediateFlag )
+    {
+        // Arrange
+        var resource = new TestDisposableResource();
+        var disposableExpression = Constant( resource, typeof( TestDisposableResource ) );
+
+        var bodyExpression = BlockAsync(
+            Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 10 ) ) )
+        );
+
+        // Act
+        var usingExpression = Using( disposableExpression, bodyExpression );
+
+        var lambda = Lambda<Func<Task<int>>>( usingExpression );
+        var compiledLambda = lambda.Compile();
+
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 10, result );
+    }
+
+    [DataTestMethod]
+    [DataRow( true )]
+    [DataRow( false )]
+    public async Task UsingExpression_ShouldExecuteAsyncExpression_WithInnerUsing( bool immediateFlag )
+    {
+        // Arrange
+        var resource = new TestDisposableResource();
+        var disposableExpression = Constant( resource, typeof( TestDisposableResource ) );
+
+        var bodyExpression = BlockAsync(
+            Using(
+                disposableExpression,
+                Await( AsyncHelper.Completable( Constant( immediateFlag ), Constant( 10 ) ) )
+            )
+        );
+
+        // Act
+        var lambda = Lambda<Func<Task<int>>>( bodyExpression );
+        var compiledLambda = lambda.Compile();
+
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 10, result );
+    }
+
     [TestMethod]
     [ExpectedException( typeof( ArgumentException ) )]
     public void UsingExpression_ShouldThrowArgumentException_WhenNonDisposableUsed()
     {
         // Arrange
-        var nonDisposableExpression = Expression.Constant( "non-disposable string" );
+        var nonDisposableExpression = Constant( "non-disposable string" );
 
         // Act
-        ExpressionExtensions.Using( nonDisposableExpression, Expression.Empty() );
+        Using( nonDisposableExpression, Empty() );
 
         // Assert: Expect an ArgumentException due to non-disposable resource
         // The constructor should throw the exception, no need for further assertions
@@ -94,15 +146,14 @@ public void UsingExpression_ShouldDisposeResource_EvenIfExceptionThrown()
     {
         // Arrange
         var resource = new TestDisposableResource();
-        var disposableExpression = Expression.Constant( resource, typeof( TestDisposableResource ) );
+        var disposableExpression = Constant( resource, typeof( TestDisposableResource ) );
 
-        // Create a body expression that throws an exception
-        var bodyExpression = Expression.Throw( Expression.New( typeof( Exception ) ) );
+        var bodyExpression = Throw( New( typeof( Exception ) ) );
 
         // Act
-        var usingExpression = ExpressionExtensions.Using( disposableExpression, bodyExpression );
+        var usingExpression = Using( disposableExpression, bodyExpression );
 
-        var lambda = Expression.Lambda<Action>( usingExpression );
+        var lambda = Lambda<Action>( usingExpression );
         var compiledLambda = lambda.Compile();
 
         // Assert: Execute the expression and catch the exception, check if the resource was disposed
diff --git a/test/Hyperbee.Expressions.Tests/WhileExpressionTests.cs b/test/Hyperbee.Expressions.Tests/WhileExpressionTests.cs
index d728225..5821b5f 100644
--- a/test/Hyperbee.Expressions.Tests/WhileExpressionTests.cs
+++ b/test/Hyperbee.Expressions.Tests/WhileExpressionTests.cs
@@ -1,4 +1,5 @@
-using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
+using static Hyperbee.Expressions.ExpressionExtensions;
 
 namespace Hyperbee.Expressions.Tests;
 
@@ -9,20 +10,16 @@ public class WhileExpressionTests
     public void WhileExpression_ShouldBreak_WhenConditionMet()
     {
         // Arrange
-        var counter = Expression.Variable( typeof( int ), "counter" );
-        var counterInit = Expression.Assign( counter, Expression.Constant( 0 ) );
+        var counter = Variable( typeof( int ), "counter" );
+        var counterInit = Assign( counter, Constant( 0 ) );
 
-        // Condition: while (counter < 10)
-        var condition = Expression.LessThan( counter, Expression.Constant( 10 ) );
+        var condition = LessThan( counter, Constant( 10 ) );
 
-        var whileExpr = ExpressionExtensions.While( condition,
-
-            // increment counter
-            Expression.PostIncrementAssign( counter )
+        var whileExpr = While( condition,
+            PostIncrementAssign( counter )
         );
 
-        // Block to initialize the counter and execute the loop
-        var block = Expression.Block(
+        var block = Block(
             [counter],
             counterInit,
             whileExpr,
@@ -30,7 +27,7 @@ public void WhileExpression_ShouldBreak_WhenConditionMet()
         );
 
         // Act
-        var lambda = Expression.Lambda<Func<int>>( block );
+        var lambda = Lambda<Func<int>>( block );
         var compiledLambda = lambda.Compile();
 
         var result = compiledLambda();
@@ -43,24 +40,20 @@ public void WhileExpression_ShouldBreak_WhenConditionMet()
     public void WhileExpression_ShouldBreak()
     {
         // Arrange
-        var counter = Expression.Variable( typeof( int ), "counter" );
-        var counterInit = Expression.Assign( counter, Expression.Constant( 0 ) );
-
-        // Condition: while (counter < 10)
-        var condition = Expression.LessThan( counter, Expression.Constant( 10 ) );
+        var counter = Variable( typeof( int ), "counter" );
+        var counterInit = Assign( counter, Constant( 0 ) );
 
-        var whileExpr = ExpressionExtensions.While( condition, ( breakLabel, _ ) =>
+        var condition = LessThan( counter, Constant( 10 ) );
 
-            // if (counter == 5) break; else counter++
-            Expression.IfThenElse(
-                Expression.Equal( counter, Expression.Constant( 5 ) ),
-                Expression.Break( breakLabel ),
-                Expression.PostIncrementAssign( counter )
+        var whileExpr = While( condition, ( breakLabel, _ ) =>
+            IfThenElse(
+                Equal( counter, Constant( 5 ) ),
+                Break( breakLabel ),
+                PostIncrementAssign( counter )
             )
         );
 
-        // Block to initialize the counter and execute the loop
-        var block = Expression.Block(
+        var block = Block(
             [counter],
             counterInit,
             whileExpr,
@@ -68,7 +61,7 @@ public void WhileExpression_ShouldBreak()
         );
 
         // Act
-        var lambda = Expression.Lambda<Func<int>>( block );
+        var lambda = Lambda<Func<int>>( block );
         var compiledLambda = lambda.Compile();
 
         var result = compiledLambda();