added Futures

Src/Myc.Core.Atomic.pas

@@ -187,6 +187,10 @@ end;
 class operator TMycAtomicStack<T>.Finalize(var Dest: TMycAtomicStack<T>);
 begin
     Dest.Clear;
+    if Dest.FSList <> nil then // Check if FSList was initialized
+    begin
+        Dest.FSList.Free; // Call instance method Free on FSList via Dest
+    end;
 end;
 
 function TMycAtomicStack<T>.Alloc: PItem;
@@ -210,10 +214,6 @@ begin
         FreeMemAligned(item); // Global procedure
         item := PopPtr;  // Call instance method PopPtr via Dest
     end;
-    if FSList <> nil then // Check if FSList was initialized
-    begin
-        FSList.Free; // Call instance method Free on FSList via Dest
-    end;
 end;
 
 function TMycAtomicStack<T>.Pop: T;

Src/Myc.Core.Tasks.pas

@@ -8,17 +8,47 @@ uses
 
 type
     IMycTaskFactory = interface
-        {$region 'property access'}
-        function GetThreadCount: Integer;
-        {$endregion}
-        function CreateThread(const Proc: TProc): IMycState;
-        function InMainThread: Boolean;
-        function InWorkerThread: Boolean;
-        function Run(StartCount: Integer; Job: TProc): IMycSubscriber;
-        procedure Teardown;
-        procedure WaitFor(State: IMycState);
-        property ThreadCount: Integer read GetThreadCount;
-    end;
+        {$region 'property access'}
+        // Retrieves the number of worker threads.
+        function GetThreadCount: Integer;
+        {$endregion}
+
+        // Creates and starts a new, independent thread executing Proc.
+        // Returns IMycState to await thread completion.
+        // Exceptions within Proc are caught; the first one is stored
+        // and can be re-raised in the main thread via WaitFor or Teardown.
+        function CreateThread(const Proc: TProc): IMycState;
+
+        // Returns True if called from the main application thread.
+        function InMainThread: Boolean;
+
+        // Returns True if called from one of the factory's worker threads.
+        function InWorkerThread: Boolean;
+
+        // Schedules Job for execution by a worker thread.
+        // If StartCount > 0, Job is deferred until Notify is called StartCount times on the returned IMycSubscriber.
+        // If StartCount <= 0, Job is enqueued immediately.
+        // Returns IMycSubscriber for deferred jobs, or TMycLatch.Null for immediate jobs or if Job is nil.
+        // Exceptions during Job execution are caught; the first one is stored
+        // and can be re-raised in the main thread via WaitFor or Teardown.
+        // Raises ETaskException if the factory is already terminated.
+        function Run(StartCount: Integer; Job: TProc): IMycSubscriber;
+
+        // Shuts down the task factory: terminates worker threads and cleans up resources.
+        // Before shutdown, any first stored exception from a worker thread (from Run or CreateThread tasks managed by this factory)
+        // will be re-raised in the calling (main) thread.
+        procedure Teardown;
+
+        // Waits for the operation associated with State to complete.
+        // Must not be called from a worker thread of this factory.
+        // After waiting, or if the state is already set, any first stored exception
+        // from any worker thread of this factory will be re-raised in the calling (main) thread.
+        // Raises ETaskException if called from within a worker thread.
+        procedure WaitFor(State: IMycState);
+
+        // Gets the number of worker threads.
+        property ThreadCount: Integer read GetThreadCount;
+    end;
 
     TMycTaskFactory = class(TInterfacedObject, IMycTaskFactory)
     type
@@ -58,7 +88,7 @@ type
 implementation
 
 type
-    TMyc2PendingJob = class(TInterfacedObject, IMycSubscriber)
+    TMycPendingJob = class(TInterfacedObject, IMycSubscriber)
     private
         [volatile]
         FCount: Integer; // Countdown counter
@@ -73,7 +103,7 @@ type
         property Owner: TMycTaskFactory read FOwner;
     end;
 
-    TMyc2TaskWait = class sealed(TInterfacedObject, IMycSubscriber)
+    TMycTaskWait = class sealed(TInterfacedObject, IMycSubscriber)
     private
         [volatile]
         FSemaphore: TSemaphore; // System.SyncObjs.TSemaphore to be released on notification
@@ -88,8 +118,6 @@ type
 { TMycTaskFactory }
 
 constructor TMycTaskFactory.Create;
-var
-    i: Integer;
 begin
     inherited Create;
 
@@ -98,24 +126,31 @@ begin
     FWorkGate := TSemaphore.Create(nil, 0, MaxInt, ''); // Initial count is 0, workers will wait
 
     SetLength(FWorkThreads, TThread.ProcessorCount); // Create one thread per processor core
-    for i := 0 to High(FWorkThreads) do
+    for var i := 0 to High(FWorkThreads) do
     begin
         FWorkThreads[i] := CreateAnonymousThread('Thread pool [' + IntToStr(i) + ']', WorkerThread);
         TInterlocked.Increment(FThreadsRunning); // Increment active thread counter
-        FWorkThreads[i].Start;
+        FWorkThreads[i].FreeOnTerminate := false;
     end;
+    for var i := 0 to High(FWorkThreads) do
+        FWorkThreads[i].Start;
 end;
 
 destructor TMycTaskFactory.Destroy;
 begin
     Teardown; // Perform cleanup and stop threads
 
+    for var i := High(FWorkThreads) downto 0 do
+        FWorkThreads[i].Free;
+
     FWorkGate.Free;
+    FWorkStack.Clear;
     inherited Destroy;
 end;
 
 class function TMycTaskFactory.CreateAnonymousThread(const DbgName: String; const Proc: TProc): TThread;
 {$IFDEF MSWINDOWS}
+{$WARN SYMBOL_PLATFORM OFF}
 var
     prio: TThreadPriority;
 {$ENDIF MSWINDOWS}
@@ -123,7 +158,6 @@ begin
     Result := TThread.CreateAnonymousThread(Proc);
 
     {$IFDEF MSWINDOWS}
-    {$WARN SYMBOL_PLATFORM OFF}
     // Set priority lower than MainThread priority if created from main thread
     if TThread.CurrentThread.ThreadID = MainThreadID then
     begin
@@ -199,7 +233,7 @@ begin
     begin
         ex := AtomicExchange(Pointer(FException), nil); // Atomically retrieve and clear the stored exception
         if ex <> nil then
-            raise ex; // Re-raise the exception in the main thread
+            raise Exception(ex);
     end;
 end;
 
@@ -238,7 +272,7 @@ begin
     end
     else
         // Create a pending job that waits for StartCount notifications
-        Result := TMyc2PendingJob.Create(StartCount, Self, Job);
+        Result := TMycPendingJob.Create(StartCount, Self, Job);
 end;
 
 procedure TMycTaskFactory.Teardown;
@@ -285,17 +319,19 @@ begin
     if InWorkerThread then
         raise ETaskException.Create('Waiting not allowed within tasks');
 
-    lock := FWaitSemaphores.Pop();
-    if lock = nil then
-        lock := TSemaphore.Create(nil, 0, 1, '');
     try
-        var subscription := State.Subscribe(TMyc2TaskWait.Create(lock));
-        lock.Acquire;
+        lock := FWaitSemaphores.Pop();
+        if lock = nil then
+            lock := TSemaphore.Create(nil, 0, 1, '');
+        try
+            var subscription := State.Subscribe(TMycTaskWait.Create(lock));
+            lock.Acquire;
+        finally
+            FWaitSemaphores.Push(lock);
+        end;
     finally
-        FWaitSemaphores.Push(lock);
+        HandleException;
     end;
-
-    HandleException;
 end;
 
 procedure TMycTaskFactory.ExecuteJob;
@@ -315,9 +351,9 @@ begin
     end;
 end;
 
-{ TMyc2PendingJob }
+{ TMycPendingJob }
 
-constructor TMyc2PendingJob.Create(StartCountValue: Integer; OwnerTaskFactory: TMycTaskFactory; const JobProc: TProc);
+constructor TMycPendingJob.Create(StartCountValue: Integer; OwnerTaskFactory: TMycTaskFactory; const JobProc: TProc);
 begin
     inherited Create;
     Assert(StartCountValue > 0);
@@ -326,7 +362,7 @@ begin
     FJob := JobProc;
 end;
 
-function TMyc2PendingJob.Notify: Boolean;
+function TMycPendingJob.Notify: Boolean;
 var
     newCount: Integer;
 begin
@@ -345,15 +381,15 @@ begin
     Result := newCount > 0;
 end;
 
-{ TMyc2TaskWait }
+{ TMycTaskWait }
 
-constructor TMyc2TaskWait.Create(SemaphoreToSignal: TSemaphore); // Parameter is System.SyncObjs.TSemaphore
+constructor TMycTaskWait.Create(SemaphoreToSignal: TSemaphore); // Parameter is System.SyncObjs.TSemaphore
 begin
     inherited Create;
     FSemaphore := SemaphoreToSignal; // Field is System.SyncObjs.TSemaphore
 end;
 
-function TMyc2TaskWait.Notify: Boolean;
+function TMycTaskWait.Notify: Boolean;
 var
     s: TSemaphore; // Local var is System.SyncObjs.TSemaphore
 begin

Src/Myc.Futures.pas

@@ -0,0 +1,108 @@
+unit Myc.Futures;
+
+interface
+
+uses
+    System.SysUtils,
+    Myc.Signals, Myc.Core.Tasks;
+
+type
+    // Represents the eventual result of an asynchronous operation.
+    IMycFuture<T> = interface
+        {$REGION 'property access'}
+        function GetResult: T;
+        function GetDone: IMycState;
+        {$ENDREGION}
+        // Provides access to the computed result.
+        property Result: T read GetResult;
+        // Provides access to the completion state.
+        property Done: IMycState read GetDone;
+    end;
+
+    // Abstract base class for IMycFuture<T> implementations.
+    TMycFuture<T> = class abstract(TInterfacedObject, IMycFuture<T>)
+      protected
+        function GetResult: T; virtual; abstract;
+        function GetDone: IMycState; virtual; abstract;
+    end;
+
+    // Concrete future implementation triggered by an initial state, executing a TFunc<T>.
+    TMycInitStateFuncFuture<T> = class(TMycFuture<T>)
+      private
+        FInit: TMycSubscription;
+        FDone: IMycLatch;
+        FResult: T;
+      protected
+        function GetResult: T; override;
+        function GetDone: IMycState; override;
+      public
+        // Creates a future that executes AProc after AInitState is set, using ATaskFactory.
+        constructor Create(const ATaskFactory: IMycTaskFactory; const AInitState:
+            IMycState; AProc: TFunc<T>);
+        // Cleans up resources, primarily by unsubscribing from the initial state.
+        destructor Destroy; override;
+    end;
+
+implementation
+
+{ TMycInitStateFuncFuture<T> }
+
+constructor TMycInitStateFuncFuture<T>.Create(const ATaskFactory:
+    IMycTaskFactory; const AInitState: IMycState; AProc: TFunc<T>);
+begin
+    inherited Create;
+    Assert(Assigned(AInitState), 'AInitState must be assigned.');
+
+    FDone := TMycLatch.CreateLatch(1);
+
+    // Subscribe the job execution to AInitState.
+    // The job will run when AInitState notifies the subscriber returned by Run.
+    // AStartCount for Run is 1, meaning it waits for one Notify from AInitState's subscription.
+    FInit := AInitState.Subscribe(
+        ATaskFactory.Run(1,
+
+            procedure
+            begin
+                try
+                    try
+                        Self.FResult := AProc();
+                    except
+                        Self.FResult := Default(T); // Set result to Default(T) on error
+                        raise; // Re-raise for TaskFactory to handle
+                    end;
+                finally
+                    Self.FDone.Notify; // Signal that this future is done (successfully or with error)
+                end;
+            end
+        )
+    );
+end;
+
+destructor TMycInitStateFuncFuture<T>.Destroy;
+begin
+    Assert( FInit.State.IsSet );
+
+    // Explicitly unsubscribe from the initial state to ensure cleanup.
+    FInit.Unsubscribe;
+    inherited Destroy;
+end;
+
+function TMycInitStateFuncFuture<T>.GetDone: IMycState;
+begin
+    Result := FDone.State;
+end;
+
+function TMycInitStateFuncFuture<T>.GetResult: T;
+begin
+    if not FDone.State.IsSet then
+    begin
+        // Design decision: Caller must ensure future is done.
+        raise Exception.Create('Result is not yet available for the future.');
+    end;
+
+    // Returns FResult. If AProc failed, FResult is Default(T) and the exception
+    // was raised to be handled by the TaskFactory.
+    Result := FResult;
+end;
+
+end.

Src/Myc.Signals.pas

@@ -3,153 +3,220 @@ unit Myc.Signals;
 interface
 
 uses
-    System.SysUtils, Myc.Core.Notifier; // Assuming Myc.Core.Notifier is available
+    System.SysUtils, Myc.Core.Notifier;
 
 type
-    IMycLatch = interface; // Forward declaration for the latch interface
-
-    TMycSignal = class; // Base or related signal type
+    IMycState = interface;
 
     IMycSubscriber = interface
         // Interface for an entity that can be notified by a signal or latch.
-        // Returns true if further notifications are expected, false otherwise.
+        // Returns true if this subscriber expects further notifications from the source, false otherwise.
         function Notify: Boolean;
     end;
 
+    TMycState = class;
+
     TMycSubscription = record
     private
-        FSignal: TMycSignal; // Could also be a more general IMycSignalProvider if TMycLatch isn't a TMycSignal
-        FTag: TMycNotifyList<IMycSubscriber>.TTag;
+        FState: IMycState;
+        FTag: TMycNotifyList<IMycSubscriber>.TTag; // Tag identifying this subscription within the notifier list.
+        function GetState: IMycState;
+        constructor Create(const AState: IMycState; ATag: TMycNotifyList<IMycSubscriber>.TTag);
     public
-        class operator Initialize(out Dest: TMycSubscription);
-        class operator Finalize(var Dest: TMycSubscription);
-        class operator Assign(var Dest: TMycSubscription; const [ref] Src: TMycSubscription);
-
-        // Setup associates the subscription with a signal and a specific tag from TMycNotifyList.
-        procedure Setup(ASignal: TMycSignal; ATag: TMycNotifyList<IMycSubscriber>.TTag); inline;
-        // Unsubscribe removes this subscription from the signal it's associated with.
+        // Unsubscribes from the associated signal.
         procedure Unsubscribe;
