Documentation and Tests refinements

Author: ori88c

dist/zero-backpressure-semaphore.d.ts

@@ -74,7 +74,14 @@ export declare class ZeroBackpressureSemaphore<T, UncaughtErrorType = Error> {
     /**
      * amountOfUncaughtErrors
      *
-     * @returns The number of uncaught errors from background jobs, triggered by `startExecution`.
+     * Indicates the number of uncaught errors from background jobs triggered by `startExecution`,
+     * that are currently stored by the instance.
+     * These errors have not yet been extracted using `extractUncaughtErrors`.
+     *
+     * Knowing the number of uncaught errors allows users to decide whether to process them immediately
+     * or wait for further accumulation.
+     *
+     * @returns The number of uncaught errors from background jobs.
      */
     get amountOfUncaughtErrors(): number;
     /**
@@ -127,14 +134,15 @@ export declare class ZeroBackpressureSemaphore<T, UncaughtErrorType = Error> {
     /**
      * waitForAllExecutingJobsToComplete
      *
-     * This method allows the caller to wait until all currently executing jobs have completed.
-     * It is useful for ensuring that the application can terminate gracefully, without leaving
-     * any pending operations.
+     * This method allows the caller to wait until all *currently* executing jobs have finished,
+     * meaning once all running promises have either resolved or rejected.
+     *
+     * This is particularly useful in scenarios where you need to ensure that all jobs are completed
+     * before proceeding, such as during shutdown processes or between unit tests.
      *
-     * When this method is called, it returns a promise that resolves once all currently running
-     * promises have either resolved or rejected. This is particularly useful in scenarios where
-     * you need to ensure that all tasks are completed before proceeding, such as during shutdown
-     * processes or between unit tests.
+     * Note that the returned promise only awaits jobs that were executed at the time this method
+     * was called. Specifically, it awaits all jobs initiated by this instance that had not completed
+     * at the time of invocation.
      *
      * @returns A promise that resolves when all currently executing jobs are completed.
      */
@@ -160,8 +168,8 @@ export declare class ZeroBackpressureSemaphore<T, UncaughtErrorType = Error> {
      * This method can be useful when the system is experiencing high load (as indicated by CPU and/or memory
      * usage metrics), and you want to pause further async operations until an available job slot opens up.
      * However, the same effect can be achieved with `startExecution` alone if the async logic
-     * (which you intend to delay until availability) is performed *inside the job* rather than as a
-     * preliminary step. Therefore, `waitForAvailability` is more of a design choice than a necessity.
+     * (intended to be delayed until availability) is handled within the job itself rather than as a preliminary
+     * step. Therefore, `waitForAvailability` serves as a design choice rather than a strict necessity.
      *
      * @returns A promise that resolves once at least one slot is available.
      */