@ls-stack/utils 3.27.2 → 3.29.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/docs/retryOnError/-internal-.md

@@ -14,7 +14,7 @@
 type RetryOptions = object;
 ```
 
-Defined in: [packages/utils/src/retryOnError.ts:6](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L6)
+Defined in: [packages/utils/src/retryOnError.ts:7](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L7)
 
 Configuration options for retryOnError function.
 
@@ -26,7 +26,7 @@ Configuration options for retryOnError function.
 optional debugId: string;
 ```
 
-Defined in: [packages/utils/src/retryOnError.ts:15](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L15)
+Defined in: [packages/utils/src/retryOnError.ts:16](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L16)
 
 Optional ID for debug logging
 
@@ -36,17 +36,27 @@ Optional ID for debug logging
 optional delayBetweenRetriesMs: number | (retry) => number;
 ```
 
-Defined in: [packages/utils/src/retryOnError.ts:8](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L8)
+Defined in: [packages/utils/src/retryOnError.ts:9](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L9)
 
 Delay between retries in milliseconds or function returning delay
 
+##### disableRetries?
+
+```ts
+optional disableRetries: boolean;
+```
+
+Defined in: [packages/utils/src/retryOnError.ts:18](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L18)
+
+Disable retries
+
 ##### retryCondition()?
 
 ```ts
 optional retryCondition: (error, lastAttempt) => boolean;
 ```
 
-Defined in: [packages/utils/src/retryOnError.ts:10](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L10)
+Defined in: [packages/utils/src/retryOnError.ts:11](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L11)
 
 Function to determine if retry should happen, receives error and duration of last attempt
 
@@ -54,7 +64,7 @@ Function to determine if retry should happen, receives error and duration of las
 
 ###### error
 
-`unknown`
+`Error`
 
 ###### lastAttempt
 

package/docs/retryOnError/README.md

@@ -23,7 +23,7 @@ function retryOnError<T>(
 originalMaxRetries): Promise<T>;
 ```
 
-Defined in: [packages/utils/src/retryOnError.ts:38](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L38)
+Defined in: [packages/utils/src/retryOnError.ts:41](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L41)
 
 Retries a function on error with configurable retry logic.
 
@@ -57,10 +57,14 @@ Configuration options
 
 `number` = `0`
 
+internal use only
+
 ##### originalMaxRetries
 
 `number` = `maxRetries`
 
+internal use only
+
 #### Returns
 
 `Promise`\<`T`\>