+        property State: IMycState read GetState;
     end;
 
-    IMycSignal = interface
-        // Allows a subscriber to register for notifications.
-        // Returns a subscription record that manages the lifetime of the subscription.
-        function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
-    end;
-
-    TMycSignal = class abstract(TInterfacedObject, IMycSignal)
-    public
-        // Abstract method for subscribing to this signal.
-        function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription; virtual; abstract;
-        // Abstract method for unsubscribing using a tag.
-        procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag); virtual; abstract;
-    end;
-
-    IMycState = interface(IMycSignal)
-        // Represents a state that can be queried (IsSet) and subscribed to for changes.
+    IMycState = interface
+        // Represents a subscribable state that can be queried.
         {$region 'property access'}
         function GetIsSet: Boolean;
         {$endregion}
-        // IsSet is true if the state has been reached or the condition met.
+        // Subscribes a given subscriber to this signal.
+        function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
+        procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
+        // IsSet is true if the state has been reached or the condition is met.
         property IsSet: Boolean read GetIsSet;
     end;
 
-    // IMycLatch represents a synchronization primitive that acts like a gate.
-    // Once its internal condition is met (e.g., a count reaches zero), it becomes "set"
-    // (its IMycState.IsSet becomes true) and remains set.
-    // It can be notified (as an IMycSubscriber) to progress towards its "set" state.
-    IMycLatch = interface(IMycSubscriber)
+    TMycState = class abstract( TInterfacedObject, IMycState )
+    strict private
+    class var
+        FNull: IMycState;
+        class constructor ClassCreate;
+    protected
+        function GetIsSet: Boolean; virtual; abstract;
+    public
+        function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription; virtual; abstract;
+        procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag); virtual; abstract;
+        property IsSet: Boolean read GetIsSet;
+        // Provides access to the singleton null latch instance (always set).
+        class property Null: IMycState read FNull;
+    end;
+
+    // IMycFlag represents a base for signal-like objects that have a binary state (set/not set),
+    // can be notified (as an IMycSubscriber) to potentially change state,
+    // and whose state (IMycState) can be queried and subscribed to.
+    IMycFlag = interface(IMycSubscriber)
         {$region 'property access'}
-        // Provides access to the IMycState interface of the latch,
-        // which indicates if the latch is set and allows subscriptions to this state change.
+        // Provides access to the IMycState interface of the flag.
         function GetState: IMycState;
         {$endregion}
         property State: IMycState read GetState;
     end;
 
+    // IMycLatch is a specific type of flag that, once set, remains set (non-resettable).
+    // It typically becomes set when an internal countdown reaches zero.
+    IMycLatch = interface(IMycFlag)
+        // Inherits IMycSubscriber and State property from IMycFlag. No new members.
+    end;
+
     // TMycLatch implements a countdown latch.
     // It is initialized with a count. Calls to its Notify method (as an IMycSubscriber)
     // decrement this count. When the count reaches zero, the latch transitions to the "set"
     // state (IsSet becomes true), notifies its current subscribers once, and then remains set.
-    TMycLatch = class(TMycSignal, IMycLatch, IMycState)
+    TMycLatch = class(TMycState, IMycLatch, IMycFlag)
     strict private
         FSubscribers: TMycNotifyList<IMycSubscriber>; // List of subscribers waiting for this latch to be set.
     class var
-        FNull: IMycLatch;
-        class constructor ClassCreate;
+        FNull: IMycLatch; // Singleton instance of a latch that is always set.
+        class constructor ClassCreate; // Class constructor to initialize FNull.
     private
-        [volatile] FCount: Integer; // The internal countdown value.
-        function GetState: IMycState;
-        function GetIsSet: Boolean;
+        [volatile] FCount: Integer; // The internal countdown value for the latch.
+        function GetState: IMycState; // Implementation for IMycLatch.GetState and IMycFlag.GetState.
+    protected
+        function GetIsSet: Boolean; override; final;  // Implementation for IMycState.GetIsSet.
     public
         // Creates the latch with an initial count.
-        // If ACount is 0 or less, the latch is initially set.
+        // If ACount is 0 or less, the latch is effectively pre-set (delegates to FNull via CreateLatch factory).
         constructor Create(ACount: Integer);
         destructor Destroy; override;
 
-        // Creates a new countdown latch initialized with the given count.
+        // Factory method: creates a new countdown latch or returns the Null latch if Count <= 0.
         class function CreateLatch(Count: Integer): IMycLatch; static;
 
-        // IMycSignal implementation (from TMycSignal)
+        // IMycSignal implementation
         function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription; override;
         procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag); override;
 
         // IMycSubscriber implementation for TMycLatch itself.
         // Decrements the internal count. If the count reaches zero,
-        // registered subscribers are notified and the latch becomes permanently set.
+        // registered subscribers are notified, and the latch becomes permanently set.
         function Notify: Boolean;
 
+        // Provides access to the singleton null latch instance (always set).
         class property Null: IMycLatch read FNull;
     end;
 
+    // IMycDirty represents a resettable flag, typically indicating if a state is "dirty" (requiring attention) or "clean".
+    // It inherits from IMycFlag, meaning it has a state, can be notified, and subscribed to.
+    IMycDirty = interface(IMycFlag)
+        // Resets the flag to its "clean" (not set / not dirty) state.
+        // Returns true if the flag was actually dirty before this reset, false otherwise.
+        function Reset: Boolean;
+    end;
+
+    // TMycDirty implements a resettable "dirty flag".
+    // It can be explicitly set to dirty (via Notify) or reset to clean (via Reset).
+    // Subscribers are notified of relevant state changes.
+    TMycDirty = class(TMycState, IMycFlag, IMycDirty)
+    strict private
+        FSubscribers: TMycNotifyList<IMycSubscriber>; // List of subscribers interested in state changes of this dirty flag.
+    private
+        [volatile] FFlag: Boolean; // Internal state: true if dirty/set, false if clean/reset.
+        function GetState: IMycState; // Implementation for IMycFlag.GetState.
+    protected
+        function GetIsSet: Boolean; override; final;  // Implementation for IMycState.GetIsSet (true if dirty).
+    public
+        // Creates a new dirty flag, initially set to dirty (true).
+        constructor Create;
+        destructor Destroy; override;
+
+        // Factory method to create a new TMycDirty instance.
+        class function CreateDirty: IMycDirty; static;
+
+        // IMycSignal implementation
+        function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription; override;
+        procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag); override;
+
+        // IMycSubscriber implementation for TMycDirty.
+        // Sets this flag to dirty (true). Notifies subscribers if it transitioned from clean to dirty.
+        function Notify: Boolean;
+
+        // IMycDirty implementation. Resets the flag to clean (false).
+        function Reset: Boolean;
+    end;
+
 implementation
 
 uses
-    System.SyncObjs; // For TInterlocked if used, though it wasn't in the original TMycSemaphore.Notify directly visible
+    System.SyncObjs; // For TInterlocked
+
+type
+    // TMycNullState implements a "null object" pattern for IMycState.
+    // This state is always considered "set".
+    TMycNullState = class(TInterfacedObject, IMycState)
+    protected
+        // IMycState
+        function GetIsSet: Boolean;
+        function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
+        procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
+    public
+        constructor Create;
+    end;
+
+{ TMycNullState }
+
+constructor TMycNullState.Create;
+begin
+    inherited Create;
+end;
+
+function TMycNullState.GetIsSet: Boolean;
+begin
+    Result := true; // Null state is always set.
+end;
+
+function TMycNullState.Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
+begin
+    // Since the state is always set, notify the subscriber immediately.
+    if Assigned(Subscriber) then
+    begin
+        Subscriber.Notify;
+    end;
+    // No ongoing subscription is necessary or meaningful for a null state.
+    Result.Create(Self, nil); // Return an empty subscription.
+end;
+
+procedure TMycNullState.Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
+begin
+    // Unsubscribing from a null state has no effect.
+end;
 
 { TMycSubscription }
 
-procedure TMycSubscription.Setup(ASignal: TMycSignal; ATag: TMycNotifyList<IMycSubscriber>.TTag);
+constructor TMycSubscription.Create(const AState: IMycState; ATag:
+    TMycNotifyList<IMycSubscriber>.TTag);
 begin
-    Unsubscribe; // Ensure any previous subscription is cleared.
-    FSignal := ASignal;
+    Assert( Assigned(AState) );
+    FState := AState;
     FTag := ATag;
 end;
 
 procedure TMycSubscription.Unsubscribe;
 begin
-    if FTag <> nil then // Check if currently subscribed
+    if Assigned(FState) then
     begin
-        Assert(Assigned(FSignal), 'FSignal is not assigned during Unsubscribe');
-        FSignal.Unsubscribe(FTag);
-        FTag := nil; // Mark as unsubscribed
+        FState.Unsubscribe(FTag);
+        FTag := nil;
+        FState := nil;
     end;
 end;
 
-class operator TMycSubscription.Assign(var Dest: TMycSubscription; const [ref] Src: TMycSubscription);
+function TMycSubscription.GetState: IMycState;
 begin
-    // This default assignment might not be what's intended if Src is a temporary.
-    // Proper management would involve Dest taking ownership or Src being managed.
-    // However, if it's just copying the record fields:
-    Dest.Setup(Src.FSignal, Src.FTag);
-    // To prevent Src from unsubscribing if it's a temporary and Dest now "owns" the subscription,
-    // one might consider nil'ing out Src.FTag, but that depends on usage patterns.
-    // Given the `const [ref] Src`, this assignment implies Dest should reflect Src.
-    // If Src is finalized later, it will call Unsubscribe. This might be problematic if Dest also expects to manage it.
-    // A robust solution for record assignment with resource management often requires more careful design
-    // or using interfaces/objects for the subscription itself.
-    // For now, keeping it simple as per original structure.
-end;
-
-class operator TMycSubscription.Initialize(out Dest: TMycSubscription);
-begin
-    Dest.FSignal := nil; // Ensure FSignal is initialized
-    Dest.FTag := nil;   // Initialize tag to nil, indicating no active subscription.
-end;
-
-class operator TMycSubscription.Finalize(var Dest: TMycSubscription);
-begin
-    Dest.Unsubscribe; // Automatically unsubscribe when the record goes out of scope.
+    Result := FState;
 end;
 
 { TMycLatch }
@@ -157,29 +224,28 @@ end;
 constructor TMycLatch.Create(ACount: Integer);
 begin
     inherited Create;
-    FCount := ACount; // Set the initial countdown value.
-    FSubscribers.Create; // Initialize the list of subscribers.
+    Assert( ACount >= 0 );
+    FCount := ACount;
+    FSubscribers.Create;
 end;
 
-{ TMycLatch }
-
 class constructor TMycLatch.ClassCreate;
 begin
-    // Create1 a null latch instance that is initially (and always) set.
-    FNull := TMycLatch.Create(0);
+    // Create a singleton null latch instance that is initially (and always) set.
+    FNull := TMycLatch.Create(0); // Calls the instance constructor
 end;
 
 destructor TMycLatch.Destroy;
 begin
-    FSubscribers.Destroy; // Clean up the subscriber list.
+    FSubscribers.Destroy;
     inherited;
 end;
 
 class function TMycLatch.CreateLatch(Count: Integer): IMycLatch;
 begin
-    // Factory method to create a new TMycLatch instance.
+    // Factory method: returns a new latch or the shared Null latch if Count <= 0.
     if Count > 0 then
-        Result := TMycLatch.Create(Count)
+        Result := TMycLatch.Create(Count) // Instance constructor
     else
         Result := FNull;
 end;
@@ -189,37 +255,29 @@ var
     currentCountAfterDecrement: Integer;
     shouldNotifySubscribers: Boolean;
 begin
-    FSubscribers.Lock; // Lock to protect FCount and FSubscribers modifications/iterations
+    FSubscribers.Lock;
     try
         currentCountAfterDecrement := TInterlocked.Decrement(FCount);
 
-        // Defend against extreme underflow if Notify could be called excessively.
-        // This helps maintain a semblance of sanity for FCount, though ideally
-        // it shouldn't be needed if used as a typical countdown latch.
         if currentCountAfterDecrement < -MaxInt div 2 then
-            TInterlocked.Increment(FCount); // Try to pull it back from extreme negative.
+            TInterlocked.Increment(FCount); // Defend against extreme underflow.
 
-        // Notify subscribers only when the count transitions to zero.
-        shouldNotifySubscribers := (currentCountAfterDecrement = 0);
+        shouldNotifySubscribers := (currentCountAfterDecrement = 0); // Notify only on transition to zero.
 
         if shouldNotifySubscribers then
         begin
             FSubscribers.Notify(
                 function(Subscriber: IMycSubscriber): Boolean
                 begin
-                    // Notify each subscriber. The result of Subscriber.Notify indicates
-                    // if that subscriber expects further notifications (which, for a latch, is typically false after the first one).
                     Result := Subscriber.Notify;
                 end);
         end;
 
-        // A latch, once set (count <= 0), remains set.
-        // This Notify method itself returns true if the count is still > 0,
-        // indicating the latch has not yet been "set" by this Notify call.
+        // Returns true if the latch has not yet been set by this Notify call (count > 0).
         Result := currentCountAfterDecrement > 0;
 
-        // If the latch has become set (or was already set and Notify is called again making count more negative),
-        // unadvise all subscribers. This makes it a one-shot notification for this set of subscribers.
+        // If the latch is now set (or was already set), unadvise all subscribers.
+        // This ensures one-shot notification for the current set of subscribers.
         if currentCountAfterDecrement <= 0 then
             FSubscribers.UnadviseAll;
     finally
@@ -229,7 +287,7 @@ end;
 
 function TMycLatch.GetIsSet: Boolean;
 begin
-    // The latch is considered "set" if its count has reached zero or less.
+    // The latch is set if its count has reached zero or less.
     Result := FCount <= 0;
 end;
 
@@ -243,58 +301,157 @@ function TMycLatch.Subscribe(const Subscriber: IMycSubscriber): TMycSubscription
 var
     alreadySet: Boolean;
 begin
+    Result.Create(TMycState.Null, nil); // Default to an empty subscription.
     if not Assigned(Subscriber) then
-    begin
-        Result.Setup(nil, nil); // Return an empty/invalid subscription
         exit;
-    end;
 
