@ls-stack/utils 3.27.2 → 3.28.0

package/docs/concurrentCalls/-internal-.md

@@ -10,7 +10,7 @@
 
 ### ConcurrentCalls\<R, E\>
 
-Defined in: [packages/utils/src/concurrentCalls.ts:31](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L31)
+Defined in: [packages/utils/src/concurrentCalls.ts:124](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L124)
 
 #### Type Parameters
 
@@ -42,7 +42,7 @@ new ConcurrentCalls<R, E>(): ConcurrentCalls<R, E>;
 add(...calls): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:35](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L35)
+Defined in: [packages/utils/src/concurrentCalls.ts:128](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L128)
 
 ###### Parameters
 
@@ -60,7 +60,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:35](https://github.com/lucaso
 resultifyAdd(...calls): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:41](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L41)
+Defined in: [packages/utils/src/concurrentCalls.ts:134](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L134)
 
 ###### Parameters
 
@@ -78,7 +78,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:41](https://github.com/lucaso
 runAll(__namedParameters): Promise<Result<R[], E>>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:58](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L58)
+Defined in: [packages/utils/src/concurrentCalls.ts:151](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L151)
 
 ###### Parameters
 
@@ -94,7 +94,8 @@ Defined in: [packages/utils/src/concurrentCalls.ts:58](https://github.com/lucaso
 
 ```ts
 runAllSettled(__namedParameters): Promise<{
-  aggregatedError: null | AggregateError;
+  aggregatedError:   | null
+     | ConcurrentCallsAggregateError;
   allFailed: boolean;
   failures: E[];
   succeeded: R[];
@@ -102,7 +103,7 @@ runAllSettled(__namedParameters): Promise<{
 }>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:90](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L90)
+Defined in: [packages/utils/src/concurrentCalls.ts:183](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L183)
 
 ###### Parameters
 
@@ -113,7 +114,8 @@ Defined in: [packages/utils/src/concurrentCalls.ts:90](https://github.com/lucaso
 ###### Returns
 
 `Promise`\<\{
-  `aggregatedError`: `null` \| `AggregateError`;
+  `aggregatedError`:   \| `null`
+     \| [`ConcurrentCallsAggregateError`](README.md#concurrentcallsaggregateerror);
   `allFailed`: `boolean`;
   `failures`: `E`[];
   `succeeded`: `R`[];
@@ -124,7 +126,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:90](https://github.com/lucaso
 
 ### ConcurrentCallsWithMetadata\<M, R, E\>
 
-Defined in: [packages/utils/src/concurrentCalls.ts:157](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L157)
+Defined in: [packages/utils/src/concurrentCalls.ts:250](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L250)
 
 #### Type Parameters
 
@@ -160,7 +162,7 @@ new ConcurrentCallsWithMetadata<M, R, E>(): ConcurrentCallsWithMetadata<M, R, E>
 add(...calls): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:165](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L165)
+Defined in: [packages/utils/src/concurrentCalls.ts:258](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L258)
 
 ###### Parameters
 
@@ -178,7 +180,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:165](https://github.com/lucas
 resultifyAdd(...items): this;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:179](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L179)
+Defined in: [packages/utils/src/concurrentCalls.ts:272](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L272)
 
 ###### Parameters
 
@@ -196,7 +198,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:179](https://github.com/lucas
 runAll(__namedParameters): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:199](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L199)
+Defined in: [packages/utils/src/concurrentCalls.ts:292](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L292)
 
 ###### Parameters
 
@@ -212,7 +214,8 @@ Defined in: [packages/utils/src/concurrentCalls.ts:199](https://github.com/lucas
 
 ```ts
 runAllSettled(__namedParameters): Promise<{
-  aggregatedError: null | AggregateError;
+  aggregatedError:   | null
+     | ConcurrentCallsWithMetadataAggregateError<M>;
   allFailed: boolean;
   failed: FailedCall<M, E>[];
   failures: FailedCall<M, E>[];
@@ -222,7 +225,7 @@ runAllSettled(__namedParameters): Promise<{
 }>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:246](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L246)
+Defined in: [packages/utils/src/concurrentCalls.ts:339](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L339)
 
 ###### Parameters
 
@@ -233,7 +236,8 @@ Defined in: [packages/utils/src/concurrentCalls.ts:246](https://github.com/lucas
 ###### Returns
 
 `Promise`\<\{
-  `aggregatedError`: `null` \| `AggregateError`;
+  `aggregatedError`:   \| `null`
+     \| [`ConcurrentCallsWithMetadataAggregateError`](README.md#concurrentcallswithmetadataaggregateerror)\<`M`\>;
   `allFailed`: `boolean`;
   `failed`: [`FailedCall`](#failedcall)\<`M`, `E`\>[];
   `failures`: [`FailedCall`](#failedcall)\<`M`, `E`\>[];
@@ -250,7 +254,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:246](https://github.com/lucas
 type Action<R, E> = () => Promise<Result<R, E>>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:24](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L24)
+Defined in: [packages/utils/src/concurrentCalls.ts:117](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L117)
 
 #### Type Parameters
 
@@ -274,7 +278,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:24](https://github.com/lucaso
 type FailedCall<M, E> = object;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:19](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L19)
+Defined in: [packages/utils/src/concurrentCalls.ts:112](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L112)
 
 #### Type Parameters
 
@@ -294,7 +298,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:19](https://github.com/lucaso
 error: E;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:21](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L21)
+Defined in: [packages/utils/src/concurrentCalls.ts:114](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L114)
 
 ##### metadata
 
@@ -302,7 +306,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:21](https://github.com/lucaso
 metadata: M;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:20](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L20)
+Defined in: [packages/utils/src/concurrentCalls.ts:113](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L113)
 
 ***
 
@@ -312,7 +316,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:20](https://github.com/lucaso
 type RunProps = object;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:10](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L10)
+Defined in: [packages/utils/src/concurrentCalls.ts:103](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L103)
 
 #### Properties
 
@@ -322,7 +326,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:10](https://github.com/lucaso
 optional delayStart: (index) => number;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:11](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L11)