@@ -79,3 +83,82 @@ await retryOnError(
   { delayBetweenRetriesMs: 1000 }
 );
 ```
+
+***
+
+### retryResultOnError()
+
+```ts
+function retryResultOnError<T, E>(
+   fn, 
+   maxRetries, 
+   options, 
+   __retry, 
+__originalMaxRetries): Promise<Result<T, E>>;
+```
+
+Defined in: [packages/utils/src/retryOnError.ts:116](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L116)
+
+Retries a result function on error with configurable retry logic.
+
+#### Type Parameters
+
+##### T
+
+`T`
+
+##### E
+
+`E` *extends* `ResultValidErrors`
+
+#### Parameters
+
+##### fn
+
+(`ctx`) => `Promise`\<`Result`\<`T`, `E`\>\>
+
+Function to retry that receives context with retry count
+
+##### maxRetries
+
+`number`
+
+Maximum number of retries
+
+##### options
+
+Configuration options
+
+###### debugId?
+
+`string`
+
+###### delayBetweenRetriesMs?
+
+`number` \| (`retry`) => `number`
+
+###### disableRetries?
+
+`boolean`
+
+###### retryCondition?
+
+(`error`, `lastAttempt`) => `boolean`
+
+##### \_\_retry
+
+`number` = `0`
+
+internal use only
+
+##### \_\_originalMaxRetries
+
+`number` = `maxRetries`
+
+internal use only
+
+#### Returns
+
+`Promise`\<`Result`\<`T`, `E`\>\>
+
+Promise resolving to the function result or rejecting with the final error

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/lib/retryOnError.cjs

@@ -20,9 +20,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/retryOnError.ts
 var retryOnError_exports = {};
 __export(retryOnError_exports, {
-  retryOnError: () => retryOnError
+  retryOnError: () => retryOnError,
+  retryResultOnError: () => retryResultOnError
 });
 module.exports = __toCommonJS(retryOnError_exports);
+var import_t_result = require("t-result");
 
 // src/sleep.ts
 function sleep(ms) {
@@ -31,7 +33,7 @@ function sleep(ms) {
 
 // src/retryOnError.ts
 async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMaxRetries = maxRetries) {
-  const { delayBetweenRetriesMs, retryCondition } = options;
+  const { delayBetweenRetriesMs, retryCondition, disableRetries } = options;
   if (options.debugId) {
     if (retry > 0) {
       console.info(
@@ -43,9 +45,12 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
   try {
     return await fn({ retry });
   } catch (error) {
-    if (maxRetries > 0) {
+    if (maxRetries > 0 && !disableRetries) {
       const errorDuration = Date.now() - startTime;
-      const shouldRetry = retryCondition ? retryCondition(error, { duration: errorDuration, retry }) : true;
+      const shouldRetry = retryCondition ? retryCondition((0, import_t_result.unknownToError)(error), {
+        duration: errorDuration,
+        retry
+      }) : true;
       if (!shouldRetry) {
         throw error;
       }
@@ -66,7 +71,47 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
     }
   }
 }
+async function retryResultOnError(fn, maxRetries, options = {}, __retry = 0, __originalMaxRetries = maxRetries) {
+  const { delayBetweenRetriesMs, retryCondition } = options;
+  if (options.debugId) {
+    if (__retry > 0) {
+      console.info(
+        `Retrying ${options.debugId} (retry ${__retry}/${__originalMaxRetries}) after error`
+      );
+    }
+  }
+  const startTime = Date.now();
+  const result = await fn({ retry: __retry });
+  if (result.ok) {
+    return result;
+  }
+  if (maxRetries > 0 && !options.disableRetries) {
+    const errorDuration = Date.now() - startTime;
+    const shouldRetry = retryCondition ? retryCondition(result.error, {
+      duration: errorDuration,
+      retry: __retry
+    }) : true;
+    if (!shouldRetry) {
+      return result;
+    }
+    if (delayBetweenRetriesMs) {
+      await sleep(
+        typeof delayBetweenRetriesMs === "function" ? delayBetweenRetriesMs(__retry) : delayBetweenRetriesMs
+      );
+    }
+    return retryResultOnError(
+      fn,
+      maxRetries - 1,
+      options,
+      __retry + 1,
+      __originalMaxRetries
+    );
+  } else {
+    return result;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  retryOnError
+  retryOnError,
+  retryResultOnError
 });

package/lib/retryOnError.d.cts

@@ -1,3 +1,5 @@
+import { ResultValidErrors, Result } from 't-result';
+
 /**
  * Configuration options for retryOnError function.
  */
@@ -5,12 +7,14 @@ type RetryOptions = {
     /** Delay between retries in milliseconds or function returning delay */
     delayBetweenRetriesMs?: number | ((retry: number) => number);
     /** Function to determine if retry should happen, receives error and duration of last attempt */
-    retryCondition?: (error: unknown, lastAttempt: {
+    retryCondition?: (error: Error, lastAttempt: {
         duration: number;
         retry: number;
     }) => boolean;
     /** Optional ID for debug logging */
     debugId?: string;
+    /** Disable retries */
+    disableRetries?: boolean;
 };
 /**
  * Retries a function on error with configurable retry logic.
@@ -18,8 +22,8 @@ type RetryOptions = {
  * @param fn - Function to retry that receives context with retry count
  * @param maxRetries - Maximum number of retries
  * @param options - Configuration options
- * @param retry
- * @param originalMaxRetries
+ * @param retry - internal use only
+ * @param originalMaxRetries - internal use only
  * @returns Promise resolving to the function result or rejecting with the final error
  *
  * @example
@@ -36,5 +40,31 @@ declare function retryOnError<T>(fn: (ctx: {
     /** Current retry count, (0 for first attempt) */
     retry: number;
 }) => Promise<T>, maxRetries: number, options?: RetryOptions, retry?: number, originalMaxRetries?: number): Promise<T>;
+/**
+ * Retries a result function on error with configurable retry logic.
+ *
+ * @param fn - Function to retry that receives context with retry count
+ * @param maxRetries - Maximum number of retries
+ * @param options - Configuration options
+ * @param options.delayBetweenRetriesMs
+ * @param options.retryCondition
+ * @param options.debugId
+ * @param options.disableRetries
+ * @param __retry - internal use only
+ * @param __originalMaxRetries - internal use only
+ * @returns Promise resolving to the function result or rejecting with the final error
+ */
+declare function retryResultOnError<T, E extends ResultValidErrors>(fn: (ctx: {
+    /** Current retry count, (0 for first attempt) */
+    retry: number;
+}) => Promise<Result<T, E>>, maxRetries: number, options?: {
+    delayBetweenRetriesMs?: number | ((retry: number) => number);
+    retryCondition?: (error: E, lastAttempt: {
+        duration: number;
+        retry: number;
+    }) => boolean;
+    debugId?: string;
+    disableRetries?: boolean;
+}, __retry?: number, __originalMaxRetries?: number): Promise<Result<T, E>>;
 
-export { retryOnError };
+export { retryOnError, retryResultOnError };

package/lib/retryOnError.d.ts

@@ -1,3 +1,5 @@
+import { ResultValidErrors, Result } from 't-result';
+
 /**
  * Configuration options for retryOnError function.
  */
@@ -5,12 +7,14 @@ type RetryOptions = {
     /** Delay between retries in milliseconds or function returning delay */
     delayBetweenRetriesMs?: number | ((retry: number) => number);
     /** Function to determine if retry should happen, receives error and duration of last attempt */
-    retryCondition?: (error: unknown, lastAttempt: {
+    retryCondition?: (error: Error, lastAttempt: {
         duration: number;
         retry: number;
     }) => boolean;
     /** Optional ID for debug logging */
     debugId?: string;
+    /** Disable retries */
+    disableRetries?: boolean;
 };
 /**
  * Retries a function on error with configurable retry logic.
@@ -18,8 +22,8 @@ type RetryOptions = {
  * @param fn - Function to retry that receives context with retry count
  * @param maxRetries - Maximum number of retries
  * @param options - Configuration options
- * @param retry
- * @param originalMaxRetries
+ * @param retry - internal use only
+ * @param originalMaxRetries - internal use only
  * @returns Promise resolving to the function result or rejecting with the final error
  *
  * @example
@@ -36,5 +40,31 @@ declare function retryOnError<T>(fn: (ctx: {
     /** Current retry count, (0 for first attempt) */
     retry: number;
 }) => Promise<T>, maxRetries: number, options?: RetryOptions, retry?: number, originalMaxRetries?: number): Promise<T>;
+/**
+ * Retries a result function on error with configurable retry logic.
+ *
+ * @param fn - Function to retry that receives context with retry count
+ * @param maxRetries - Maximum number of retries
+ * @param options - Configuration options
+ * @param options.delayBetweenRetriesMs
+ * @param options.retryCondition
+ * @param options.debugId
+ * @param options.disableRetries
+ * @param __retry - internal use only
+ * @param __originalMaxRetries - internal use only
+ * @returns Promise resolving to the function result or rejecting with the final error
+ */
+declare function retryResultOnError<T, E extends ResultValidErrors>(fn: (ctx: {
+    /** Current retry count, (0 for first attempt) */
+    retry: number;
+}) => Promise<Result<T, E>>, maxRetries: number, options?: {
+    delayBetweenRetriesMs?: number | ((retry: number) => number);
+    retryCondition?: (error: E, lastAttempt: {
+        duration: number;
+        retry: number;
+    }) => boolean;
+    debugId?: string;
+    disableRetries?: boolean;
+}, __retry?: number, __originalMaxRetries?: number): Promise<Result<T, E>>;
 
-export { retryOnError };
+export { retryOnError, retryResultOnError };

package/lib/retryOnError.js

@@ -3,8 +3,9 @@ import {
 } from "./chunk-5DZT3Z5Z.js";
 
 // src/retryOnError.ts
+import { unknownToError } from "t-result";
 async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMaxRetries = maxRetries) {
-  const { delayBetweenRetriesMs, retryCondition } = options;
+  const { delayBetweenRetriesMs, retryCondition, disableRetries } = options;
   if (options.debugId) {
     if (retry > 0) {
       console.info(
@@ -16,9 +17,12 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
   try {
     return await fn({ retry });
   } catch (error) {
-    if (maxRetries > 0) {
+    if (maxRetries > 0 && !disableRetries) {
       const errorDuration = Date.now() - startTime;
-      const shouldRetry = retryCondition ? retryCondition(error, { duration: errorDuration, retry }) : true;
+      const shouldRetry = retryCondition ? retryCondition(unknownToError(error), {
+        duration: errorDuration,
+        retry
+      }) : true;
       if (!shouldRetry) {
         throw error;
       }
@@ -39,6 +43,46 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
     }
   }
 }
+async function retryResultOnError(fn, maxRetries, options = {}, __retry = 0, __originalMaxRetries = maxRetries) {
+  const { delayBetweenRetriesMs, retryCondition } = options;
+  if (options.debugId) {
+    if (__retry > 0) {
+      console.info(
+        `Retrying ${options.debugId} (retry ${__retry}/${__originalMaxRetries}) after error`
+      );
+    }
+  }
+  const startTime = Date.now();
+  const result = await fn({ retry: __retry });
+  if (result.ok) {
+    return result;
+  }
+  if (maxRetries > 0 && !options.disableRetries) {
+    const errorDuration = Date.now() - startTime;
+    const shouldRetry = retryCondition ? retryCondition(result.error, {
+      duration: errorDuration,
+      retry: __retry
+    }) : true;
+    if (!shouldRetry) {
+      return result;
+    }
+    if (delayBetweenRetriesMs) {
+      await sleep(
+        typeof delayBetweenRetriesMs === "function" ? delayBetweenRetriesMs(__retry) : delayBetweenRetriesMs
+      );
+    }
+    return retryResultOnError(
+      fn,
+      maxRetries - 1,
+      options,
+      __retry + 1,
+      __originalMaxRetries
+    );
+  } else {
+    return result;
+  }
+}
 export {
-  retryOnError
+  retryOnError,
+  retryResultOnError
 };

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.29.0",
   "license": "MIT",
   "files": [
     "lib",