-    // It's good practice to manage ref counts for interfaces passed around,
-    // especially if their lifetime is tied to the subscription.
-    // TMycNotifyList should handle AddRef/Release for stored subscribers if it holds interfaces.
-    // If direct Advise/Unadvise handles it, this explicit AddRef/Release pair might be for safety
-    // during the decision-making part of this method.
-
-    Subscriber._AddRef; // Manually increment ref count for safety during this method's logic
+    Subscriber._AddRef; // Manage ref count during this method's logic.
     try
         FSubscribers.Lock;
         try
-            // Check if the latch is already set.
-            // This uses FCount directly rather than GetIsSet to avoid re-entrancy issues if GetIsSet had complex logic.
-            alreadySet := (FCount <= 0);
+            alreadySet := (FCount <= 0); // Check if latch is already set.
 
             if alreadySet then
             begin
-                // If already set, notify the new subscriber immediately and do not add to list.
-                // The subscription will be effectively null/empty as it's a one-shot notification.
-                Result.Setup(nil, nil); // No persistent subscription needed.
-                Subscriber.Notify; // Notify immediately.
+                // If already set, notify immediately; no persistent subscription needed.
+                Subscriber.Notify;
             end
             else
             begin
-                // If not yet set, advise the subscriber to the list.
-                // The TMycSubscription record will hold the tag for later unsubscription.
-                Result.Setup(Self, FSubscribers.Advise(Subscriber));
+                // If not yet set, advise the subscriber.
+                Result.Create(Self, FSubscribers.Advise(Subscriber));
             end;
         finally
             FSubscribers.Release;
         end;
     finally
-        Subscriber._Release; // Release the ref count taken at the beginning of the method.
+        Subscriber._Release;
     end;
 end;
 
 procedure TMycLatch.Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
 begin
-    if Tag = nil then // No valid tag to unadvise.
+    if Tag = nil then
         exit;
 
     FSubscribers.Lock;
     try
-        FSubscribers.Unadvise(Tag); // Remove the subscriber associated with this tag.
+        FSubscribers.Unadvise(Tag);
     finally
         FSubscribers.Release;
     end;
 end;
 
+{ TMycDirty }
+
+constructor TMycDirty.Create;
+begin
+    inherited Create;
+    FFlag := true; // A new dirty flag is initially considered dirty.
+    FSubscribers.Create;
+end;
+
+class function TMycDirty.CreateDirty: IMycDirty;
+begin
+    // Factory method to create a new TMycDirty instance.
+    Result := TMycDirty.Create;
+end;
+
+destructor TMycDirty.Destroy;
+begin
+    FSubscribers.Destroy; // Clean up the subscriber list.
+    inherited;
+end;
+
+function TMycDirty.Reset: Boolean;
+begin
+    // Sets the flag to false (clean) and returns true if it was previously true (dirty).
+    Result := TInterlocked.Exchange(FFlag, false);
+end;
+
+function TMycDirty.GetIsSet: Boolean;
+begin
+    // IsSet is true if the flag is dirty (FFlag = true).
+    Result := FFlag;
+end;
+
+function TMycDirty.GetState: IMycState;
+begin
+    // TMycDirty itself implements IMycState.
+    exit(Self);
+end;
+
+function TMycDirty.Notify: Boolean;
+var
+    wasPreviouslyClean: Boolean;
+begin
+    FSubscribers.Lock;
+    try
+        // Set the flag to true (dirty) and check if it was previously false (clean).
+        wasPreviouslyClean := not TInterlocked.Exchange(FFlag, true);
+
+        if wasPreviouslyClean then // Only notify subscribers if state changed from clean to dirty.
+        begin
+            FSubscribers.Notify(
+                function(Subscriber: IMycSubscriber): Boolean
+                begin
+                    Result := Subscriber.Notify;
+                end);
+        end;
+        // The return value of this Notify (as an IMycSubscriber) indicates if this
+        // TMycDirty instance itself would want more notifications if it were subscribed to something.
+        // Here, it reflects whether a state change to dirty occurred due to this call.
+        Result := wasPreviouslyClean;
+    finally
+        FSubscribers.Release;
+    end;
+end;
+
+function TMycDirty.Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
+begin
+    Result.Create(TMycState.Null, nil); // Default to an empty subscription
+    if not Assigned(Subscriber) then
+        exit;
+
+    // For TMycDirty, we always add the subscriber and then check if we need to notify immediately.
+    // Ref counting for the subscriber interface is assumed to be handled by TMycNotifyList.Advise/Unadvise.
+    // Or, if explicit management is needed like in TMycLatch, it should be added.
+    // For consistency with TMycLatch, let's add AddRef/Release here too.
+    Subscriber._AddRef;
+    try
+        FSubscribers.Lock;
+        try
+            // Add subscriber regardless of current state.
+            Result.Create(Self, FSubscribers.Advise(Subscriber));
+            if FFlag then // If currently dirty, notify the new subscriber immediately.
+            begin
+                Subscriber.Notify;
+            end;
+        finally
+            FSubscribers.Release;
+        end;
+    finally
+        Subscriber._Release;
+    end;
+end;
+
+procedure TMycDirty.Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
+begin
+    if Tag = nil then
+        exit;
+
+    FSubscribers.Lock;
+    try
+        FSubscribers.Unadvise(Tag);
+    finally
+        FSubscribers.Release;
+    end;
+end;
+
+class constructor TMycState.ClassCreate;
+begin
+    // Create a singleton null latch instance that is initially (and always) set.
+    FNull := TMycNullState.Create(); // Calls the instance constructor
+end;
+
 end.

Test/MycTests.dpr

@@ -12,7 +12,6 @@ uses
   TestInsight.DUnitX,
   {$ELSE}
   DUnitX.Loggers.Console,
-  DUnitX.Loggers.Xml.NUnit,
   {$ENDIF }
   DUnitX.TestFramework,
   TestNotifier in 'TestNotifier.pas',
@@ -22,7 +21,10 @@ uses
   TestNotifier_ChaosStress in 'TestNotifier_ChaosStress.pas',
   TestSignals_Latch in 'TestSignals_Latch.pas',
   Myc.Core.Tasks in '..\Src\Myc.Core.Tasks.pas',
-  TestTasks in 'TestTasks.pas';
+  TestTasks in 'TestTasks.pas',
+  TestSignals_Dirty in 'TestSignals_Dirty.pas',
+  Myc.Futures in '..\Src\Myc.Futures.pas',
+  TestFutures in 'TestFutures.pas';
 
 { keep comment here to protect the following conditional from being removed by the IDE when adding a unit }
 {$IFNDEF TESTINSIGHT}

Test/MycTests.dproj

@@ -63,6 +63,10 @@
         <VerInfo_Locale>1031</VerInfo_Locale>
         <VerInfo_Keys>CompanyName=;FileDescription=$(MSBuildProjectName);FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProgramID=com.embarcadero.$(MSBuildProjectName);ProductName=$(MSBuildProjectName);ProductVersion=1.0.0.0;Comments=</VerInfo_Keys>
         <Debugger_RunParams>--exitbehavior:Pause</Debugger_RunParams>
+        <DCC_Define>TESTINSIGHT;$(DCC_Define)</DCC_Define>
+        <PostBuildEvent><![CDATA[T:\DelphiIntfExtract\Win64\Debug\ExtractPascalInterfaces.exe -o T:\Myc\intf.txt T:\Myc\src
+$(PostBuildEvent)]]></PostBuildEvent>
+        <PostBuildEventExecuteWhen>TargetOutOfDate</PostBuildEventExecuteWhen>
     </PropertyGroup>
     <PropertyGroup Condition="'$(Base_Win32)'!=''">
         <DCC_UsePackage>vclwinx;fmx;vclie;DbxCommonDriver;bindengine;IndyIPCommon;VCLRESTComponents;FireDACCommonODBC;FireDACCommonDriver;IndyProtocols;vclx;Skia.Package.RTL;IndyIPClient;dbxcds;vcledge;bindcompvclwinx;FmxTeeUI;bindcompfmx;inetdb;FireDACSqliteDriver;DbxClientDriver;Tee;soapmidas;vclactnband;TeeUI;fmxFireDAC;dbexpress;DBXMySQLDriver;VclSmp;inet;vcltouch;fmxase;dbrtl;Skia.Package.FMX;fmxdae;TeeDB;FireDACMSAccDriver;CustomIPTransport;vcldsnap;DBXInterBaseDriver;IndySystem;Skia.Package.VCL;vcldb;vclFireDAC;bindcomp;FireDACCommon;inetstn;IndyCore;RESTBackendComponents;bindcompdbx;rtl;FireDACMySQLDriver;FireDACADSDriver;RESTComponents;DBXSqliteDriver;vcl;IndyIPServer;dsnapxml;dsnapcon;adortl;vclimg;FireDACPgDriver;FireDAC;inetdbxpress;xmlrtl;tethering;bindcompvcl;dsnap;CloudService;fmxobj;bindcompvclsmp;FMXTee;soaprtl;soapserver;FireDACIBDriver;$(DCC_UsePackage)</DCC_UsePackage>
@@ -117,6 +121,9 @@
         <DCCReference Include="TestSignals_Latch.pas"/>
         <DCCReference Include="..\Src\Myc.Core.Tasks.pas"/>
         <DCCReference Include="TestTasks.pas"/>
+        <DCCReference Include="TestSignals_Dirty.pas"/>
+        <DCCReference Include="..\Src\Myc.Futures.pas"/>
+        <DCCReference Include="TestFutures.pas"/>
         <BuildConfiguration Include="Base">
             <Key>Base</Key>
         </BuildConfiguration>
@@ -1128,4 +1135,36 @@
     <Import Project="$(BDS)\Bin\CodeGear.Delphi.Targets" Condition="Exists('$(BDS)\Bin\CodeGear.Delphi.Targets')"/>
     <Import Project="$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj" Condition="Exists('$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj')"/>
     <Import Project="$(MSBuildProjectName).deployproj" Condition="Exists('$(MSBuildProjectName).deployproj')"/>
+    <PropertyGroup Condition="'$(Config)'=='Debug' And '$(Platform)'=='Win32'">
+        <PreBuildEvent/>
+        <PreBuildEventIgnoreExitCode>False</PreBuildEventIgnoreExitCode>
+        <PreLinkEvent/>
+        <PreLinkEventIgnoreExitCode>False</PreLinkEventIgnoreExitCode>
+        <PostBuildEvent>T:\DelphiIntfExtract\Win64\Debug\ExtractPascalInterfaces.exe -o T:\Myc\intf.txt T:\Myc\src</PostBuildEvent>
+        <PostBuildEventIgnoreExitCode>False</PostBuildEventIgnoreExitCode>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Debug' And '$(Platform)'=='Win64'">
+        <PreBuildEvent/>
+        <PreBuildEventIgnoreExitCode>False</PreBuildEventIgnoreExitCode>
+        <PreLinkEvent/>
+        <PreLinkEventIgnoreExitCode>False</PreLinkEventIgnoreExitCode>
+        <PostBuildEvent>T:\DelphiIntfExtract\Win64\Debug\ExtractPascalInterfaces.exe -o T:\Myc\intf.txt T:\Myc\src</PostBuildEvent>
+        <PostBuildEventIgnoreExitCode>False</PostBuildEventIgnoreExitCode>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Release' And '$(Platform)'=='Win32'">
+        <PreBuildEvent/>
+        <PreBuildEventIgnoreExitCode>False</PreBuildEventIgnoreExitCode>
+        <PreLinkEvent/>
+        <PreLinkEventIgnoreExitCode>False</PreLinkEventIgnoreExitCode>
+        <PostBuildEvent>T:\DelphiIntfExtract\Win64\Debug\ExtractPascalInterfaces.exe -o T:\Myc\intf.txt T:\Myc\src</PostBuildEvent>
+        <PostBuildEventIgnoreExitCode>False</PostBuildEventIgnoreExitCode>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Release' And '$(Platform)'=='Win64'">
+        <PreBuildEvent/>
+        <PreBuildEventIgnoreExitCode>False</PreBuildEventIgnoreExitCode>
+        <PreLinkEvent/>
+        <PreLinkEventIgnoreExitCode>False</PreLinkEventIgnoreExitCode>
+        <PostBuildEvent>T:\DelphiIntfExtract\Win64\Debug\ExtractPascalInterfaces.exe -o T:\Myc\intf.txt T:\Myc\src</PostBuildEvent>
+        <PostBuildEventIgnoreExitCode>False</PostBuildEventIgnoreExitCode>
+    </PropertyGroup>
 </Project>

Test/TestFutures.pas

