Bump version to v3.0.3: Docs and README improvements

Author: ori88c

README.md

@@ -1,4 +1,4 @@
-<h3 align="middle">Zero Backpressure Semaphore Typescript</h2>
+<h2 align="middle">Zero Backpressure Semaphore Typescript</h2>
 
 The `ZeroBackpressureSemaphore` class implements a semaphore for Node.js projects, allowing users to limit the number of concurrently executing jobs.  
 This implementation does not queue pending jobs, thereby eliminating backpressure. As a result, users have better control over memory footprint, which enhances performance by reducing garbage-collector overhead.
@@ -13,8 +13,8 @@ Each use case necessitates distinct handling capabilities, which will be discuss
 
 - __Backpressure Control__: Ideal for job workers and background services. Concurrency control alone isn't sufficient to ensure stability and performance if backpressure control is overlooked. Without backpressure control, the heap can become overloaded, resulting in space complexity of O(*semaphore-slots* + *pending-jobs*) instead of O(*semaphore-slots*).
 - __Graceful Termination__: Await the completion of all currently executing jobs via the `waitForAllExecutingJobsToComplete` method.
-- __High Efficiency__: All state-altering operations have a constant time complexity, O(1).
-- __Comprehensive documentation__: The class is thoroughly documented, enabling IDEs to provide helpful tooltips that enhance the coding experience.
+- __High Efficiency :gear:__: All state-altering operations have a constant time complexity, O(1).
+- __Comprehensive documentation :books:__: The class is thoroughly documented, enabling IDEs to provide helpful tooltips that enhance the coding experience.
 - __Robust Error Handling__: Uncaught errors from background jobs triggered by `startExecution` are captured and can be accessed using the `extractUncaughtErrors` method.
 - **Fully covered** by rigorous unit tests.
 - Self-explanatory method names.

dist/zero-backpressure-semaphore.d.ts

@@ -80,14 +80,21 @@ export declare class ZeroBackpressureSemaphore<T, UncaughtErrorType = Error> {
     /**
      * startExecution
      *
-     * This method resolves once the given job has started its execution, indicating that the
+     * This method resolves once the given job has *started* its execution, indicating that the
      * semaphore has become available (i.e., allotted a slot for the job).
-     * Users can leverage this to determine the start timestamp of a job. If the semaphore is too busy
-     * to start a given job `X`, there is no reason to create another job `Y` until `X` has started.
+     * Users can leverage this to prevent backpressure of pending jobs:
+     * If the semaphore is too busy to start a given job `X`, there is no reason to create another
+     * job `Y` until `X` has started.
      *
      * This method is particularly useful for executing multiple or background jobs, where no return
-     * value is expected.
+     * value is expected. It promotes a just-in-time approach, on which each job is pending execution
+     * only when no other job is, thereby eliminating backpressure and reducing memory footprint.
      *
+     * ### Graceful Termination
+     * Method `waitForAllExecutingJobsToComplete` complements the typical use-cases of `startExecution`.
+     * It can be used to perform post-processing, after all the currently-executing jobs have completed.
+     *
+     * ### Error Handling
      * If the job throws an error, it is captured by the semaphore and can be accessed via the
      * `extractUncaughtError` method. Users are encouraged to specify a custom `UncaughtErrorType`
      * generic parameter to the class if jobs may throw errors.
@@ -100,11 +107,11 @@ export declare class ZeroBackpressureSemaphore<T, UncaughtErrorType = Error> {
      * waitForCompletion
      *
      * This method executes the given job in a controlled manner, once the semaphore is available.
-     * It resolves or rejects when the job has finished its execution, providing the returned value
-     * or thrown error from the job.
+     * It resolves or rejects when the job finishes execution, returning the job's value or propagating
+     * any error it may throw.
      *
-     * This method is useful when the flow depends on the job's execution, such as needing its return
-     * value or handling any errors it may throw.
+     * This method is useful when the flow depends on a job's execution to proceed, such as needing
+     * its return value or handling any errors it may throw.
      *
      * ### Example Use Case
      * Suppose you have a route handler that needs to perform a specific code block with limited

dist/zero-backpressure-semaphore.js

@@ -1,6 +1,6 @@
 {
   "name": "zero-backpressure-semaphore-typescript",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "A classic semaphore with modern API, inspired by the RAII idiom. Offering backpressure control for enhanced efficiency, utilizing a communicative API that signals availability. Additionally, it incorporates mechanisms for graceful termination and error handling, making it suitable for complex scenarios.",
   "repository": {
     "type": "git",

dist/zero-backpressure-semaphore.js.map

@@ -125,14 +125,21 @@ export class ZeroBackpressureSemaphore<T, UncaughtErrorType = Error> {
     /**
      * startExecution
      * 
-     * This method resolves once the given job has started its execution, indicating that the
+     * This method resolves once the given job has *started* its execution, indicating that the
      * semaphore has become available (i.e., allotted a slot for the job).
-     * Users can leverage this to determine the start timestamp of a job. If the semaphore is too busy
-     * to start a given job `X`, there is no reason to create another job `Y` until `X` has started.
+     * Users can leverage this to prevent backpressure of pending jobs:
+     * If the semaphore is too busy to start a given job `X`, there is no reason to create another
+     * job `Y` until `X` has started.
      * 
      * This method is particularly useful for executing multiple or background jobs, where no return
-     * value is expected.
+     * value is expected. It promotes a just-in-time approach, on which each job is pending execution
+     * only when no other job is, thereby eliminating backpressure and reducing memory footprint.
      * 
+     * ### Graceful Termination
+     * Method `waitForAllExecutingJobsToComplete` complements the typical use-cases of `startExecution`.
+     * It can be used to perform post-processing, after all the currently-executing jobs have completed.
+     * 
+     * ### Error Handling
      * If the job throws an error, it is captured by the semaphore and can be accessed via the
      * `extractUncaughtError` method. Users are encouraged to specify a custom `UncaughtErrorType`
      * generic parameter to the class if jobs may throw errors.
@@ -150,11 +157,11 @@ export class ZeroBackpressureSemaphore<T, UncaughtErrorType = Error> {
      * waitForCompletion
      * 
      * This method executes the given job in a controlled manner, once the semaphore is available. 
-     * It resolves or rejects when the job has finished its execution, providing the returned value
-     * or thrown error from the job.
+     * It resolves or rejects when the job finishes execution, returning the job's value or propagating
+     * any error it may throw.
      * 
-     * This method is useful when the flow depends on the job's execution, such as needing its return
-     * value or handling any errors it may throw.
+     * This method is useful when the flow depends on a job's execution to proceed, such as needing
+     * its return value or handling any errors it may throw.
      * 
      * ### Example Use Case
      * Suppose you have a route handler that needs to perform a specific code block with limited