+Defined in: [packages/utils/src/concurrentCalls.ts:104](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L104)
 
 ###### Parameters
 
@@ -353,7 +357,7 @@ type SettledResultWithMetadata<R, M, E> =
 };
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:27](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L27)
+Defined in: [packages/utils/src/concurrentCalls.ts:120](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L120)
 
 #### Type Parameters
 
@@ -377,7 +381,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:27](https://github.com/lucaso
 type SucceededCall<R, M> = object;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:15](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L15)
+Defined in: [packages/utils/src/concurrentCalls.ts:108](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L108)
 
 #### Type Parameters
 
@@ -397,7 +401,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:15](https://github.com/lucaso
 metadata: M;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:17](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L17)
+Defined in: [packages/utils/src/concurrentCalls.ts:110](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L110)
 
 ##### value
 
@@ -405,7 +409,7 @@ Defined in: [packages/utils/src/concurrentCalls.ts:17](https://github.com/lucaso
 value: R;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:16](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L16)
+Defined in: [packages/utils/src/concurrentCalls.ts:109](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L109)
 
 ***
 
@@ -415,4 +419,4 @@ Defined in: [packages/utils/src/concurrentCalls.ts:16](https://github.com/lucaso
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:8](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L8)
+Defined in: [packages/utils/src/concurrentCalls.ts:101](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L101)

package/docs/concurrentCalls/README.md

@@ -10,6 +10,190 @@
 
 - [\<internal\>](-internal-.md)
 
+## Classes
+
+### ConcurrentCallsAggregateError
+
+Defined in: [packages/utils/src/concurrentCalls.ts:32](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L32)
+
+#### Extends
+
+- `AggregateError`
+
+#### Constructors
+
+##### Constructor
+
+```ts
+new ConcurrentCallsAggregateError(
+   errors, 
+   total, 
+   failed): ConcurrentCallsAggregateError;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:37](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L37)
+
+###### Parameters
+
+###### errors
+
+`Error`[]
+
+###### total
+
+`number`
+
+###### failed
+
+`number`
+
+###### Returns
+
+[`ConcurrentCallsAggregateError`](#concurrentcallsaggregateerror)
+
+###### Overrides
+
+```ts
+AggregateError.constructor
+```
+
+#### Properties
+
+##### errors
+
+```ts
+errors: Error[] = [];
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:33](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L33)
+
+###### Overrides
+
+```ts
+AggregateError.errors
+```
+
+##### failed
+
+```ts
+failed: number = 0;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:35](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L35)
+
+##### total
+
+```ts
+total: number = 0;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:34](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L34)
+
+***
+
+### ConcurrentCallsWithMetadataAggregateError\<M\>
+
+Defined in: [packages/utils/src/concurrentCalls.ts:50](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L50)
+
+#### Extends
+
+- `AggregateError`
+
+#### Type Parameters
+
+##### M
+
+`M` *extends* [`ValidMetadata`](-internal-.md#validmetadata)
+
+#### Constructors
+
+##### Constructor
+
+```ts
+new ConcurrentCallsWithMetadataAggregateError<M>(
+   errors, 
+   total, 
+failed): ConcurrentCallsWithMetadataAggregateError<M>;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:58](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L58)
+
+###### Parameters
+
+###### errors
+
+`object`[]
+
+###### total
+
+`number`
+
+###### failed
+
+`number`
+
+###### Returns
+
+[`ConcurrentCallsWithMetadataAggregateError`](#concurrentcallswithmetadataaggregateerror)\<`M`\>
+
+###### Overrides
+
+```ts
+AggregateError.constructor
+```
+
+#### Properties
+
+##### errors
+
+```ts
+errors: Error[] = [];
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:53](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L53)
+
+###### Overrides
+
+```ts
+AggregateError.errors
+```
+
+##### errorsWithMetadata
+
+```ts
+errorsWithMetadata: object[] = [];
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:54](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L54)
+
+###### error
+
+```ts
+error: Error;
+```
+
+###### metadata
+
+```ts
+metadata: M;
+```
+
+##### failed
+
+```ts
+failed: number = 0;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:56](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L56)
+
+##### total
+
+```ts
+total: number = 0;
+```
+
+Defined in: [packages/utils/src/concurrentCalls.ts:55](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L55)
+
 ## Functions
 
 ### concurrentCalls()