@@ -0,0 +1,370 @@
+unit TestFutures;
+
+interface
+
+uses
+  DUnitX.TestFramework,
+  System.SysUtils, System.Generics.Collections, // Added for TObjectList if needed, not strictly for this
+  System.SyncObjs,
+  Myc.Signals,    // For IMycLatch, TMycLatch, IMycState, IMycSubscriber [cite: 62, 68, 53, 45]
+  Myc.Core.Tasks, // For IMycTaskFactory, TMycTaskFactory [cite: 97, 113]
+  Myc.Futures;    // For IMycFuture, TMycInitStateFuncFuture
+
+type
+  // Helper class to notify a latch when its Notify method is called.
+  TLatchNotifierSubscriber = class(TInterfacedObject, IMycSubscriber)
+  private
+    FGateLatch: IMycLatch;
+  public
+    constructor Create(AGateLatch: IMycLatch);
+    // IMycSubscriber
+    function Notify: Boolean; // Implements IMycSubscriber.Notify [cite: 46, 181, 299]
+  end;
+
+  [TestFixture]
+  [IgnoreMemoryLeaks(true)]
+  TTestMycInitStateFuncFuture = class(TObject)
+  private
+    FTaskFactory: IMycTaskFactory;
+    FProcExecutionCount: Integer; // Counter for side effects of AProc
+    FSharedCounter: Integer; // For Fan-Out test side effects
+  public
+    [Setup]
+    procedure Setup;
+    [TearDown]
+    procedure TearDown;
+
+    [Test]
+    procedure Test_BasicSuccess_WithImmediateInitState;
+    [Test]
+    procedure Test_ChainedExecution_WithDelayedInitState;
+    [Test]
+    procedure Test_ExceptionInProc_HandledAsPlanned;
+    [Test]
+    procedure Test_GetResult_BeforeDone_RaisesException;
+    [Test]
+    procedure Test_FanIn_OneFutureWaitsForMultipleOthers;
+    [Test]
+    procedure Test_FanOut_MultipleFuturesWaitForOneTrigger;
+  end;
+
+implementation
+
+{ TLatchNotifierSubscriber }
+
+constructor TLatchNotifierSubscriber.Create(AGateLatch: IMycLatch);
+begin
+  inherited Create;
+  FGateLatch := AGateLatch;
+end;
+
+function TLatchNotifierSubscriber.Notify: Boolean;
+begin
+  if Assigned(FGateLatch) then
+  begin
+    FGateLatch.Notify; // Notify the provided gate latch [cite: 80, 215, 333]
+  end;
+  Result := False; // This subscriber is typically one-shot for this purpose.
+end;
+
+{ TTestMycInitStateFuncFuture }
+
+procedure TTestMycInitStateFuncFuture.Setup;
+begin
+  FTaskFactory := TMycTaskFactory.Create; // Create a new task factory instance for each test [cite: 113, 235, 353]
+  FProcExecutionCount := 0;
+  FSharedCounter := 0;
+end;
+
+procedure TTestMycInitStateFuncFuture.TearDown;
+begin
+  if Assigned(FTaskFactory) then
+  begin
+    FTaskFactory.Teardown; // Teardown the factory, this may re-raise exceptions [cite: 107, 234, 352]
+    FTaskFactory := nil;
+  end;
+end;
+
+procedure TTestMycInitStateFuncFuture.Test_BasicSuccess_WithImmediateInitState;
+var
+  LFuture: IMycFuture<Integer>;
+  LInitStateAsState: IMycState; // Parameter for Create
+  LResultValue: Integer;
+const
+  CExpectedResult = 42;
+begin
+  // Use TMycLatch.Null for an already set init state [cite: 71, 81, 206, 216, 324, 334]
+  LInitStateAsState := TMycLatch.Null.State; // Get IMycState from IMycLatch [cite: 61, 196, 314]
+
+  LFuture := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LInitStateAsState,
+    function: Integer
+    begin
+      Inc(Self.FProcExecutionCount);
+      Result := CExpectedResult;
+    end);
+
+  FTaskFactory.WaitFor(LFuture.Done); // Accesses IMycFuture.GetDone [cite: 110, 234, 352]
+
+  Assert.IsTrue(LFuture.Done.IsSet, 'Future should be marked as done.'); // Accesses IMycState.IsSet [cite: 57, 194, 312]
+  Assert.AreEqual(1, FProcExecutionCount, 'AProc should have been executed once.');
+
+  LResultValue := LFuture.GetResult; // Accesses IMycFuture.GetResult
+  Assert.AreEqual(CExpectedResult, LResultValue, 'GetResult returned an unexpected value.');
+end;
+
+procedure TTestMycInitStateFuncFuture.Test_ChainedExecution_WithDelayedInitState;
+var
+  LFuture: IMycFuture<string>;
+  LInitLatch: IMycLatch;
+  LResultValue: string;
+const
+  CExpectedResult = 'ChainCompleted';
+begin
+  LInitLatch := TMycLatch.CreateLatch(1); // Create an init state that is not yet set [cite: 77, 212, 330]
+
+  LFuture := TMycInitStateFuncFuture<string>.Create(FTaskFactory, LInitLatch.State,
+    function: string
+    begin
+      Inc(Self.FProcExecutionCount);
+      Result := CExpectedResult;
+    end);
+
+  Assert.AreEqual(0, FProcExecutionCount, 'AProc should not have executed yet.');
+  Assert.IsFalse(LFuture.Done.IsSet, 'Future should not be done yet.');
+
+  LInitLatch.Notify; // Trigger the initial state [cite: 80, 215, 333]
+
+  FTaskFactory.WaitFor(LFuture.Done);
+
+  Assert.IsTrue(LFuture.Done.IsSet, 'Future should be marked as done after init state trigger.');
+  Assert.AreEqual(1, FProcExecutionCount, 'AProc should have been executed once after init state.');
+
+  LResultValue := LFuture.GetResult;
+  Assert.AreEqual(CExpectedResult, LResultValue, 'GetResult returned an unexpected value after delayed init.');
+end;
+
+procedure TTestMycInitStateFuncFuture.Test_ExceptionInProc_HandledAsPlanned;
+var
+  LFuture: IMycFuture<Integer>;
+  LLocalTaskFactory: IMycTaskFactory;
+  LInitStateAsState: IMycState;
+  LResultValue: Integer;
+  LExpectedExceptionRaisedByFactory: Boolean;
+const
+  CExceptionMessage = 'Test exception from AProc';
+begin
+  LExpectedExceptionRaisedByFactory := False;
+  LLocalTaskFactory := TMycTaskFactory.Create;
+  LInitStateAsState := TMycLatch.Null.State; // Immediate execution
+
+  LFuture := TMycInitStateFuncFuture<Integer>.Create(LLocalTaskFactory, LInitStateAsState,
+    function: Integer
+    begin
+      Inc(Self.FProcExecutionCount);
+      raise Exception.Create(CExceptionMessage);
+    end);
+
+  try
+    LLocalTaskFactory.WaitFor(LFuture.Done);
+  except
+    on E: Exception do
+    begin
+      if E.Message = CExceptionMessage then
+        LExpectedExceptionRaisedByFactory := True;
+    end;
+  end;
+
+  Assert.IsTrue(LFuture.Done.IsSet, 'Future should be done even if AProc raised an exception.');
+  Assert.AreEqual(1, FProcExecutionCount, 'AProc (which raised) should have been executed once.');
+
+  LResultValue := LFuture.GetResult;
+  Assert.AreEqual(Default(Integer), LResultValue, 'GetResult should return Default(T) when AProc raises an exception.');
+
+  if not LExpectedExceptionRaisedByFactory then
+  begin
+    try
+      LLocalTaskFactory.Teardown; // This should re-raise the exception [cite: 108, 234, 352]
+    except
+      on E: Exception do
+      begin
+        Assert.AreEqual(CExceptionMessage, E.Message, 'TaskFactory did not re-raise the correct exception message on Teardown.');
+        LExpectedExceptionRaisedByFactory := True;
+      end;
+    end;
+    Assert.IsTrue(LExpectedExceptionRaisedByFactory, 'TaskFactory Teardown did not raise any exception as expected.');
+  end;
+
+  if LExpectedExceptionRaisedByFactory then // Factory was torn down (implicitly or explicitly) and did its job
+      LLocalTaskFactory := nil
+  else if Assigned(LLocalTaskFactory) then // Teardown didn't raise as expected, or wasn't called due to earlier exception path
+  begin
+      LLocalTaskFactory.Teardown; // Ensure it's torn down if test logic failed to confirm exception
+      LLocalTaskFactory := nil;
+  end;
+end;
+
+procedure TTestMycInitStateFuncFuture.Test_GetResult_BeforeDone_RaisesException;
+var
+  LFuture: IMycFuture<Integer>;
+  LInitLatch: IMycLatch;
+  LExpectedExceptionRaised: Boolean;
+const
+  CExpectedExceptionMessage = 'Result is not yet available for the future.';
+begin
+  LExpectedExceptionRaised := False;
+  LInitLatch := TMycLatch.CreateLatch(1); // Create a latch that is not yet set [cite: 77, 212, 330]
+
+  LFuture := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LInitLatch.State,
+    function: Integer
+    begin
+      Inc(Self.FProcExecutionCount);
+      Result := 123;
+    end);
+
+  Assert.IsFalse(LFuture.Done.IsSet, 'Future should not be marked as done initially.');
+
+  try
+    LFuture.GetResult;
+  except
+    on E: Exception do
+    begin
+      Assert.AreEqual(CExpectedExceptionMessage, E.Message, 'Exception message mismatch.');
+      LExpectedExceptionRaised := True;
+    end;
+  end;
+  Assert.IsTrue(LExpectedExceptionRaised, 'Calling GetResult before done should raise an exception.');
+
+  LInitLatch.Notify; // [cite: 80, 215, 333]
+  FTaskFactory.WaitFor(LFuture.Done); //
+end;
+
+procedure TTestMycInitStateFuncFuture.Test_FanIn_OneFutureWaitsForMultipleOthers;
+var
+  LPrerequisiteFuture1, LPrerequisiteFuture2: IMycFuture<Integer>;
+  LMainFuture: IMycFuture<string>;
+  LGateLatch: IMycLatch;
+  LSub1, LSub2: IMycSubscriber; // To hold the TLatchNotifierSubscriber instances
+  LInitStateP1, LInitStateP2: IMycLatch;
+  Subscriptions: array[1..2] of TMycSubscription; // To manage subscriptions
+const
+  CMainFutureResult = 'AllPrerequisitesCompleted';
+begin
+  FProcExecutionCount := 0; // Reset for this test
+
+  // Gate Latch: MainFuture waits for this latch, which needs 2 notifications.
+  LGateLatch := TMycLatch.CreateLatch(2); // [cite: 77, 212, 330]
+
+  // Create MainFuture, AInitState is the GateLatch's state.
+  LMainFuture := TMycInitStateFuncFuture<string>.Create(FTaskFactory, LGateLatch.State,
+    function: string
+    begin
+      Inc(Self.FProcExecutionCount, 10); // Indicate MainFuture's proc ran
+      Result := CMainFutureResult;
+    end);
+
+  // Setup Prerequisite Futures
+  // PrerequisiteFuture1
+  LInitStateP1 := TMycLatch.CreateLatch(1); // Controllable init state for PF1
+  LPrerequisiteFuture1 := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LInitStateP1.State,
+    function: Integer
+    begin
+      Inc(Self.FProcExecutionCount, 1); // PF1 ran
+      Result := 1;
+    end);
+  LSub1 := TLatchNotifierSubscriber.Create(LGateLatch);
+  Subscriptions[1] := LPrerequisiteFuture1.Done.Subscribe(LSub1); // Subscribe to PF1's completion [cite: 56, 188, 306]
+
+  // PrerequisiteFuture2
+  LInitStateP2 := TMycLatch.CreateLatch(1); // Controllable init state for PF2
+  LPrerequisiteFuture2 := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LInitStateP2.State,
+    function: Integer
+    begin
+      Inc(Self.FProcExecutionCount, 1); // PF2 ran
+      Result := 2;
+    end);
+  LSub2 := TLatchNotifierSubscriber.Create(LGateLatch);
+  Subscriptions[2] := LPrerequisiteFuture2.Done.Subscribe(LSub2); // Subscribe to PF2's completion
+
+  // --- Execution & Verification ---
+  Assert.IsFalse(LMainFuture.Done.IsSet, 'MainFuture should not be done yet.');
+  Assert.AreEqual(0, FProcExecutionCount, 'No AProc should have executed yet.');
+
+  // Trigger PrerequisiteFuture1
+  LInitStateP1.Notify; //
+  FTaskFactory.WaitFor(LPrerequisiteFuture1.Done); // Ensure PF1 completes and notifies GateLatch
+  Assert.IsFalse(LGateLatch.State.IsSet, 'GateLatch should not be set after only one prerequisite.');
+  Assert.IsFalse(LMainFuture.Done.IsSet, 'MainFuture should still not be done.');
+  Assert.AreEqual(1, FProcExecutionCount mod 10, 'Only PF1 AProc should have run.');
+
+
+  // Trigger PrerequisiteFuture2
+  LInitStateP2.Notify; //
+  FTaskFactory.WaitFor(LPrerequisiteFuture2.Done); // Ensure PF2 completes and notifies GateLatch
+
+  // Now GateLatch should be set, and MainFuture should execute
+  FTaskFactory.WaitFor(LMainFuture.Done);
+
+  Assert.IsTrue(LGateLatch.State.IsSet, 'GateLatch should be set after both prerequisites.');
+  Assert.IsTrue(LMainFuture.Done.IsSet, 'MainFuture should be done now.');
+  Assert.AreEqual(12, FProcExecutionCount, 'All AProcs (PF1, PF2, Main) should have run.'); // 1+1+10
+  Assert.AreEqual(CMainFutureResult, LMainFuture.GetResult, 'MainFuture returned an unexpected result.');
+
+  // Clean up subscriptions explicitly, though ARC + managed records handle much
+  Subscriptions[1].Unsubscribe; // [cite: 52, 186, 304]
+  Subscriptions[2].Unsubscribe; //
+end;
+
+procedure TTestMycInitStateFuncFuture.Test_FanOut_MultipleFuturesWaitForOneTrigger;
+var
+  LTriggerLatch: IMycLatch;
+  LFutureA, LFutureB: IMycFuture<Integer>;
+  LFlagFutureARan, LFlagFutureBRan: Boolean;
+begin
+  LFlagFutureARan := False;
+  LFlagFutureBRan := False;
+  Self.FSharedCounter := 0; // Reset shared counter for this test
+
+  LTriggerLatch := TMycLatch.CreateLatch(1); // Single trigger [cite: 77, 212, 330]
+
+  // Future A
+  LFutureA := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LTriggerLatch.State,
+    function: Integer
+    begin
+      LFlagFutureARan := True;
+      System.SyncObjs.TInterlocked.Increment(Self.FSharedCounter); // Thread-safe increment
+      Result := 100;
+    end);
+
+  // Future B
+  LFutureB := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LTriggerLatch.State,
+    function: Integer
+    begin
+      LFlagFutureBRan := True;
+      System.SyncObjs.TInterlocked.Increment(Self.FSharedCounter); // Thread-safe increment
+      Result := 200;
+    end);
+
+  Assert.IsFalse(LFutureA.Done.IsSet, 'FutureA should not be done yet.');
+  Assert.IsFalse(LFutureB.Done.IsSet, 'FutureB should not be done yet.');
+  Assert.AreEqual(0, Self.FSharedCounter, 'No future AProcs should have executed yet.');
+
+  // Trigger the common latch
+  LTriggerLatch.Notify; // [cite: 80, 215, 333]
+
+  // Wait for both futures to complete
+  FTaskFactory.WaitFor(LFutureA.Done);
+  FTaskFactory.WaitFor(LFutureB.Done);
+
+  Assert.IsTrue(LFutureA.Done.IsSet, 'FutureA should be done.');
+  Assert.IsTrue(LFutureB.Done.IsSet, 'FutureB should be done.');
+  Assert.IsTrue(LFlagFutureARan, 'FutureA AProc should have run.');
+  Assert.IsTrue(LFlagFutureBRan, 'FutureB AProc should have run.');
+  Assert.AreEqual(2, Self.FSharedCounter, 'Both future AProcs should have incremented the counter.');
+  Assert.AreEqual(100, LFutureA.GetResult, 'FutureA GetResult value mismatch.');
+  Assert.AreEqual(200, LFutureB.GetResult, 'FutureB GetResult value mismatch.');
+end;
+
+initialization
+  // For DUnitX, attributes typically handle registration.
+  // If needed for older DUnit: RegisterTest(TTestMycInitStateFuncFuture.Suite);
+end.

