Index: libcfa/src/concurrency/future.hfa
===================================================================
--- libcfa/src/concurrency/future.hfa	(revision e6e250dd2e3aad6c341b64a30dc67e27608341a2)
+++ libcfa/src/concurrency/future.hfa	(revision f41b1614e8f77a861276c86c3fd61b86cbde5ac7)
@@ -10,6 +10,6 @@
 // Created On       : Wed Jan 06 17:33:18 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Mar 29 22:47:01 2026
-// Update Count     : 224
+// Last Modified On : Fri Jul 10 07:16:22 2026
+// Update Count     : 232
 //
 
@@ -39,10 +39,10 @@
 	} // distribution
 
-	enum { FUTURE_EMPTY$ = 0, FUTURE_FULFILLED$ = 1 };
+	enum future_state$ ! { EMPTY, FULFILLED };
 
 	// PUBLIC
 
 	struct future {
-		int state;
+		future_state$ state;
 		T result;
 		exception_t * except;
@@ -59,5 +59,5 @@
 
 			// check if we can complete operation. If so race to establish winner in special OR case
-			if ( !s.park_counter && state != FUTURE_EMPTY$ ) {
+			if ( !s.park_counter && state != future_state$.EMPTY ) {
 				if ( !__make_select_node_available( s ) ) { // we didn't win the race so give up on registering
 					unlock( lock );
@@ -67,5 +67,5 @@
 
 			// future not ready -> insert select node and return
-		  if ( state == FUTURE_EMPTY$ ) {
+		  if ( state == future_state$.EMPTY ) {
 				insert_last( waiters, s );
 				unlock( lock );
@@ -99,5 +99,5 @@
  		void ?{}( future(T) & fut ) with( fut ) {
  			except = 0p;
- 			state = FUTURE_EMPTY$;
+ 			state = future_state$.EMPTY;
  		}
 
@@ -123,5 +123,5 @@
 
 			// LOCK ACQUIRED IN PUBLIC get
-			if ( state == FUTURE_FULFILLED$ ) {
+			if ( state == future_state$.FULFILLED ) {
 				exceptCheck();
 				copy_T$( ret_val, result );
@@ -140,10 +140,10 @@
 		// PUBLIC
 
-		bool available( future( T ) & fut ) { return __atomic_load_n( &fut.state, __ATOMIC_RELAXED ); } // future result available ?
+		bool available( future( T ) & fut ) { return fut.state == future_state$.FULFILLED; } // future result available ?
 
 		// Return a value/exception from the future.
 		[T, bool] get( future(T) & fut ) with( fut ) {
 			lock( lock );
-			bool ret = state == FUTURE_EMPTY$;
+			bool ret = state == future_state$.EMPTY;
 			return [ get$( fut ), ret ];
 		}
@@ -159,5 +159,5 @@
 			lock( lock );
 			T ret_val;
-			if ( state == FUTURE_FULFILLED$ ) {
+			if ( state == future_state$.FULFILLED ) {
 				copy_T$( ret_val, result );
 				unlock( lock );
@@ -174,5 +174,5 @@
 		bool fulfil$( future(T) & fut ) with( fut ) {	// helper
 			bool ret_val = ! empty( waiters );
-			state = FUTURE_FULFILLED$;
+			state = future_state$.FULFILLED;
 			while ( ! empty( waiters ) ) {
 				if ( !__handle_waituntil_OR( waiters ) ) // handle special waituntil OR case
@@ -194,5 +194,5 @@
 		bool fulfil( future(T) & fut, T val ) with( fut ) {
 			lock( lock );
-		  if ( state != FUTURE_EMPTY$ ) abort("Attempting to fulfil a future that has already been fulfilled");
+		  if ( state != future_state$.EMPTY ) abort("Attempting to fulfil a future that has already been fulfilled");
 			copy_T$( result, val );
 			return fulfil$( fut );
@@ -202,5 +202,5 @@
 		bool fulfil( future(T) & fut, exception_t * ex ) with( fut ) {
 			lock( lock );
-		  if ( state != FUTURE_EMPTY$ ) abort( "Attempting to fulfil a future that has already been fulfilled" );
+		  if ( state != future_state$.EMPTY ) abort( "Attempting to fulfil a future that has already been fulfilled" );
 			except = ( exception_t * ) malloc( ex->virtual_table->size );
 			ex->virtual_table->copy( except, ex );
@@ -212,5 +212,5 @@
 			lock( lock );
 		  if ( ! empty( waiters ) ) abort( "Attempting to reset a future with blocked waiters" );
-			state = FUTURE_EMPTY$;
+			state = future_state$.EMPTY;
 			free( except );
 			except = 0p;