@@ -18,7 +202,7 @@
 function concurrentCalls<R>(): ConcurrentCalls<R, Error>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:153](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L153)
+Defined in: [packages/utils/src/concurrentCalls.ts:246](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L246)
 
 Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
 
@@ -42,7 +226,7 @@ The type of the result value.
 function concurrentCallsWithMetadata<M, R>(): ConcurrentCallsWithMetadata<M, R, Error>;
 ```
 
-Defined in: [packages/utils/src/concurrentCalls.ts:345](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L345)
+Defined in: [packages/utils/src/concurrentCalls.ts:435](https://github.com/lucasols/utils/blob/main/packages/utils/src/concurrentCalls.ts#L435)
 
 Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
 

package/lib/concurrentCalls.cjs

@@ -20,6 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/concurrentCalls.ts
 var concurrentCalls_exports = {};
 __export(concurrentCalls_exports, {
+  ConcurrentCallsAggregateError: () => ConcurrentCallsAggregateError,
+  ConcurrentCallsWithMetadataAggregateError: () => ConcurrentCallsWithMetadataAggregateError,
   concurrentCalls: () => concurrentCalls,
   concurrentCallsWithMetadata: () => concurrentCallsWithMetadata
 });
@@ -70,6 +72,67 @@ function truncateString(str, length, ellipsis = "\u2026") {
 }
 
 // src/concurrentCalls.ts
+function formatErrorMessagesWithCounts(messages, failed, total) {
+  const errorMessageCounts = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    errorMessageCounts.set(message, (errorMessageCounts.get(message) || 0) + 1);
+  }
+  const formattedMessages = Array.from(errorMessageCounts.entries()).map(
+    ([message, count]) => count > 1 ? `${message} (${count}x)` : message
+  );
+  return `${failed}/${total} calls failed:
+${truncateArray(
+    formattedMessages,
+    5,
+    "..."
+  ).join("\n")}`;
+}
+var ConcurrentCallsAggregateError = class extends AggregateError {
+  errors = [];
+  total = 0;
+  failed = 0;
+  constructor(errors, total, failed) {
+    const messages = errors.map(
+      (error) => `- ${truncateString(error.message, 100)}`
+    );
+    const message = formatErrorMessagesWithCounts(messages, failed, total);
+    super(errors, message);
+    this.errors = errors;
+    this.total = total;
+    this.failed = failed;
+  }
+};
+var ConcurrentCallsWithMetadataAggregateError = class extends AggregateError {
+  errors = [];
+  errorsWithMetadata = [];
+  total = 0;
+  failed = 0;
+  constructor(errors, total, failed) {
+    const messages = errors.map(({ error, metadata }) => {
+      let metadataPrefix = typeof metadata === "string" || typeof metadata === "number" || typeof metadata === "boolean" ? `${metadata}: ` : "";
+      try {
+        const isArray = Array.isArray(metadata);
+        if (isObject(metadata) || isArray) {
+          const stringifiedMetadata = JSON.stringify(metadata);
+          if (stringifiedMetadata.length < 30) {
+            metadataPrefix = `${stringifiedMetadata}: `;
+          } else {
+            metadataPrefix = `[${isArray ? "Array" : "Object"} metadata]: `;
+          }
+        }
+      } catch (_) {
+      }
+      return `- ${metadataPrefix}${truncateString(error.message, 100)}`;
+    });
+    const message = formatErrorMessagesWithCounts(messages, failed, total);
+    const errorInstances = errors.map((e) => e.error);
+    super(errorInstances, message);
+    this.errors = errorInstances;
+    this.errorsWithMetadata = errors;
+    this.total = total;
+    this.failed = failed;
+  }
+};
 var ConcurrentCalls = class {
   #pendingCalls = [];
   #alreadyRun = false;
@@ -146,7 +209,7 @@ var ConcurrentCalls = class {
       }
     }
     const allFailed = failed.length === total;
-    const aggregatedError = failed.length > 0 ? new AggregateError(failed, "One or more calls failed") : null;
+    const aggregatedError = failed.length > 0 ? new ConcurrentCallsAggregateError(failed, total, failed.length) : null;
     this.#pendingCalls = [];
     return {
       succeeded,
@@ -272,13 +335,10 @@ var ConcurrentCallsWithMetadata = class {
       }
     }
     const allFailed = failedProcessing.length === total;
-    const aggregatedError = failedProcessing.length > 0 ? new AggregateError(
-      failedProcessing.map((f) => f.error),
-      `${failedProcessing.length}/${total} calls failed: ${truncateArray(
-        failedProcessing.map((f) => truncateString(f.error.message, 20)),
-        5,
-        "..."
-      ).join("; ")}`
+    const aggregatedError = failedProcessing.length > 0 ? new ConcurrentCallsWithMetadataAggregateError(
+      failedProcessing,
+      total,
+      failedProcessing.length
     ) : null;
     return {
       succeeded: succeededProcessing,
@@ -296,6 +356,8 @@ function concurrentCallsWithMetadata() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ConcurrentCallsAggregateError,
+  ConcurrentCallsWithMetadataAggregateError,
   concurrentCalls,
   concurrentCallsWithMetadata
 });

package/lib/concurrentCalls.d.cts

@@ -1,5 +1,24 @@
 import { Result } from 't-result';
 
+declare class ConcurrentCallsAggregateError extends AggregateError {
+    errors: Error[];
+    total: number;
+    failed: number;
+    constructor(errors: Error[], total: number, failed: number);
+}
+declare class ConcurrentCallsWithMetadataAggregateError<M extends ValidMetadata> extends AggregateError {
+    errors: Error[];
+    errorsWithMetadata: {
+        error: Error;
+        metadata: M;
+    }[];
+    total: number;
+    failed: number;
+    constructor(errors: {
+        error: Error;
+        metadata: M;
+    }[], total: number, failed: number);
+}
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 type RunProps = {
     delayStart?: (index: number) => number;
@@ -33,7 +52,7 @@ declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
         failures: E[];
         succeeded: R[];
         total: number;
-        aggregatedError: AggregateError | null;
+        aggregatedError: ConcurrentCallsAggregateError | null;
     }>;
 }
 /**
@@ -62,7 +81,7 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
         succeeded: SucceededCall<R, M>[];
         total: number;
         results: SettledResultWithMetadata<R, M, E>[];
-        aggregatedError: AggregateError | null;
+        aggregatedError: ConcurrentCallsWithMetadataAggregateError<M> | null;
     }>;
 }
 /**
@@ -74,4 +93,4 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
  */
 declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown>(): ConcurrentCallsWithMetadata<M, R, Error>;
 
-export { concurrentCalls, concurrentCallsWithMetadata };
+export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata };

package/lib/concurrentCalls.d.ts

@@ -1,5 +1,24 @@
 import { Result } from 't-result';
 
+declare class ConcurrentCallsAggregateError extends AggregateError {
+    errors: Error[];
+    total: number;
+    failed: number;
+    constructor(errors: Error[], total: number, failed: number);
+}
+declare class ConcurrentCallsWithMetadataAggregateError<M extends ValidMetadata> extends AggregateError {
+    errors: Error[];
+    errorsWithMetadata: {
+        error: Error;
+        metadata: M;
+    }[];
+    total: number;
+    failed: number;
+    constructor(errors: {
+        error: Error;
+        metadata: M;
+    }[], total: number, failed: number);
+}
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 type RunProps = {
     delayStart?: (index: number) => number;
@@ -33,7 +52,7 @@ declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
         failures: E[];
         succeeded: R[];
         total: number;
-        aggregatedError: AggregateError | null;
+        aggregatedError: ConcurrentCallsAggregateError | null;
     }>;
 }
 /**
@@ -62,7 +81,7 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
         succeeded: SucceededCall<R, M>[];
         total: number;
         results: SettledResultWithMetadata<R, M, E>[];
-        aggregatedError: AggregateError | null;
+        aggregatedError: ConcurrentCallsWithMetadataAggregateError<M> | null;
     }>;
 }
 /**
@@ -74,4 +93,4 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
  */
 declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown>(): ConcurrentCallsWithMetadata<M, R, Error>;
 
-export { concurrentCalls, concurrentCallsWithMetadata };
+export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata };

package/lib/concurrentCalls.js

@@ -11,11 +11,73 @@ import {
   invariant
 } from "./chunk-C2SVCIWE.js";
 import {
+  isObject,
   isPromise
 } from "./chunk-JF2MDHOJ.js";
 
 // src/concurrentCalls.ts
 import { Result, resultify, unknownToError } from "t-result";
+function formatErrorMessagesWithCounts(messages, failed, total) {
+  const errorMessageCounts = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    errorMessageCounts.set(message, (errorMessageCounts.get(message) || 0) + 1);
+  }
+  const formattedMessages = Array.from(errorMessageCounts.entries()).map(
+    ([message, count]) => count > 1 ? `${message} (${count}x)` : message
+  );
+  return `${failed}/${total} calls failed:
+${truncateArray(
+    formattedMessages,
+    5,
+    "..."
+  ).join("\n")}`;
+}
+var ConcurrentCallsAggregateError = class extends AggregateError {
+  errors = [];
+  total = 0;
+  failed = 0;
+  constructor(errors, total, failed) {
+    const messages = errors.map(
+      (error) => `- ${truncateString(error.message, 100)}`
+    );
+    const message = formatErrorMessagesWithCounts(messages, failed, total);
+    super(errors, message);
+    this.errors = errors;
+    this.total = total;
+    this.failed = failed;
+  }
+};
+var ConcurrentCallsWithMetadataAggregateError = class extends AggregateError {
+  errors = [];
+  errorsWithMetadata = [];
+  total = 0;
+  failed = 0;
+  constructor(errors, total, failed) {
+    const messages = errors.map(({ error, metadata }) => {
+      let metadataPrefix = typeof metadata === "string" || typeof metadata === "number" || typeof metadata === "boolean" ? `${metadata}: ` : "";
+      try {
+        const isArray = Array.isArray(metadata);
+        if (isObject(metadata) || isArray) {
+          const stringifiedMetadata = JSON.stringify(metadata);
+          if (stringifiedMetadata.length < 30) {
+            metadataPrefix = `${stringifiedMetadata}: `;
+          } else {
+            metadataPrefix = `[${isArray ? "Array" : "Object"} metadata]: `;
+          }
+        }
+      } catch (_) {
+      }
+      return `- ${metadataPrefix}${truncateString(error.message, 100)}`;
+    });
+    const message = formatErrorMessagesWithCounts(messages, failed, total);
+    const errorInstances = errors.map((e) => e.error);
+    super(errorInstances, message);
+    this.errors = errorInstances;
+    this.errorsWithMetadata = errors;
+    this.total = total;
+    this.failed = failed;
+  }
+};
 var ConcurrentCalls = class {
   #pendingCalls = [];
   #alreadyRun = false;
@@ -92,7 +154,7 @@ var ConcurrentCalls = class {
       }
     }
     const allFailed = failed.length === total;
-    const aggregatedError = failed.length > 0 ? new AggregateError(failed, "One or more calls failed") : null;
+    const aggregatedError = failed.length > 0 ? new ConcurrentCallsAggregateError(failed, total, failed.length) : null;
     this.#pendingCalls = [];
     return {
       succeeded,
@@ -218,13 +280,10 @@ var ConcurrentCallsWithMetadata = class {
       }
     }
     const allFailed = failedProcessing.length === total;
-    const aggregatedError = failedProcessing.length > 0 ? new AggregateError(
-      failedProcessing.map((f) => f.error),
-      `${failedProcessing.length}/${total} calls failed: ${truncateArray(
-        failedProcessing.map((f) => truncateString(f.error.message, 20)),
-        5,
-        "..."
-      ).join("; ")}`
+    const aggregatedError = failedProcessing.length > 0 ? new ConcurrentCallsWithMetadataAggregateError(
+      failedProcessing,
+      total,
+      failedProcessing.length
     ) : null;
     return {
       succeeded: succeededProcessing,
@@ -241,6 +300,8 @@ function concurrentCallsWithMetadata() {
   return new ConcurrentCallsWithMetadata();
 }
 export {
+  ConcurrentCallsAggregateError,
+  ConcurrentCallsWithMetadataAggregateError,
   concurrentCalls,
   concurrentCallsWithMetadata
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.27.2",
+  "version": "3.28.0",
   "license": "MIT",
   "files": [
     "lib",