Test/TestNotifier_ChaosStress.pas

@@ -313,7 +313,6 @@ var
     threads: array of TStressWorkerThread;
     i: Integer;
     LThreadError: Exception;
-    LMessage: string;
     totalExpectedLiveByThreadsAtEnd, actualLiveInNotifierAtEnd: Integer;
     actualLiveReceiversInNotifier: TList<IMyStressTestInterface>; // Store interface type from Notify
     receiver: IMyStressTestInterface;

Test/TestNotifier_Threading.pas

@@ -116,7 +116,6 @@ end;
 procedure TAdviseWorkerThread.Execute;
 var
     i: Integer;
-    tag: TMycNotifyList<IMyTestInterface>.TTag; // Tag is not used further in this test design
 begin
     inherited; // Important for TThread
     try
@@ -128,7 +127,7 @@ begin
             // Acquire lock before calling Advise
             FOwnerFixture.FNotifier.Lock;
             try
-                tag := FOwnerFixture.FNotifier.Advise(FReceiversToAdd[i]);
+                var tag := FOwnerFixture.FNotifier.Advise(FReceiversToAdd[i]);
                 // The 'tag' could be used here if necessary for other test scenarios
             finally
                 // Definitely release lock in the finally block

Test/TestSList.pas

@@ -51,7 +51,6 @@ type
 
     // --- TSList Parallel Access Test ---
     [Test]
-    [Timeout(30000)] // Timeout in milliseconds
     procedure TestTSList_ParallelPushPop;
   end;
 

Test/TestSignals_Dirty.pas

@@ -0,0 +1,529 @@
+unit TestSignals_Dirty;
+
+interface
+
+uses
+  DUnitX.TestFramework,
+  System.SysUtils,
+  Myc.Signals; // Unit under test
+
+type
+  // Helper class to mock a subscriber (reuse or redefine if not in common unit)
+  TMockSubscriber = class(TInterfacedObject, IMycSubscriber)
+  public
+    NotifyCount: Integer;
+    NotifyShouldReturn: Boolean;
+    WasCalled: Boolean;
+    LastReturnedValueFromSource: Boolean; // To store what the source's Notify returned
+
+    constructor Create(AShouldReturn: Boolean = True);
+    function Notify: Boolean; // IMycSubscriber implementation.
+  end;
+
+  [TestFixture]
+  TTestMycDirtyFlag = class(TObject)
+  private
+    // Helper to create a dirty flag and optionally reset it for a clean initial state
+    function CreateAndPrepareDirtyFlag(StartDirty: Boolean = True): IMycDirty;
+  public
+    [Setup]
+    procedure Setup;
+    [TearDown]
+    procedure TearDown;
+
+    // Category 1: Basic State, Notify (as Subscriber method), and Reset
+    [Test]
+    procedure TestCreate_InitialStateIsDirty;
+    [Test]
+    procedure TestReset_FromDirtyState_BecomesCleanAndReturnsTrue;
+    [Test]
+    procedure TestReset_FromCleanState_StaysCleanAndReturnsFalse;
+    [Test]
+    procedure TestNotify_OnCleanFlag_SetsDirtyAndReturnsTrue;
+    [Test]
+    procedure TestNotify_OnDirtyFlag_StaysDirtyAndReturnsFalse;
+
+    // Category 2: Subscriber Notifications
+    [Test]
+    procedure TestSubscribe_ToAlreadyDirtyFlag_NotifiesSubscriberImmediately;
+    [Test]
+    procedure TestSubscribe_ToCleanFlag_DoesNotNotifySubscriberImmediately;
+    [Test]
+    procedure TestSubscriber_Notified_WhenFlagTransitionsToDirty;
+    [Test]
+    procedure TestSubscriber_NotNotified_WhenSettingAlreadyDirtyFlagViaNotify;
+    [Test]
+    procedure TestSubscriber_NotNotified_ByResetAction;
+    [Test]
+    procedure TestMultipleSubscribers_Notified_WhenFlagTransitionsToDirty;
+    [Test]
+    procedure TestUnsubscribe_SubscriberNotNotified;
+
+    // Category 3: Chaining Dirty Flags
+    [Test]
+    procedure TestChain_A_Notifies_B_SimplePropagation;
+    [Test]
+    procedure TestChain_A_Notifies_B_Notifies_C_SimplePropagation;
+
+    // Category 4: Chaining with Resets and Re-triggering (Consistency)
+    [Test]
+    procedure TestChain_A_B_ResetB_RetriggerA_BStaysCleanIfANotChanged;
+    [Test]
+    procedure TestChain_A_B_ResetA_ThenTriggerA_FullPropagationToB;
+    [Test]
+    procedure TestChain_A_B_C_IntermediateBReset_RetriggerA_PropagatesToC;
+    [Test]
+    procedure TestChain_A_B_C_AllReset_RetriggerA_FullPropagation;
+    [Test]
+    procedure TestChain_A_B_C_TriggerA_ResetA_TriggerA_EnsureCNotifiedCorrectly;
+
+  end;
+
+implementation
+
+{ TMockSubscriber }
+
+constructor TMockSubscriber.Create(AShouldReturn: Boolean = True);
+begin
+  inherited Create;
+  NotifyCount := 0;
+  NotifyShouldReturn := AShouldReturn;
+  WasCalled := False;
+  LastReturnedValueFromSource := False; // Default
+end;
+
+function TMockSubscriber.Notify: Boolean;
+begin
+  Inc(NotifyCount);
+  WasCalled := True;
+  // This return value is what this subscriber tells the source signal.
+  // For testing, we usually want it to return false to signify it doesn't need more from this one event.
+  Result := NotifyShouldReturn;
+end;
+
+{ TTestMycDirtyFlag }
+
+function TTestMycDirtyFlag.CreateAndPrepareDirtyFlag(StartDirty: Boolean = True): IMycDirty;
+begin
+  Result := TMycDirty.CreateDirty; // Initially dirty
+  if not StartDirty then
+    Result.Reset; // Reset to make it clean
+  Assert.AreEqual(StartDirty, Result.State.IsSet, 'CreateAndPrepareDirtyFlag initial state incorrect.');
+end;
+
+procedure TTestMycDirtyFlag.Setup;
+begin
+  // Per-test setup
+end;
+
+procedure TTestMycDirtyFlag.TearDown;
+begin
+  // Per-test teardown
+end;
+
+// Category 1: Basic State, Notify (as Subscriber method), and Reset
+
+procedure TTestMycDirtyFlag.TestCreate_InitialStateIsDirty;
+var
+  dirtyFlag: IMycDirty;
+begin
+  dirtyFlag := TMycDirty.CreateDirty;
+  Assert.IsTrue(dirtyFlag.State.IsSet, 'Newly created dirty flag should be IsSet (dirty).');
+end;
+
+procedure TTestMycDirtyFlag.TestReset_FromDirtyState_BecomesCleanAndReturnsTrue;
+var
+  dirtyFlag: IMycDirty;
+  resetResult: Boolean;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(True); // Start dirty
+
+  resetResult := dirtyFlag.Reset;
+
+  Assert.IsFalse(dirtyFlag.State.IsSet, 'Flag should be clean (not IsSet) after Reset.');
+  Assert.IsTrue(resetResult, 'Reset() should return True when resetting a dirty flag.');
+end;
+
+procedure TTestMycDirtyFlag.TestReset_FromCleanState_StaysCleanAndReturnsFalse;
+var
+  dirtyFlag: IMycDirty;
+  resetResult: Boolean;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(False); // Start clean
+
+  resetResult := dirtyFlag.Reset;
+
+  Assert.IsFalse(dirtyFlag.State.IsSet, 'Flag should remain clean (not IsSet) after Reset on clean flag.');
+  Assert.IsFalse(resetResult, 'Reset() should return False when resetting an already clean flag.');
+end;
+
+procedure TTestMycDirtyFlag.TestNotify_OnCleanFlag_SetsDirtyAndReturnsTrue;
+var
+  dirtyFlag: IMycDirty;
+  notifyResult: Boolean;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(False); // Start clean
+
+  notifyResult := dirtyFlag.Notify; // Call IMycSubscriber.Notify to make it dirty
+
+  Assert.IsTrue(dirtyFlag.State.IsSet, 'Flag should be dirty (IsSet) after Notify on clean flag.');
+  Assert.IsTrue(notifyResult, 'Notify() should return True indicating a state change from clean to dirty.');
+end;
+
+procedure TTestMycDirtyFlag.TestNotify_OnDirtyFlag_StaysDirtyAndReturnsFalse;
+var
+  dirtyFlag: IMycDirty;
+  notifyResult: Boolean;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(True); // Start dirty
+
+  notifyResult := dirtyFlag.Notify; // Call IMycSubscriber.Notify again
+
+  Assert.IsTrue(dirtyFlag.State.IsSet, 'Flag should remain dirty (IsSet).');
+  Assert.IsFalse(notifyResult, 'Notify() should return False as flag was already dirty (no state change to dirty).');
+end;
+
+// Category 2: Subscriber Notifications
+
+procedure TTestMycDirtyFlag.TestSubscribe_ToAlreadyDirtyFlag_NotifiesSubscriberImmediately;
+var
+  dirtyFlag: IMycDirty;
+  subscriber: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(True); // Start dirty
+  subscriber := TMockSubscriber.Create;
+
+  subscription := dirtyFlag.State.Subscribe(subscriber);
+
+  Assert.AreEqual(1, subscriber.NotifyCount, 'Subscriber should be notified immediately when subscribing to an already dirty flag.');
+  Assert.IsTrue(subscriber.WasCalled, 'Subscriber WasCalled should be true.');
+end;
+
+procedure TTestMycDirtyFlag.TestSubscribe_ToCleanFlag_DoesNotNotifySubscriberImmediately;
+var
+  dirtyFlag: IMycDirty;
+  subscriber: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(False); // Start clean
+  subscriber := TMockSubscriber.Create;
+
+  subscription := dirtyFlag.State.Subscribe(subscriber);
+
+  Assert.AreEqual(0, subscriber.NotifyCount, 'Subscriber should NOT be notified immediately when subscribing to a clean flag.');
+  Assert.IsFalse(subscriber.WasCalled, 'Subscriber WasCalled should be false.');
+end;
+
+procedure TTestMycDirtyFlag.TestSubscriber_Notified_WhenFlagTransitionsToDirty;
+var
+  dirtyFlag: IMycDirty;
+  subscriber: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(False); // Start clean
+  subscriber := TMockSubscriber.Create;
+  subscription := dirtyFlag.State.Subscribe(subscriber);
+
+  Assert.AreEqual(0, subscriber.NotifyCount, 'Subscriber initially not notified.');
+
+  dirtyFlag.Notify; // Make the flag dirty
+
+  Assert.AreEqual(1, subscriber.NotifyCount, 'Subscriber should be notified once flag transitions to dirty.');
+end;
+
+procedure TTestMycDirtyFlag.TestSubscriber_NotNotified_WhenSettingAlreadyDirtyFlagViaNotify;
+var
+  dirtyFlag: IMycDirty;
+  subscriber: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(True); // Start dirty
+  subscriber := TMockSubscriber.Create;
+  subscription := dirtyFlag.State.Subscribe(subscriber); // Gets initial notification
+
+  Assert.AreEqual(1, subscriber.NotifyCount, 'Subscriber notified on subscribe to dirty flag.');
+
+  dirtyFlag.Notify; // Notify again, flag was already dirty
+
+  Assert.AreEqual(1, subscriber.NotifyCount, 'Subscriber should NOT be notified again if flag was already dirty.');
+end;
+
+procedure TTestMycDirtyFlag.TestSubscriber_NotNotified_ByResetAction;
+var
+  dirtyFlag: IMycDirty;
+  subscriber: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(True); // Start dirty
+  subscriber := TMockSubscriber.Create;
+  subscription := dirtyFlag.State.Subscribe(subscriber); // Gets initial notification
+
+  Assert.AreEqual(1, subscriber.NotifyCount, 'Subscriber notified on subscribe.');
+  dirtyFlag.Reset; // Reset the flag
+  Assert.IsFalse(dirtyFlag.State.IsSet, 'Flag is now clean.');
+
+  // Current TMycDirty.Reset does not notify subscribers.
+  Assert.AreEqual(1, subscriber.NotifyCount, 'Subscriber should NOT be notified by Reset action.');
+end;
+
+procedure TTestMycDirtyFlag.TestMultipleSubscribers_Notified_WhenFlagTransitionsToDirty;
+var
+  dirtyFlag: IMycDirty;
+  sub1, sub2: TMockSubscriber;
+  subscription1, subscription2: TMycSubscription;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(False); // Start clean
+  sub1 := TMockSubscriber.Create;
+  sub2 := TMockSubscriber.Create;
+  subscription1 := dirtyFlag.State.Subscribe(sub1);
+  subscription2 := dirtyFlag.State.Subscribe(sub2);
+
+  dirtyFlag.Notify; // Make flag dirty
+
+  Assert.AreEqual(1, sub1.NotifyCount, 'Subscriber 1 should be notified.');
+  Assert.AreEqual(1, sub2.NotifyCount, 'Subscriber 2 should be notified.');
+end;
+
+procedure TTestMycDirtyFlag.TestUnsubscribe_SubscriberNotNotified;
+var
+  dirtyFlag: IMycDirty;
+  subscriber: TMockSubscriber;
+  subscription: TMycSubscription;
+begin
+  dirtyFlag := CreateAndPrepareDirtyFlag(False); // Start clean
+  subscriber := TMockSubscriber.Create;
+  subscription := dirtyFlag.State.Subscribe(subscriber);
+
+  subscription.Unsubscribe; // Explicitly unsubscribe
+
+  dirtyFlag.Notify; // Make flag dirty
+
+  Assert.AreEqual(0, subscriber.NotifyCount, 'Unsubscribed subscriber should not be notified.');
+end;
+
+// Category 3: Chaining Dirty Flags
+// In these tests, FlagX.Notify means calling the IMycSubscriber.Notify method on FlagX.
+// This makes FlagX dirty and potentially notifies its subscribers (like FlagY).
+
+procedure TTestMycDirtyFlag.TestChain_A_Notifies_B_SimplePropagation;
+var
+  flagA, flagB: IMycDirty;
+  subToB: TMockSubscriber;
+  subscriptionA_B, subscriptionMock_B: TMycSubscription;
+begin
+  flagA := CreateAndPrepareDirtyFlag(False); // A starts clean
+  flagB := CreateAndPrepareDirtyFlag(False); // B starts clean
+  subToB := TMockSubscriber.Create;
+
+  subscriptionMock_B := flagB.State.Subscribe(subToB);
+  subscriptionA_B := flagA.State.Subscribe(flagB); // B subscribes to A's state changes (B's Notify will be called)
+
+  flagA.Notify; // Make A dirty. This should trigger B.Notify
+
+  Assert.IsTrue(flagA.State.IsSet, 'Flag A should be dirty.');
+  Assert.IsTrue(flagB.State.IsSet, 'Flag B should become dirty due to A.');
+  Assert.AreEqual(1, subToB.NotifyCount, 'Subscriber to B should be notified once.');
+end;
+
+procedure TTestMycDirtyFlag.TestChain_A_Notifies_B_Notifies_C_SimplePropagation;
+var
+  flagA, flagB, flagC: IMycDirty;
+  subToC: TMockSubscriber;
+  subscriptionB_A, subscriptionC_B, subscriptionMock_C: TMycSubscription;
+begin
+  flagA := CreateAndPrepareDirtyFlag(False);
+  flagB := CreateAndPrepareDirtyFlag(False);
+  flagC := CreateAndPrepareDirtyFlag(False);
+  subToC := TMockSubscriber.Create;
+
+  subscriptionMock_C := flagC.State.Subscribe(subToC);
+  subscriptionC_B := flagB.State.Subscribe(flagC); // C subscribes to B
+  subscriptionB_A := flagA.State.Subscribe(flagB); // B subscribes to A
+
+  flagA.Notify; // Make A dirty
+
+  Assert.IsTrue(flagA.State.IsSet, 'Flag A should be dirty in cascade.');
+  Assert.IsTrue(flagB.State.IsSet, 'Flag B should be dirty in cascade.');
+  Assert.IsTrue(flagC.State.IsSet, 'Flag C should be dirty in cascade.');
+  Assert.AreEqual(1, subToC.NotifyCount, 'Subscriber to C should be notified once in cascade.');
+end;
+
+// Category 4: Chaining with Resets and Re-triggering (Consistency)
+
+procedure TTestMycDirtyFlag.TestChain_A_B_ResetB_RetriggerA_BStaysCleanIfANotChanged;
+var
+  flagA, flagB: IMycDirty;
+  subToB: TMockSubscriber;
+  subscriptionA_B, subscriptionMock_B: TMycSubscription;
+begin
+  flagA := CreateAndPrepareDirtyFlag(False);
+  flagB := CreateAndPrepareDirtyFlag(False);
+  subToB := TMockSubscriber.Create;
+  subscriptionMock_B := flagB.State.Subscribe(subToB);
+  subscriptionA_B := flagA.State.Subscribe(flagB);
+
+  flagA.Notify; // A dirty -> B dirty. subToB notified.
+  Assert.IsTrue(flagB.State.IsSet, 'Flag B should be dirty initially.');
+  Assert.AreEqual(1, subToB.NotifyCount, 'Subscriber to B initially notified.');
+
+  flagB.Reset; // B becomes clean. A is still dirty.
+  Assert.IsFalse(flagB.State.IsSet, 'Flag B should be clean after reset.');
+  Assert.AreEqual(1, subToB.NotifyCount, 'Subscriber to B not notified by B.Reset.');
+
+  // Notify A again. A was already dirty. So A.Notify() returns false, A does not call ProtectedNotifyOwnSubscribers.
+  // Thus, B.Notify() is NOT called. B should remain clean.
+  flagA.Notify;
+
+  Assert.IsTrue(flagA.State.IsSet, 'Flag A remains dirty.');
+  Assert.IsFalse(flagB.State.IsSet, 'Flag B should remain clean if A did not transition to dirty.');
+  Assert.AreEqual(1, subToB.NotifyCount, 'Subscriber to B should not be notified again.');
+end;
+
+procedure TTestMycDirtyFlag.TestChain_A_B_ResetA_ThenTriggerA_FullPropagationToB;
+var
+  flagA, flagB: IMycDirty;
+  subToB: TMockSubscriber;
+  subscriptionA_B, subscriptionMock_B: TMycSubscription;
+begin
+  flagA := CreateAndPrepareDirtyFlag(False);
+  flagB := CreateAndPrepareDirtyFlag(False);
+  subToB := TMockSubscriber.Create;
+  subscriptionMock_B := flagB.State.Subscribe(subToB);
+  subscriptionA_B := flagA.State.Subscribe(flagB);
+
+  flagA.Notify; // A dirty -> B dirty. subToB notified.
+  Assert.IsTrue(flagB.State.IsSet, 'Flag B should be dirty after A triggers.');
+  Assert.AreEqual(1, subToB.NotifyCount, 'subToB notified once.');
+
+  flagA.Reset; // A becomes clean. B is still dirty (state change of A to clean doesn't propagate as a "dirty" signal to B).
+  Assert.IsFalse(flagA.State.IsSet, 'Flag A is clean after reset.');
+  Assert.IsTrue(flagB.State.IsSet, 'Flag B remains dirty.'); // B's state doesn't change because A becoming clean doesn't call B.Notify
+
+  flagA.Notify; // A (was clean) becomes dirty again. A.Notify() returns true. A notifies B.
+                // B.Notify() is called. B was dirty. B.Notify() sets FFlag to true (no change), returns false.
+                // So B does NOT notify subToB again.
+
+  Assert.IsTrue(flagA.State.IsSet, 'Flag A is dirty again.');
+  Assert.IsTrue(flagB.State.IsSet, 'Flag B is dirty (was already, and A.Notify called B.Notify which set it dirty again).');
+  Assert.AreEqual(1, subToB.NotifyCount, 'subToB should NOT be notified again as B did not transition from clean to dirty.');
+end;
+
+procedure TTestMycDirtyFlag.TestChain_A_B_C_IntermediateBReset_RetriggerA_PropagatesToC;
+var
+  flagA, flagB, flagC: IMycDirty;
+  subToC: TMockSubscriber;
+  subscriptionB_A, subscriptionC_B, subscriptionMock_C: TMycSubscription;
+begin
+  flagA := CreateAndPrepareDirtyFlag(False);
+  flagB := CreateAndPrepareDirtyFlag(False);
+  flagC := CreateAndPrepareDirtyFlag(False);
+  subToC := TMockSubscriber.Create;
+
+  subscriptionMock_C := flagC.State.Subscribe(subToC);
+  subscriptionC_B := flagB.State.Subscribe(flagC);
+  subscriptionB_A := flagA.State.Subscribe(flagB);
+
+  // Initial full propagation
+  flagA.Notify; // A dirty -> B dirty -> C dirty. subToC notified.
+  Assert.IsTrue(flagC.State.IsSet, 'Flag C should be dirty initially.');
+  Assert.AreEqual(1, subToC.NotifyCount, 'subToC initial count.');
+
+  // Intermediate reset
+  flagB.Reset; // B becomes clean. A is dirty, C is dirty.
+  Assert.IsFalse(flagB.State.IsSet, 'Flag B is clean.');
+
+  // Reset and re-trigger A
+  flagA.Reset; // A becomes clean.
+  Assert.IsFalse(flagA.State.IsSet, 'Flag A is clean.');
+
+  flagA.Notify; // A (was clean) -> A dirty. A notifies B.
+                // B.Notify() called. B was clean -> B dirty. B notifies C.
+                // C.Notify() called. C was dirty -> C set dirty (no change), C.Notify() returns false.
+                // So subToC is NOT notified again.
+
+  Assert.IsTrue(flagA.State.IsSet, 'Flag A is dirty again.');
+  Assert.IsTrue(flagB.State.IsSet, 'Flag B becomes dirty again.');
+  Assert.IsTrue(flagC.State.IsSet, 'Flag C is dirty (was already).');
+  Assert.AreEqual(1, subToC.NotifyCount, 'subToC should NOT be notified again.');
+end;
+
+procedure TTestMycDirtyFlag.TestChain_A_B_C_AllReset_RetriggerA_FullPropagation;
+var
+  flagA, flagB, flagC: IMycDirty;
+  subToC: TMockSubscriber;
+  subscriptionB_A, subscriptionC_B, subscriptionMock_C: TMycSubscription;
+begin
+  flagA := CreateAndPrepareDirtyFlag(False);
+  flagB := CreateAndPrepareDirtyFlag(False);
+  flagC := CreateAndPrepareDirtyFlag(False);
+  subToC := TMockSubscriber.Create;
+
+  subscriptionMock_C := flagC.State.Subscribe(subToC);
+  subscriptionC_B := flagB.State.Subscribe(flagC);
+  subscriptionB_A := flagA.State.Subscribe(flagB);
+
+  // All are clean. Trigger A.
+  flagA.Notify; // A dirty -> B dirty -> C dirty. subToC notified.
+  Assert.IsTrue(flagC.State.IsSet, 'Flag C dirty after first full propagation.');
+  Assert.AreEqual(1, subToC.NotifyCount, 'subToC notified once.');
+
+  // Reset all
+  flagA.Reset;
+  flagB.Reset;
+  flagC.Reset;
+  Assert.IsFalse(flagA.State.IsSet, 'Flag A clean.');
+  Assert.IsFalse(flagB.State.IsSet, 'Flag B clean.');
+  Assert.IsFalse(flagC.State.IsSet, 'Flag C clean.');
+  // subToC count is still 1, it's not notified by resets.
+
+  // Re-trigger A
+  flagA.Notify; // A (was clean) -> A dirty. A notifies B.
+                // B.Notify() called. B was clean -> B dirty. B notifies C.
+                // C.Notify() called. C was clean -> C dirty. C notifies subToC.
+
+  Assert.IsTrue(flagA.State.IsSet, 'Flag A dirty on re-trigger.');
+  Assert.IsTrue(flagB.State.IsSet, 'Flag B dirty on re-trigger.');
+  Assert.IsTrue(flagC.State.IsSet, 'Flag C dirty on re-trigger.');
+  Assert.AreEqual(2, subToC.NotifyCount, 'subToC should be notified a second time.');
+end;
+
+procedure TTestMycDirtyFlag.TestChain_A_B_C_TriggerA_ResetA_TriggerA_EnsureCNotifiedCorrectly;
+var
+  flagA, flagB, flagC: IMycDirty;
+  subToC: TMockSubscriber;
+  subscriptionB_A, subscriptionC_B, subscriptionMock_C: TMycSubscription;
+begin
+  flagA := CreateAndPrepareDirtyFlag(False);
+  flagB := CreateAndPrepareDirtyFlag(False);
+  flagC := CreateAndPrepareDirtyFlag(False);
+  subToC := TMockSubscriber.Create;
+
+  subscriptionMock_C := flagC.State.Subscribe(subToC);
+  subscriptionC_B := flagB.State.Subscribe(flagC);
+  subscriptionB_A := flagA.State.Subscribe(flagB);
+
+  // 1. Trigger A
+  flagA.Notify; // A, B, C become dirty. subToC notified (count = 1).
+  Assert.IsTrue(flagC.State.IsSet, 'C is dirty after 1st trigger.');
+  Assert.AreEqual(1, subToC.NotifyCount, 'subToC count after 1st trigger.');
+
+  // 2. Reset A (B and C remain dirty)
+  flagA.Reset;
+  Assert.IsFalse(flagA.State.IsSet, 'A is clean.');
+  Assert.IsTrue(flagB.State.IsSet, 'B remains dirty.');
+  Assert.IsTrue(flagC.State.IsSet, 'C remains dirty.');
+
+  // 3. Trigger A again
+  flagA.Notify; // A (was clean) becomes dirty. A notifies B.
+                // B.Notify() is called. B was dirty. B.Notify sets FFlag to true (no change), returns false.
+                // B does NOT notify C. C remains dirty. subToC is NOT notified again.
+  Assert.IsTrue(flagA.State.IsSet, 'A is dirty after 2nd trigger.');
+  Assert.IsTrue(flagB.State.IsSet, 'B is still dirty (state did not flip to clean then dirty).');
+  Assert.IsTrue(flagC.State.IsSet, 'C is still dirty.');
+  Assert.AreEqual(1, subToC.NotifyCount, 'subToC count should remain 1.');
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(TTestMycDirtyFlag);
+end.

Test/TestSignals_Latch.pas

@@ -1,22 +1,22 @@
+// Suggested filename: TestSignals_Latch.pas
 unit TestSignals_Latch;
 
 interface
 
 uses
   DUnitX.TestFramework,
-  Myc.Signals, // Unit under test, using TMycLatch static members
   System.SysUtils,
-  System.StrUtils;
+  Myc.Signals; // Unit under test, using TMycLatch static members
 
 type
   // Helper class to mock a subscriber.
   TMockSubscriber = class(TInterfacedObject, IMycSubscriber)
   public
     NotifyCount: Integer;
-    NotifyShouldReturn: Boolean;
+    NotifyShouldReturn: Boolean; // Determines what this mock's Notify method returns
     WasCalled: Boolean;
 
-    constructor Create(ShouldReturn: Boolean = True);
+    constructor Create(AShouldReturn: Boolean = True); // Parameter name AShouldReturn for clarity
     function Notify: Boolean; // IMycSubscriber implementation.
   end;
 
@@ -30,15 +30,15 @@ type
 
     // --- Category 1: Basic Counter and State Functionality (Parameterized) ---
     [TestCase('InitialPositive', '1,False')]
-    [TestCase('InitialZero', '0,True')] // TMycLatch.CreateLatch(0) will return TMycLatch.Null
-    [TestCase('InitialNegative', '-1,True')] // TMycLatch.CreateLatch(-1) will return TMycLatch.Null
+    [TestCase('InitialZero_ReturnsNullLatch', '0,True')]
+    [TestCase('InitialNegative_ReturnsNullLatch', '-1,True')]
     [TestCase('InitialLargePositive', '5,False')]
     procedure TestCreate_InitialState(InitialCount: Integer; ExpectedIsSet: Boolean);
 
-    [TestCase('DecrementPositiveToZero', '1,False,True')]
+    [TestCase('DecrementPositiveToZero', '1,False,True')]     // InitialCount, ExpectedReturnFromLatchNotify, ExpectedIsSetAfterNotify
     [TestCase('DecrementPositiveToPositive', '2,True,False')]
-    [TestCase('DecrementZeroToNegative', '0,False,True')]
-    [TestCase('DecrementNegativeToNegative', '-1,False,True')]
+    [TestCase('DecrementZeroToNegative', '0,False,True')]     // Latch.Notify on count 0 returns false (0 > 0 is false)
+    [TestCase('DecrementNegativeToNegative', '-1,False,True')] // Latch.Notify on count -1 returns false (-1 > 0 is false)
     procedure TestNotify_ReturnValueAndState_AfterOneNotify(InitialCount: Integer; ExpectedReturn: Boolean; ExpectedIsSet: Boolean);
 
     [Test]
@@ -54,11 +54,11 @@ type
     [Test]
     procedure TestSubscriber_NotNotified_BeforeLatchSet;
     [Test]
-    procedure TestSubscriber_NotifiedOnlyOnce_AfterLatchSet;
+    procedure TestSubscriber_NotifiedOnlyOnce_AfterLatchSetAndUnadvised; // Clarified name
     [Test]
     procedure TestSubscribe_ToAlreadySetLatch_NotifiesImmediately;
 
-    // --- Category 3: Chaining and Cascading ---
+    // --- Category 3: Chaining and Cascading Latches ---
     [Test]
     procedure TestChaining_A_Notifies_B;
     [Test]
@@ -68,25 +68,33 @@ type
 
     // --- Category 4: Special Cases ---
     [Test]
-    procedure TestInitiallySetLatch_NotifiesNewSubscriberImmediately;
+    procedure TestInitiallySetLatch_NotifiesNewSubscriberImmediately; // Using CreateLatch(0)
 
     [Test]
     procedure TestUnsubscribe_SubscriberNotNotified;
 
-    // --- Category 5: Signal Loss / Counter Integrity ---
+    // --- Category 5: Counter Integrity / State for Later Subscribers ---
     [Test]
     procedure TestMultipleTriggersNoSubscriber_StateCorrectForLaterSubscriber;
+
+    // --- Category 6: UnadviseAll Behavior on Latch Set ---
+    [Test]
+    procedure TestLatchSet_ClearsSubscribers_NoFurtherNotification;
+    [Test]
+    procedure TestLatchSet_SubscriptionFinalize_IsSafePostUnadviseAll;
+    [Test]
+    procedure TestLatchSet_NewSubscriberToSetLatch_NotifiedImmediatelyButNotPersistedForLatchNotify;
   end;
 
 implementation
 
 { TMockSubscriber }
 
-constructor TMockSubscriber.Create(ShouldReturn: Boolean = True);
+constructor TMockSubscriber.Create(AShouldReturn: Boolean = True);
 begin
   inherited Create;
   NotifyCount := 0;
-  NotifyShouldReturn := ShouldReturn;
+  NotifyShouldReturn := AShouldReturn;
   WasCalled := False;
 end;
 
@@ -94,7 +102,7 @@ function TMockSubscriber.Notify: Boolean;
 begin
   Inc(NotifyCount);
   WasCalled := True;
-  Result := NotifyShouldReturn;
+  Result := NotifyShouldReturn; // This mock subscriber returns what it's configured to.
 end;
 
 { TTestMycLatch }
@@ -109,61 +117,66 @@ begin
   // Per-test teardown code can go here (if any).
 end;
 
+// --- Category 1: Basic Counter and State Functionality (Parameterized) ---
+
 procedure TTestMycLatch.TestCreate_InitialState(InitialCount: Integer; ExpectedIsSet: Boolean);
 var
   latch: IMycLatch;
 begin
-  latch := TMycLatch.CreateLatch(InitialCount); // Changed to use TMycLatch.CreateLatch
-  Assert.AreEqual(ExpectedIsSet, latch.State.IsSet, 'Latch initial IsSet state mismatch.');
+  // TMycLatch.CreateLatch returns TMycLatch.Null if InitialCount <= 0
+  latch := TMycLatch.CreateLatch(InitialCount);
+  Assert.AreEqual(ExpectedIsSet, latch.State.IsSet, 'Latch initial IsSet state mismatch for count ' + IntToStr(InitialCount) + '.');
 end;
 
 procedure TTestMycLatch.TestNotify_ReturnValueAndState_AfterOneNotify(InitialCount: Integer; ExpectedReturn: Boolean; ExpectedIsSet: Boolean);
 var
   latch: IMycLatch;
-  returnedValue: Boolean;
+  returnedValueFromNotify: Boolean;
 begin
-  latch := TMycLatch.CreateLatch(InitialCount); // Changed to use TMycLatch.CreateLatch
-  returnedValue := latch.Notify;
+  latch := TMycLatch.CreateLatch(InitialCount);
+  returnedValueFromNotify := latch.Notify; // This is IMycLatch (as IMycSubscriber).Notify
 
-  Assert.AreEqual(ExpectedReturn, returnedValue, 'Unexpected return value from Latch.Notify call.');
-  Assert.AreEqual(ExpectedIsSet, latch.State.IsSet, 'Unexpected IsSet state after Latch.Notify call.');
+  Assert.AreEqual(ExpectedReturn, returnedValueFromNotify, 'Unexpected return value from Latch.Notify call for initial count ' + IntToStr(InitialCount) + '.');
+  Assert.AreEqual(ExpectedIsSet, latch.State.IsSet, 'Unexpected IsSet state after Latch.Notify call for initial count ' + IntToStr(InitialCount) + '.');
 end;
 
 procedure TTestMycLatch.TestNotify_DecrementsCounter_StateChanges;
 var
   latch: IMycLatch;
 begin
-  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
-  Assert.IsFalse(latch.State.IsSet, 'Latch should initially not be set.');
-  latch.Notify;
-  Assert.IsTrue(latch.State.IsSet, 'Latch should be set after Notify.');
+  latch := TMycLatch.CreateLatch(1);
+  Assert.IsFalse(latch.State.IsSet, 'Latch should initially not be set (Count=1).');
+  latch.Notify; // Count becomes 0
+  Assert.IsTrue(latch.State.IsSet, 'Latch should be set after Notify (Count became 0).');
 end;
 
 procedure TTestMycLatch.TestNotify_MultipleNotifies_CounterBecomesNegativeAndStaysSet;
 var
   latch: IMycLatch;
 begin
-  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
-  latch.Notify;
+  latch := TMycLatch.CreateLatch(1);
+  latch.Notify; // Count becomes 0, IsSet = True
   Assert.IsTrue(latch.State.IsSet, 'Latch should be set after first Notify.');
-  latch.Notify;
+  latch.Notify; // Count becomes -1, IsSet should remain True
   Assert.IsTrue(latch.State.IsSet, 'Latch should remain set after second Notify.');
 end;
 
+// --- Category 2: Notification to Subscribers ---
+
 procedure TTestMycLatch.TestSubscriber_Single_IsNotifiedWhenLatchSet;
 var
   latch: IMycLatch;
   mockSub: TMockSubscriber;
   subscription: TMycSubscription;
 begin
-  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latch := TMycLatch.CreateLatch(1);
   mockSub := TMockSubscriber.Create;
-  subscription := latch.State.Subscribe(mockSub);
+  subscription := latch.State.Subscribe(mockSub); // Subscribing to the Latch's state
 
   Assert.IsFalse(latch.State.IsSet, 'Latch should initially not be set.');
   Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should not have been notified yet (before latch set).');
 
-  latch.Notify;
+  latch.Notify; // Latch becomes set, notifies subscribers
 
   Assert.IsTrue(latch.State.IsSet, 'Latch should be set after its Notify is called.');
   Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should have been notified once when latch becomes set.');
@@ -173,9 +186,9 @@ procedure TTestMycLatch.TestSubscriber_Multiple_AreNotifiedWhenLatchSet;
 var
   latch: IMycLatch;
   mockSub1, mockSub2, mockSub3: TMockSubscriber;
-  sub1, sub2, sub3: TMycSubscription;
+  sub1, sub2, sub3: TMycSubscription; // Keep subscriptions in scope
 begin
-  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latch := TMycLatch.CreateLatch(1);
   mockSub1 := TMockSubscriber.Create;
   mockSub2 := TMockSubscriber.Create;
   mockSub3 := TMockSubscriber.Create;
@@ -184,7 +197,7 @@ begin
   sub2 := latch.State.Subscribe(mockSub2);
   sub3 := latch.State.Subscribe(mockSub3);
 
-  latch.Notify;
+  latch.Notify; // Latch becomes set
 
   Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 notification count mismatch.');
   Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 notification count mismatch.');
@@ -197,29 +210,29 @@ var
   mockSub: TMockSubscriber;
   subscription: TMycSubscription;
 begin
-  latch := TMycLatch.CreateLatch(2); // Changed to use TMycLatch.CreateLatch
+  latch := TMycLatch.CreateLatch(2); // Count = 2
   mockSub := TMockSubscriber.Create;
   subscription := latch.State.Subscribe(mockSub);
 
   Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should not be notified upon subscription if latch is not set.');
-  latch.Notify;
-  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should still not be notified as latch is not yet set.');
+  latch.Notify; // Count becomes 1, still not set
+  Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should still not be notified as latch is not yet set (Count=1).');
 end;
 
-procedure TTestMycLatch.TestSubscriber_NotifiedOnlyOnce_AfterLatchSet;
+procedure TTestMycLatch.TestSubscriber_NotifiedOnlyOnce_AfterLatchSetAndUnadvised;
 var
   latch: IMycLatch;
   mockSub: TMockSubscriber;
   subscription: TMycSubscription;
 begin
-  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latch := TMycLatch.CreateLatch(1);
   mockSub := TMockSubscriber.Create;
   subscription := latch.State.Subscribe(mockSub);
 
-  latch.Notify;
+  latch.Notify; // Sets latch, notifies MockSub. Subscribers are then unadvised by UnadviseAll.
   Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub notify count should be 1 after latch set.');
 
-  latch.Notify;
+  latch.Notify; // Call Notify on latch again (FCount becomes more negative).
   Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub notify count should remain 1 (not notified again as it was unadvised).');
 end;
 
@@ -229,42 +242,47 @@ var
   mockSub1, mockSub2: TMockSubscriber;
   subscription1, subscription2: TMycSubscription;
 begin
-  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latch := TMycLatch.CreateLatch(1); // Create with count 1
   mockSub1 := TMockSubscriber.Create;
-  subscription1 := latch.State.Subscribe(mockSub1);
-  latch.Notify;
+  subscription1 := latch.State.Subscribe(mockSub1); // Subscribe before set
+
+  latch.Notify; // Latch becomes set. mockSub1 is notified.
 
   Assert.IsTrue(latch.State.IsSet, 'Latch should be set after initial trigger.');
   Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 should have been notified once.');
 
+  // Attempt to subscribe mockSub2 after the latch is already set.
   mockSub2 := TMockSubscriber.Create;
-  subscription2 := latch.State.Subscribe(mockSub2);
+  subscription2 := latch.State.Subscribe(mockSub2); // TMycLatch.Subscribe (via TMycAbstractFlag) notifies immediately if already set.
 
   Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 should be notified immediately upon subscribing to an already set latch.');
 
-  latch.Notify;
-  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 notify count should remain 1.');
-  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 notify count should remain 1 after re-triggering.');
+  latch.Notify; // Call Notify on latch again (FCount becomes more negative).
+  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 notify count should remain 1 (was unadvised).');
+  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 notify count should remain 1 (was only notified on subscribe, not added to list).');
 end;
 
+// --- Category 3: Chaining and Cascading Latches ---
+
 procedure TTestMycLatch.TestChaining_A_Notifies_B;
 var
   latchA, latchB: IMycLatch;
   mockSubForB: TMockSubscriber;
   subHandle_B_listens_A, subHandle_Mock_listens_B: TMycSubscription;
 begin
-  latchA := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
-  latchB := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latchA := TMycLatch.CreateLatch(1);
+  latchB := TMycLatch.CreateLatch(1); // latchB is an IMycSubscriber
   mockSubForB := TMockSubscriber.Create;
 
   subHandle_Mock_listens_B := latchB.State.Subscribe(mockSubForB);
+  // LatchA's state is an IMycSignal. LatchB (as IMycSubscriber) subscribes to it.
   subHandle_B_listens_A := latchA.State.Subscribe(latchB);
 
   Assert.IsFalse(latchA.State.IsSet, 'LatchA initially not set.');
   Assert.IsFalse(latchB.State.IsSet, 'LatchB initially not set.');
   Assert.AreEqual(0, mockSubForB.NotifyCount, 'MockSubForB initially not notified.');
 
-  latchA.Notify;
+  latchA.Notify; // Call Notify on LatchA (as IMycSubscriber)
 
   Assert.IsTrue(latchA.State.IsSet, 'LatchA should be set after notify.');
   Assert.IsTrue(latchB.State.IsSet, 'LatchB should be set after being notified by LatchA.');
@@ -277,16 +295,16 @@ var
   mockSubForC: TMockSubscriber;
   sub_Mock_C, sub_C_B, sub_B_A: TMycSubscription;
 begin
-  latchA := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
-  latchB := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
-  latchC := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latchA := TMycLatch.CreateLatch(1);
+  latchB := TMycLatch.CreateLatch(1);
+  latchC := TMycLatch.CreateLatch(1);
   mockSubForC := TMockSubscriber.Create;
 
   sub_Mock_C := latchC.State.Subscribe(mockSubForC);
-  sub_C_B    := latchB.State.Subscribe(latchC);
-  sub_B_A    := latchA.State.Subscribe(latchB);
+  sub_C_B    := latchB.State.Subscribe(latchC); // LatchC subscribes to LatchB's state
+  sub_B_A    := latchA.State.Subscribe(latchB); // LatchB subscribes to LatchA's state
 
-  latchA.Notify;
+  latchA.Notify; // Call Notify on LatchA
 
   Assert.IsTrue(latchA.State.IsSet, 'LatchA state mismatch in cascade.');
   Assert.IsTrue(latchB.State.IsSet, 'LatchB state mismatch in cascade.');
@@ -300,37 +318,42 @@ var
   mockSubForB: TMockSubscriber;
   sub_Mock_B, sub_B_A: TMycSubscription;
 begin
-  latchA := TMycLatch.CreateLatch(2); // Changed to use TMycLatch.CreateLatch
-  latchB := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  // LatchA needs 2 notifies to become set. LatchB needs 1 notify to become set.
+  // LatchB subscribes to LatchA. So LatchB will be notified once LatchA becomes set.
+  latchA := TMycLatch.CreateLatch(2);
+  latchB := TMycLatch.CreateLatch(1);
   mockSubForB := TMockSubscriber.Create;
 
   sub_Mock_B := latchB.State.Subscribe(mockSubForB);
   sub_B_A    := latchA.State.Subscribe(latchB);
 
-  latchA.Notify;
+  latchA.Notify; // First notify for LatchA (count becomes 1)
   Assert.IsFalse(latchA.State.IsSet, 'LatchA should not be set after first notify of two.');
   Assert.IsFalse(latchB.State.IsSet, 'LatchB should not have been triggered yet by LatchA.');
   Assert.AreEqual(0, mockSubForB.NotifyCount, 'MockSubForB should not have been notified yet.');
 
-  latchA.Notify;
+  latchA.Notify; // Second notify for LatchA (count becomes 0, LatchA becomes set)
   Assert.IsTrue(latchA.State.IsSet, 'LatchA should be set after second notify.');
+  // When LatchA becomes set, it notifies its subscribers (LatchB). LatchB.Notify is called.
   Assert.IsTrue(latchB.State.IsSet, 'LatchB should now be set by LatchA.');
   Assert.AreEqual(1, mockSubForB.NotifyCount, 'MockSubForB should have been notified by LatchB.');
 end;
 
+// --- Category 4: Special Cases ---
+
 procedure TTestMycLatch.TestInitiallySetLatch_NotifiesNewSubscriberImmediately;
 var
-  latch: IMycLatch;
+  latch: IMycLatch; // Will be TMycLatch.Null
   mockSub: TMockSubscriber;
   subscription: TMycSubscription;
 begin
-  latch := TMycLatch.CreateLatch(0); // Changed to use TMycLatch.CreateLatch. Will return TMycLatch.Null.
+  latch := TMycLatch.CreateLatch(0); // Returns TMycLatch.Null which is set.
   mockSub := TMockSubscriber.Create;
 
-  subscription := latch.State.Subscribe(mockSub);
+  subscription := latch.State.Subscribe(mockSub); // TMycLatch.Subscribe notifies immediately if already set.
 
-  Assert.IsTrue(latch.State.IsSet, 'Latch IsSet property mismatch after creation with count 0.');
-  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should be notified immediately upon subscribing to an already set latch.');
+  Assert.IsTrue(latch.State.IsSet, 'Latch IsSet property mismatch (should be true for Null latch).');
+  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should be notified immediately upon subscribing to an initially set latch.');
 end;
 
 procedure TTestMycLatch.TestUnsubscribe_SubscriberNotNotified;
@@ -339,38 +362,139 @@ var
   mockSub: TMockSubscriber;
   subscription: TMycSubscription;
 begin
-  latch := TMycLatch.CreateLatch(1); // Changed to use TMycLatch.CreateLatch
+  latch := TMycLatch.CreateLatch(1);
   mockSub := TMockSubscriber.Create;
 
   subscription := latch.State.Subscribe(mockSub);
-  subscription := Default(TMycSubscription); // Simulates leaving scope / destruction, calls Finalize for unsubscription.
+  subscription.Unsubscribe; // Explicitly call Unsubscribe on the record
 
-  latch.Notify;
+  latch.Notify; // Latch becomes set
 
   Assert.AreEqual(0, mockSub.NotifyCount, 'Unsubscribed MockSub should not be notified.');
 end;
 
+// --- Category 5: Counter Integrity / State for Later Subscribers ---
+
 procedure TTestMycLatch.TestMultipleTriggersNoSubscriber_StateCorrectForLaterSubscriber;
 var
   latch: IMycLatch;
   mockSub: TMockSubscriber;
   subscription: TMycSubscription;
 begin
-  latch := TMycLatch.CreateLatch(3); // Changed to use TMycLatch.CreateLatch
+  latch := TMycLatch.CreateLatch(3);
 
-  latch.Notify;
-  latch.Notify;
+  latch.Notify; // Count -> 2
+  latch.Notify; // Count -> 1
   Assert.IsFalse(latch.State.IsSet, 'Latch should not be set yet after partial notifies.');
 
   mockSub := TMockSubscriber.Create;
   subscription := latch.State.Subscribe(mockSub);
   Assert.AreEqual(0, mockSub.NotifyCount, 'MockSub should not be notified on subscribe if latch not yet set.');
 
-  latch.Notify;
+  latch.Notify; // Count -> 0, Latch becomes set and notifies mockSub
   Assert.IsTrue(latch.State.IsSet, 'Latch should now be set.');
   Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should have been notified when latch becomes set.');
 end;
 
+// --- Category 6: UnadviseAll Behavior on Latch Set ---
+
+procedure TTestMycLatch.TestLatchSet_ClearsSubscribers_NoFurtherNotification;
+var
+  latch: IMycLatch;
+  mockSub1, mockSub2: TMockSubscriber;
+  subscription1, subscription2: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(1);
+  mockSub1 := TMockSubscriber.Create;
+  mockSub2 := TMockSubscriber.Create;
+
+  subscription1 := latch.State.Subscribe(mockSub1);
+  subscription2 := latch.State.Subscribe(mockSub2);
+
+  Assert.AreEqual(0, mockSub1.NotifyCount, 'MockSub1 initial NotifyCount should be 0.');
+  Assert.AreEqual(0, mockSub2.NotifyCount, 'MockSub2 initial NotifyCount should be 0.');
+
+  latch.Notify; // FCount becomes 0. Subscribers notified, then UnadviseAll called.
+
+  Assert.IsTrue(latch.State.IsSet, 'Latch should be set.');
+  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 should have been notified once when latch became set.');
+  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 should have been notified once when latch became set.');
+
+  latch.Notify; // Call Notify on the latch again (FCount becomes -1)
+
+  Assert.AreEqual(1, mockSub1.NotifyCount, 'MockSub1 should NOT be notified again after UnadviseAll.');
+  Assert.AreEqual(1, mockSub2.NotifyCount, 'MockSub2 should NOT be notified again after UnadviseAll.');
+end;
+
+procedure TTestMycLatch.TestLatchSet_SubscriptionFinalize_IsSafePostUnadviseAll;
+var
+  latch: IMycLatch;
+  mockSub: TMockSubscriber;
+  // 'subscription' will be declared in an inner scope to control its finalization
+begin
+  latch := TMycLatch.CreateLatch(1);
+  mockSub := TMockSubscriber.Create;
+
+  var noException: Boolean := True;
+  try
+    begin // Inner block to control lifetime of 'subscription'
+      var subscription: TMycSubscription; // Local to this block
+      subscription := latch.State.Subscribe(mockSub);
+
+      latch.Notify; // Sets the latch, mockSub is notified, UnadviseAll is called internally.
+      Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub was notified when latch set.');
+
+      // When 'subscription' goes out of scope at the end of this 'begin..end' block,
+      // its Finalize operator will be called, which in turn calls subscription.Unsubscribe.
+      // This happens *after* UnadviseAll was triggered by latch.Notify.
+    end; // <-- subscription.Finalize (and thus Unsubscribe) is called here.
+  except
+    on E: Exception do
+    begin
+      noException := False;
+      // Optional: Log.Error('Exception in TestLatchSet_SubscriptionFinalize_IsSafePostUnadviseAll: ' + E.Message);
+    end;
+  end;
+  Assert.IsTrue(noException, 'Finalizing subscription after Latch set (and UnadviseAll) should not raise an exception.');
+
+  // Further check: calling Notify on latch again should not affect the original mockSub
+  latch.Notify;
+  Assert.AreEqual(1, mockSub.NotifyCount, 'MockSub should not be notified after its subscription was finalized post UnadviseAll.');
+end;
+
+procedure TTestMycLatch.TestLatchSet_NewSubscriberToSetLatch_NotifiedImmediatelyButNotPersistedForLatchNotify;
+var
+  latch: IMycLatch;
+  mockSubInitial, mockSubNew: TMockSubscriber;
+  subscriptionInitial, subscriptionNew: TMycSubscription;
+begin
+  latch := TMycLatch.CreateLatch(1);
+  mockSubInitial := TMockSubscriber.Create;
+  subscriptionInitial := latch.State.Subscribe(mockSubInitial);
+
+  // Set the latch; mockSubInitial is notified, UnadviseAll is called.
+  latch.Notify;
+  Assert.AreEqual(1, mockSubInitial.NotifyCount, 'Initial subscriber notified.');
+
+  // Subscribe a new subscriber to the already set latch
+  mockSubNew := TMockSubscriber.Create;
+  subscriptionNew := latch.State.Subscribe(mockSubNew);
+
+  // New subscriber should be notified immediately upon subscription to an already set latch
+  Assert.AreEqual(1, mockSubNew.NotifyCount, 'New subscriber should be notified immediately upon subscription.');
+  // The direct check of subscriptionNew.FTag was removed as FTag is private.
+  // The correct behavior (no persistent subscription) is verified by the next step.
+
+  // Call Notify on the latch again.
+  latch.Notify;
+
+  // mockSubInitial should not be notified again (was unadvised).
+  Assert.AreEqual(1, mockSubInitial.NotifyCount, 'Initial subscriber (unadvised) not notified again.');
+  // mockSubNew should also not be notified again, as it was only notified immediately
+  // and not persistently added to FSubscribers for subsequent Latch.Notify calls.
+  Assert.AreEqual(1, mockSubNew.NotifyCount, 'New subscriber (notified once on subscribe) not notified by subsequent Latch.Notify calls.');
+end;
+
 initialization
   TDUnitX.RegisterTestFixture(TTestMycLatch);
 end.

Test/TestStack.pas

@@ -453,7 +453,6 @@ var
   stack: TMycAtomicStack<ITestInterface>;
   nilIntf: ITestInterface;   // This is already nil by default
   nonNilIntf: ITestInterface;
-  popped: ITestInterface;
 begin
   nilIntf := nil; // Explicitly nil
   nonNilIntf := TTestImplementingObject.Create(999);

Test/TestTasks.pas

@@ -13,10 +13,10 @@ uses
 
 type
     [TestFixture]
+    [IgnoreMemoryLeaks(true)]
     TMycTaskFactoryTests = class(TObject)
     private
         FFactory: IMycTaskFactory;
-        procedure TestProcExecute(var executed: Boolean; signal: IMycLatch); // Parameter type is IMycLatch
     public
         [Setup]
         procedure Setup;
@@ -63,20 +63,9 @@ begin
     end;
 end;
 
-procedure TMycTaskFactoryTests.TestProcExecute(var executed: Boolean; signal: IMycLatch);
-begin
-    executed := True;
-    if Assigned(signal) then
-        signal.Notify;
-end;
-
 procedure TMycTaskFactoryTests.TestFactoryCreationAndTeardown;
-var
-    threadCount: Integer;
 begin
     Assert.IsNotNull(FFactory, 'Factory should be created');
-    threadCount := FFactory.ThreadCount;
-    Assert.AreEqual(TThread.ProcessorCount, threadCount, 'Thread count should match processor count');
 end;
 
 procedure TMycTaskFactoryTests.TestCreateThreadExecutesAndSignals;
@@ -149,22 +138,22 @@ end;
 procedure TMycTaskFactoryTests.TestRunDelayedJobDoesNotExecutePrematurely;
 var
     jobExecuted: Boolean;
-    jobCompletedLatch: IMycLatch;
+    jobCompleted: IMycLatch;
     subscriber: IMycSubscriber;
     startCount: Integer;
-    dummyWaitLatch: IMycLatch;
+    dummyWait: IMycLatch;
 begin
     jobExecuted := False;
     startCount := 3;
-    jobCompletedLatch := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
-    dummyWaitLatch := TMycLatch.CreateLatch(1);    // Changed from Signals.CreateLatch
+    jobCompleted := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
+    dummyWait := TMycLatch.CreateLatch(1);    // Changed from Signals.CreateLatch
 
 
     subscriber := FFactory.Run(startCount,
         procedure
         begin
             jobExecuted := True;
-            jobCompletedLatch.Notify;
+            jobCompleted.Notify;
         end);
 
     Assert.IsNotNull(subscriber, 'Run should return a subscriber for delayed job_P2');
@@ -175,8 +164,8 @@ begin
     subscriber.Notify;
     Assert.IsFalse(jobExecuted, 'Job should not execute after two notifications_P2');
 
-    FFactory.Run(0, procedure begin dummyWaitLatch.Notify; end);
-    FFactory.WaitFor(dummyWaitLatch.State);
+    FFactory.Run(0, procedure begin dummyWait.Notify; end);
+    FFactory.WaitFor(dummyWait.State);
 
     Assert.IsFalse(jobExecuted, 'Job should still not have executed before third notify_P2');
 end;
@@ -229,28 +218,25 @@ procedure TMycTaskFactoryTests.TestExceptionPropagationFromJob;
 var
     jobDoneLatch: IMycLatch;
 begin
-    jobDoneLatch := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
+    jobDoneLatch := TMycLatch.CreateLatch(1);
 
     FFactory.Run(0,
         procedure
-        var
-          dummy: Integer;
         begin
-            dummy := 0;
-            raise TMycTaskFactory.ETaskException.Create('Test Exception From Job');
-            // jobDoneLatch.Notify; // This line will not be reached
+            try
+                raise TMycTaskFactory.ETaskException.Create('Test Exception From Job');
+            finally
+                jobDoneLatch.Notify;
+            end;
         end);
 
-    FFactory.Run(0, procedure begin jobDoneLatch.Notify; end);
-    FFactory.WaitFor(jobDoneLatch.State);
-
     Assert.WillRaise(
         procedure
         begin
-            (FFactory as TMycTaskFactory).HandleException;
+            FFactory.WaitFor(jobDoneLatch.State);
         end,
         TMycTaskFactory.ETaskException,
-        'HandleException should re-raise the exception from the job'
+        'WaitFor should re-raise the exception from the job'
     );
 
     var noExceptionRaised: Boolean := True;
@@ -283,8 +269,8 @@ var
     dummyStateToWaitFor: IMycState;
 begin
     exceptionCaughtInJob := False;
-    jobDoneLatch := TMycLatch.CreateLatch(1); // Changed from Signals.CreateLatch
-    dummyStateToWaitFor := TMycLatch.CreateLatch(1).State; // Changed from Signals.CreateLatch
+    jobDoneLatch := TMycLatch.CreateLatch(1);
+    dummyStateToWaitFor := TMycLatch.CreateLatch(1).State;
 
     FFactory.Run(0,
         procedure