go-go-try 7.4.0 → 7.4.1

package/README.md

@@ -408,15 +408,50 @@ const [errors, results] = await goTryAll([
 // - Limit expensive computation resources
 ```
 
-### `goTryAllRaw<T>(items, options?)`
+### `goTryAllRaw<T, E>(items, options?)`
 
 Like `goTryAll`, but returns raw Error objects instead of error messages.
+Non-tagged errors are wrapped in `UnknownError` by default (consistent with `goTryRaw`).
+Tagged errors pass through unchanged.
+
+Supports the same `errorClass` and `systemErrorClass` options as `goTryRaw`, plus `concurrency` control.
 
 ```ts
-function goTryAllRaw<T extends readonly unknown[]>(
+interface GoTryAllRawOptions<E> {
+  concurrency?: number
+  // errorClass and systemErrorClass are mutually exclusive
+  errorClass?: ErrorConstructor<E>        // Wrap ALL errors
+  systemErrorClass?: ErrorConstructor<E>  // Only wrap non-tagged errors
+}
+
+function goTryAllRaw<T extends readonly unknown[], E = UnknownError>(
   items: { [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) },
-  options?: GoTryAllOptions
-): Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]>
+  options?: GoTryAllRawOptions<E>
+): Promise<[{ [K in keyof T]: E | undefined }, { [K in keyof T]: T[K] | undefined }]>
+```
+
+**Example:**
+```ts
+const DatabaseError = taggedError('DatabaseError')
+
+// Default behavior - non-tagged errors wrapped in UnknownError
+const [errors1] = await goTryAllRaw([
+  fetchUser(1),
+  fetchUser(2),
+])
+
+// Wrap all errors in DatabaseError
+const [errors2] = await goTryAllRaw([
+  fetchUser(1),
+  fetchUser(2),
+], { errorClass: DatabaseError })
+
+// Combine concurrency control with errorClass
+const [errors3] = await goTryAllRaw([
+  () => fetchUser(1),
+  () => fetchUser(2),
+  () => fetchUser(3),
+], { concurrency: 2, errorClass: DatabaseError })
 ```
 
 ### `goTryOr<T>(value, defaultValue)`
@@ -591,6 +626,12 @@ type GoTryRawOptions<E> =
   | { errorClass: ErrorConstructor<E>; systemErrorClass?: never }
   | { errorClass?: never; systemErrorClass: ErrorConstructor<E> }
   | { errorClass?: never; systemErrorClass?: never }
+
+// Options for goTryAllRaw (includes concurrency + error class options)
+type GoTryAllRawOptions<E> =
+  | { concurrency?: number; errorClass: ErrorConstructor<E>; systemErrorClass?: never }
+  | { concurrency?: number; errorClass?: never; systemErrorClass: ErrorConstructor<E> }
+  | { concurrency?: number; errorClass?: never; systemErrorClass?: never }
 ```
 
 ## License

package/dist/index.cjs

@@ -63,7 +63,7 @@ function taggedError(tag) {
 
 const UnknownError = taggedError("UnknownError");
 
-function isTaggedError(err) {
+function isTaggedError$1(err) {
   return isError(err) && "_tag" in err && typeof err._tag === "string";
 }
 function goTryRaw(value, options) {
@@ -80,7 +80,7 @@ function goTryRaw(value, options) {
       return new errorClass(String(err));
     }
     if (actualSystemErrorClass) {
-      if (isTaggedError(err)) {
+      if (isTaggedError$1(err)) {
         return err;
       }
       if (err === void 0) {
@@ -119,6 +119,31 @@ function goTryOr(value, defaultValue) {
   }
 }
 
+function isTaggedError(err) {
+  return isError(err) && "_tag" in err && typeof err._tag === "string";
+}
+function wrapError(err, errorClass, systemErrorClass) {
+  if (errorClass) {
+    if (err === void 0) {
+      return new errorClass("undefined");
+    }
+    if (isError(err)) {
+      return new errorClass(err.message, { cause: err });
+    }
+    return new errorClass(String(err));
+  }
+  const actualSystemErrorClass = systemErrorClass ?? UnknownError;
+  if (isTaggedError(err)) {
+    return err;
+  }
+  if (err === void 0) {
+    return new actualSystemErrorClass("undefined");
+  }
+  if (isError(err)) {
+    return new actualSystemErrorClass(err.message, { cause: err });
+  }
+  return new actualSystemErrorClass(String(err));
+}
 async function runWithConcurrency(items, concurrency) {
   if (items.length === 0) {
     return [];
@@ -166,6 +191,7 @@ async function goTryAll(items, options) {
   return [errors, results];
 }
 async function goTryAllRaw(items, options) {
+  const { errorClass, systemErrorClass } = options || {};
   const settled = await runWithConcurrency(items, options?.concurrency ?? 0);
   const errors = [];
   const results = [];
@@ -176,7 +202,7 @@ async function goTryAllRaw(items, options) {
       results[i] = item.value;
     } else {
       const reason = item.reason;
-      errors[i] = isError(reason) ? reason : new Error(String(reason));
+      errors[i] = wrapError(reason, errorClass, systemErrorClass);
       results[i] = void 0;
     }
   }

package/dist/index.d.cts

@@ -42,6 +42,24 @@ type GoTryRawOptions<E = Error> = {
     errorClass?: never;
     systemErrorClass?: never;
 };
+/**
+ * Options for goTryAllRaw function.
+ * Includes concurrency control and error class options.
+ * errorClass and systemErrorClass are mutually exclusive.
+ */
+type GoTryAllRawOptions<E = Error> = {
+    concurrency?: number;
+    errorClass: ErrorConstructor<E>;
+    systemErrorClass?: never;
+} | {
+    concurrency?: number;
+    errorClass?: never;
+    systemErrorClass: ErrorConstructor<E>;
+} | {
+    concurrency?: number;
+    errorClass?: never;
+    systemErrorClass?: never;
+};
 /**
  * Creates a union type from multiple tagged error classes.
  *
@@ -227,18 +245,25 @@ declare function goTryAll<T extends readonly unknown[]>(items: {
 }]>;
 /**
  * Like `goTryAll`, but returns raw Error objects instead of error messages.
+ * Non-tagged errors are wrapped in `UnknownError` by default (consistent with `goTryRaw`).
+ * Tagged errors pass through unchanged.
+ *
+ * Supports `errorClass` and `systemErrorClass` options (mutually exclusive):
+ * - `errorClass`: Wrap ALL errors in the specified class
+ * - `systemErrorClass`: Only wrap non-tagged errors (defaults to UnknownError)
  *
  * @template T The tuple type of all promise results
+ * @template E The type of the error
  * @param {readonly [...{ [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) }]} items - Array of promises or factories
- * @param {GoTryAllOptions} options - Optional configuration
- * @returns {Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]>}
+ * @param {GoTryAllRawOptions<E>} options - Optional configuration
+ * @returns {Promise<[{ [K in keyof T]: E | undefined }, { [K in keyof T]: T[K] | undefined }]>}
  *          A tuple where the first element is a tuple of Error objects (or undefined) and
  *          the second element is a tuple of results (or undefined), preserving input order
  */
-declare function goTryAllRaw<T extends readonly unknown[]>(items: {
+declare function goTryAllRaw<T extends readonly unknown[], E = InstanceType<typeof UnknownError>>(items: {
     [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>);
-}, options?: GoTryAllOptions): Promise<[{
-    [K in keyof T]: Error | undefined;
+}, options?: GoTryAllRawOptions<E>): Promise<[{
+    [K in keyof T]: E | undefined;
 }, {
     [K in keyof T]: T[K] | undefined;
 }]>;
@@ -351,5 +376,5 @@ declare function failure<E>(error: E): Failure<E>;
 declare function assertNever(value: never): never;
 
 export { UnknownError, assert, assertNever, failure, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };
-export type { ErrorConstructor, Failure, GoTryAllOptions, GoTryRawOptions, MaybePromise, Result, ResultWithDefault, Success, TaggedError, TaggedUnion };
+export type { ErrorConstructor, Failure, GoTryAllOptions, GoTryAllRawOptions, GoTryRawOptions, MaybePromise, Result, ResultWithDefault, Success, TaggedError, TaggedUnion };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sources":["../src/types.ts","../src/goTry.ts","../src/unknown-error.ts","../src/goTryRaw.ts","../src/goTryOr.ts","../src/goTryAll.ts","../src/tagged-error.ts","../src/assert.ts","../src/result-helpers.ts"],"mappings":"AAAA;;;AAIM,KAAM,OAAO;AACb,KAAM,OAAO;AACb,KAAM,MAAM,SAAS,OAAO,MAAM,OAAO;AAEzC,KAAM,iBAAiB;AAEvB,KAAM,YAAY,UAAU,OAAO;AAEzC;;;;AAIM,UAAW,WAAW;;;;;AAMtB,UAAW,eAAe;;;;;;;AAQhC;;;AAGM,KAAM,gBAAgB;;;AAO5B;;;;AAIM,KAAM,eAAe,KAAK,KAAK;gBACnB,gBAAgB;;;;sBACU,gBAAgB;;;;;AAG5D;;;;;;;;;;;;;AAaM,KAAM,WAAW,oBAAoB,gBAAgB;iCAC1B,gBAAgB;;;AC3DjD;;;;;;;;;;;;;;;;;;;;AAoBA,iBAAgB,KAAK,sBAAsB,MAAM;AACjD,iBAAgB,KAAK,cAAc,OAAO,MAAM,OAAO,CAAC,MAAM;AAC9D,iBAAgB,KAAK,aAAa,OAAO,MAAM,OAAO,CAAC,MAAM;AAC7D,iBAAgB,KAAK,kBAAkB,MAAM;AAC7C,iBAAgB,KAAK,eAAe,MAAM;;AC1B1C;;;;;;;;;;;;;;;;;AAiBA,cAAa,YAAY;;;;;;;;;;;;;ACPzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,iBAAgB,QAAQ,sBAAsB,MAAM,CAAC,KAAK;AAC1D,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,6BAA6B,eAAe,MAAM,MAAM;AACxH,iBAAgB,QAAQ,cACZ,OAAO,MAChB,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,aACpD,OAAO,cACR,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,aACb,OAAO,MACf,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,YACrD,OAAO,cACP,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,kBAAkB,MAAM,CAAC,KAAK;AACtD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,yBAAyB,eAAe,MAAM,MAAM;AACpH,iBAAgB,QAAQ,eAAe,MAAM,CAAC,KAAK;AACnD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,sBAAsB,eAAe,MAAM,MAAM;;AC5DjH;;;;;;;;;;;;;;;;;;;;;AAqBA,iBAAgB,OAAO,mDAAmD,iBAAiB;AAC3F,iBAAgB,OAAO,cACX,OAAO,mCAEhB,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,aACZ,OAAO,mCAEf,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,+CAA+C,iBAAiB;AACvF,iBAAgB,OAAO,4CAA4C,iBAAiB;;ACgBpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,iBAAsB,QAAQ;oBACH,OAAO,gBAAgB,OAAO;aAC7C,eAAe,GACxB,OAAO;;;;;AAoBV;;;;;;;;;;AAUA,iBAAsB,WAAW;oBACN,OAAO,gBAAgB,OAAO;aAC7C,eAAe,GACxB,OAAO;oBAAoB,KAAK;;;;;ACrHnC;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,iBAAgB,WAAW;;;;;;;;;;;;;AC1B3B;;;;;;;;;;;;;;;;;;;;;;AAsBA,iBAAgB,MAAM,4BAA4B,KAAK;AAEvD;;;;;;;;;;;;;;AAcA,iBAAgB,MAAM,WAAW,KAAK;;ACpCtC,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,OAAO,eAAe,OAAO;AAI7C,iBAAgB,OAAO,eAAe,OAAO;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,iBAAgB,WAAW","names":[]}
+{"version":3,"file":"index.d.cts","sources":["../src/types.ts","../src/goTry.ts","../src/unknown-error.ts","../src/goTryRaw.ts","../src/goTryOr.ts","../src/goTryAll.ts","../src/tagged-error.ts","../src/assert.ts","../src/result-helpers.ts"],"mappings":"AAAA;;;AAIM,KAAM,OAAO;AACb,KAAM,OAAO;AACb,KAAM,MAAM,SAAS,OAAO,MAAM,OAAO;AAEzC,KAAM,iBAAiB;AAEvB,KAAM,YAAY,UAAU,OAAO;AAEzC;;;;AAIM,UAAW,WAAW;;;;;AAMtB,UAAW,eAAe;;;;;;;AAQhC;;;AAGM,KAAM,gBAAgB;;;AAO5B;;;;AAIM,KAAM,eAAe,KAAK,KAAK;gBACnB,gBAAgB;;;;sBACU,gBAAgB;;;;;AAG5D;;;;;AAKM,KAAM,kBAAkB,KAAK,KAAK;;gBACA,gBAAgB;;;;;sBACU,gBAAgB;;;;;;AAGlF;;;;;;;;;;;;;AAaM,KAAM,WAAW,oBAAoB,gBAAgB;iCAC1B,gBAAgB;;;ACrEjD;;;;;;;;;;;;;;;;;;;;AAoBA,iBAAgB,KAAK,sBAAsB,MAAM;AACjD,iBAAgB,KAAK,cAAc,OAAO,MAAM,OAAO,CAAC,MAAM;AAC9D,iBAAgB,KAAK,aAAa,OAAO,MAAM,OAAO,CAAC,MAAM;AAC7D,iBAAgB,KAAK,kBAAkB,MAAM;AAC7C,iBAAgB,KAAK,eAAe,MAAM;;AC1B1C;;;;;;;;;;;;;;;;;AAiBA,cAAa,YAAY;;;;;;;;;;;;;ACPzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,iBAAgB,QAAQ,sBAAsB,MAAM,CAAC,KAAK;AAC1D,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,6BAA6B,eAAe,MAAM,MAAM;AACxH,iBAAgB,QAAQ,cACZ,OAAO,MAChB,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,aACpD,OAAO,cACR,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,aACb,OAAO,MACf,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,YACrD,OAAO,cACP,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,kBAAkB,MAAM,CAAC,KAAK;AACtD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,yBAAyB,eAAe,MAAM,MAAM;AACpH,iBAAgB,QAAQ,eAAe,MAAM,CAAC,KAAK;AACnD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,sBAAsB,eAAe,MAAM,MAAM;;AC5DjH;;;;;;;;;;;;;;;;;;;;;AAqBA,iBAAgB,OAAO,mDAAmD,iBAAiB;AAC3F,iBAAgB,OAAO,cACX,OAAO,mCAEhB,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,aACZ,OAAO,mCAEf,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,+CAA+C,iBAAiB;AACvF,iBAAgB,OAAO,4CAA4C,iBAAiB;;ACsDpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,iBAAsB,QAAQ;oBACH,OAAO,gBAAgB,OAAO;aAC7C,eAAe,GACxB,OAAO;;;;;AAoBV;;;;;;;;;;;;;;;;;AAiBA,iBAAsB,WAAW,mCAAmC,YAAY,QAAQ,YAAY;oBACzE,OAAO,gBAAgB,OAAO;aAC7C,kBAAkB,MAC3B,OAAO;;;;;;AClKV;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,iBAAgB,WAAW;;;;;;;;;;;;;AC1B3B;;;;;;;;;;;;;;;;;;;;;;AAsBA,iBAAgB,MAAM,4BAA4B,KAAK;AAEvD;;;;;;;;;;;;;;AAcA,iBAAgB,MAAM,WAAW,KAAK;;ACpCtC,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,OAAO,eAAe,OAAO;AAI7C,iBAAgB,OAAO,eAAe,OAAO;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,iBAAgB,WAAW","names":[]}

package/dist/index.d.mts

@@ -42,6 +42,24 @@ type GoTryRawOptions<E = Error> = {
     errorClass?: never;
     systemErrorClass?: never;
 };
+/**
+ * Options for goTryAllRaw function.
+ * Includes concurrency control and error class options.
+ * errorClass and systemErrorClass are mutually exclusive.
+ */
+type GoTryAllRawOptions<E = Error> = {
+    concurrency?: number;
+    errorClass: ErrorConstructor<E>;
+    systemErrorClass?: never;
+} | {
+    concurrency?: number;
+    errorClass?: never;
+    systemErrorClass: ErrorConstructor<E>;
+} | {
+    concurrency?: number;
+    errorClass?: never;
+    systemErrorClass?: never;
+};
 /**
  * Creates a union type from multiple tagged error classes.
  *
@@ -227,18 +245,25 @@ declare function goTryAll<T extends readonly unknown[]>(items: {
 }]>;
 /**
  * Like `goTryAll`, but returns raw Error objects instead of error messages.
+ * Non-tagged errors are wrapped in `UnknownError` by default (consistent with `goTryRaw`).
+ * Tagged errors pass through unchanged.
+ *
+ * Supports `errorClass` and `systemErrorClass` options (mutually exclusive):
+ * - `errorClass`: Wrap ALL errors in the specified class
+ * - `systemErrorClass`: Only wrap non-tagged errors (defaults to UnknownError)
  *
  * @template T The tuple type of all promise results
+ * @template E The type of the error
  * @param {readonly [...{ [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) }]} items - Array of promises or factories
- * @param {GoTryAllOptions} options - Optional configuration
- * @returns {Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]>}
+ * @param {GoTryAllRawOptions<E>} options - Optional configuration
+ * @returns {Promise<[{ [K in keyof T]: E | undefined }, { [K in keyof T]: T[K] | undefined }]>}
  *          A tuple where the first element is a tuple of Error objects (or undefined) and
  *          the second element is a tuple of results (or undefined), preserving input order
  */
-declare function goTryAllRaw<T extends readonly unknown[]>(items: {
+declare function goTryAllRaw<T extends readonly unknown[], E = InstanceType<typeof UnknownError>>(items: {
     [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>);
-}, options?: GoTryAllOptions): Promise<[{
-    [K in keyof T]: Error | undefined;
+}, options?: GoTryAllRawOptions<E>): Promise<[{
+    [K in keyof T]: E | undefined;
 }, {
     [K in keyof T]: T[K] | undefined;
 }]>;
@@ -351,5 +376,5 @@ declare function failure<E>(error: E): Failure<E>;
 declare function assertNever(value: never): never;
 
 export { UnknownError, assert, assertNever, failure, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };
-export type { ErrorConstructor, Failure, GoTryAllOptions, GoTryRawOptions, MaybePromise, Result, ResultWithDefault, Success, TaggedError, TaggedUnion };
+export type { ErrorConstructor, Failure, GoTryAllOptions, GoTryAllRawOptions, GoTryRawOptions, MaybePromise, Result, ResultWithDefault, Success, TaggedError, TaggedUnion };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sources":["../src/types.ts","../src/goTry.ts","../src/unknown-error.ts","../src/goTryRaw.ts","../src/goTryOr.ts","../src/goTryAll.ts","../src/tagged-error.ts","../src/assert.ts","../src/result-helpers.ts"],"mappings":"AAAA;;;AAIM,KAAM,OAAO;AACb,KAAM,OAAO;AACb,KAAM,MAAM,SAAS,OAAO,MAAM,OAAO;AAEzC,KAAM,iBAAiB;AAEvB,KAAM,YAAY,UAAU,OAAO;AAEzC;;;;AAIM,UAAW,WAAW;;;;;AAMtB,UAAW,eAAe;;;;;;;AAQhC;;;AAGM,KAAM,gBAAgB;;;AAO5B;;;;AAIM,KAAM,eAAe,KAAK,KAAK;gBACnB,gBAAgB;;;;sBACU,gBAAgB;;;;;AAG5D;;;;;;;;;;;;;AAaM,KAAM,WAAW,oBAAoB,gBAAgB;iCAC1B,gBAAgB;;;AC3DjD;;;;;;;;;;;;;;;;;;;;AAoBA,iBAAgB,KAAK,sBAAsB,MAAM;AACjD,iBAAgB,KAAK,cAAc,OAAO,MAAM,OAAO,CAAC,MAAM;AAC9D,iBAAgB,KAAK,aAAa,OAAO,MAAM,OAAO,CAAC,MAAM;AAC7D,iBAAgB,KAAK,kBAAkB,MAAM;AAC7C,iBAAgB,KAAK,eAAe,MAAM;;AC1B1C;;;;;;;;;;;;;;;;;AAiBA,cAAa,YAAY;;;;;;;;;;;;;ACPzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,iBAAgB,QAAQ,sBAAsB,MAAM,CAAC,KAAK;AAC1D,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,6BAA6B,eAAe,MAAM,MAAM;AACxH,iBAAgB,QAAQ,cACZ,OAAO,MAChB,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,aACpD,OAAO,cACR,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,aACb,OAAO,MACf,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,YACrD,OAAO,cACP,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,kBAAkB,MAAM,CAAC,KAAK;AACtD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,yBAAyB,eAAe,MAAM,MAAM;AACpH,iBAAgB,QAAQ,eAAe,MAAM,CAAC,KAAK;AACnD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,sBAAsB,eAAe,MAAM,MAAM;;AC5DjH;;;;;;;;;;;;;;;;;;;;;AAqBA,iBAAgB,OAAO,mDAAmD,iBAAiB;AAC3F,iBAAgB,OAAO,cACX,OAAO,mCAEhB,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,aACZ,OAAO,mCAEf,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,+CAA+C,iBAAiB;AACvF,iBAAgB,OAAO,4CAA4C,iBAAiB;;ACgBpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,iBAAsB,QAAQ;oBACH,OAAO,gBAAgB,OAAO;aAC7C,eAAe,GACxB,OAAO;;;;;AAoBV;;;;;;;;;;AAUA,iBAAsB,WAAW;oBACN,OAAO,gBAAgB,OAAO;aAC7C,eAAe,GACxB,OAAO;oBAAoB,KAAK;;;;;ACrHnC;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,iBAAgB,WAAW;;;;;;;;;;;;;AC1B3B;;;;;;;;;;;;;;;;;;;;;;AAsBA,iBAAgB,MAAM,4BAA4B,KAAK;AAEvD;;;;;;;;;;;;;;AAcA,iBAAgB,MAAM,WAAW,KAAK;;ACpCtC,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,OAAO,eAAe,OAAO;AAI7C,iBAAgB,OAAO,eAAe,OAAO;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,iBAAgB,WAAW","names":[]}
+{"version":3,"file":"index.d.mts","sources":["../src/types.ts","../src/goTry.ts","../src/unknown-error.ts","../src/goTryRaw.ts","../src/goTryOr.ts","../src/goTryAll.ts","../src/tagged-error.ts","../src/assert.ts","../src/result-helpers.ts"],"mappings":"AAAA;;;AAIM,KAAM,OAAO;AACb,KAAM,OAAO;AACb,KAAM,MAAM,SAAS,OAAO,MAAM,OAAO;AAEzC,KAAM,iBAAiB;AAEvB,KAAM,YAAY,UAAU,OAAO;AAEzC;;;;AAIM,UAAW,WAAW;;;;;AAMtB,UAAW,eAAe;;;;;;;AAQhC;;;AAGM,KAAM,gBAAgB;;;AAO5B;;;;AAIM,KAAM,eAAe,KAAK,KAAK;gBACnB,gBAAgB;;;;sBACU,gBAAgB;;;;;AAG5D;;;;;AAKM,KAAM,kBAAkB,KAAK,KAAK;;gBACA,gBAAgB;;;;;sBACU,gBAAgB;;;;;;AAGlF;;;;;;;;;;;;;AAaM,KAAM,WAAW,oBAAoB,gBAAgB;iCAC1B,gBAAgB;;;ACrEjD;;;;;;;;;;;;;;;;;;;;AAoBA,iBAAgB,KAAK,sBAAsB,MAAM;AACjD,iBAAgB,KAAK,cAAc,OAAO,MAAM,OAAO,CAAC,MAAM;AAC9D,iBAAgB,KAAK,aAAa,OAAO,MAAM,OAAO,CAAC,MAAM;AAC7D,iBAAgB,KAAK,kBAAkB,MAAM;AAC7C,iBAAgB,KAAK,eAAe,MAAM;;AC1B1C;;;;;;;;;;;;;;;;;AAiBA,cAAa,YAAY;;;;;;;;;;;;;ACPzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,iBAAgB,QAAQ,sBAAsB,MAAM,CAAC,KAAK;AAC1D,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,6BAA6B,eAAe,MAAM,MAAM;AACxH,iBAAgB,QAAQ,cACZ,OAAO,MAChB,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,aACpD,OAAO,cACR,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,aACb,OAAO,MACf,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,YACrD,OAAO,cACP,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,kBAAkB,MAAM,CAAC,KAAK;AACtD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,yBAAyB,eAAe,MAAM,MAAM;AACpH,iBAAgB,QAAQ,eAAe,MAAM,CAAC,KAAK;AACnD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,sBAAsB,eAAe,MAAM,MAAM;;AC5DjH;;;;;;;;;;;;;;;;;;;;;AAqBA,iBAAgB,OAAO,mDAAmD,iBAAiB;AAC3F,iBAAgB,OAAO,cACX,OAAO,mCAEhB,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,aACZ,OAAO,mCAEf,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,+CAA+C,iBAAiB;AACvF,iBAAgB,OAAO,4CAA4C,iBAAiB;;ACsDpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,iBAAsB,QAAQ;oBACH,OAAO,gBAAgB,OAAO;aAC7C,eAAe,GACxB,OAAO;;;;;AAoBV;;;;;;;;;;;;;;;;;AAiBA,iBAAsB,WAAW,mCAAmC,YAAY,QAAQ,YAAY;oBACzE,OAAO,gBAAgB,OAAO;aAC7C,kBAAkB,MAC3B,OAAO;;;;;;AClKV;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,iBAAgB,WAAW;;;;;;;;;;;;;AC1B3B;;;;;;;;;;;;;;;;;;;;;;AAsBA,iBAAgB,MAAM,4BAA4B,KAAK;AAEvD;;;;;;;;;;;;;;AAcA,iBAAgB,MAAM,WAAW,KAAK;;ACpCtC,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,OAAO,eAAe,OAAO;AAI7C,iBAAgB,OAAO,eAAe,OAAO;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,iBAAgB,WAAW","names":[]}

package/dist/index.mjs

@@ -61,7 +61,7 @@ function taggedError(tag) {
 
 const UnknownError = taggedError("UnknownError");
 
-function isTaggedError(err) {
+function isTaggedError$1(err) {
   return isError(err) && "_tag" in err && typeof err._tag === "string";
 }
 function goTryRaw(value, options) {
@@ -78,7 +78,7 @@ function goTryRaw(value, options) {
       return new errorClass(String(err));
     }
     if (actualSystemErrorClass) {
-      if (isTaggedError(err)) {
+      if (isTaggedError$1(err)) {
         return err;
       }
       if (err === void 0) {
@@ -117,6 +117,31 @@ function goTryOr(value, defaultValue) {
   }
 }
 
+function isTaggedError(err) {
+  return isError(err) && "_tag" in err && typeof err._tag === "string";
+}
+function wrapError(err, errorClass, systemErrorClass) {
+  if (errorClass) {
+    if (err === void 0) {
+      return new errorClass("undefined");
+    }
+    if (isError(err)) {
+      return new errorClass(err.message, { cause: err });
+    }
+    return new errorClass(String(err));
+  }
+  const actualSystemErrorClass = systemErrorClass ?? UnknownError;
+  if (isTaggedError(err)) {
+    return err;
+  }
+  if (err === void 0) {
+    return new actualSystemErrorClass("undefined");
+  }
+  if (isError(err)) {
+    return new actualSystemErrorClass(err.message, { cause: err });
+  }
+  return new actualSystemErrorClass(String(err));
+}
 async function runWithConcurrency(items, concurrency) {
   if (items.length === 0) {
     return [];
@@ -164,6 +189,7 @@ async function goTryAll(items, options) {
   return [errors, results];
 }
 async function goTryAllRaw(items, options) {
+  const { errorClass, systemErrorClass } = options || {};
   const settled = await runWithConcurrency(items, options?.concurrency ?? 0);
   const errors = [];
   const results = [];
@@ -174,7 +200,7 @@ async function goTryAllRaw(items, options) {
       results[i] = item.value;
     } else {
       const reason = item.reason;
-      errors[i] = isError(reason) ? reason : new Error(String(reason));
+      errors[i] = wrapError(reason, errorClass, systemErrorClass);
       results[i] = void 0;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "go-go-try",
-	"version": "7.4.0",
+	"version": "7.4.1",
 	"description": "Tries to execute a sync/async function, returns a result tuple",
 	"license": "MIT",
 	"repository": "thelinuxlich/go-go-try",

package/src/goTryAll.ts

@@ -1,5 +1,43 @@
-import type { GoTryAllOptions } from './types.js'
+import type { GoTryAllOptions, GoTryAllRawOptions, ErrorConstructor } from './types.js'
 import { isError, getErrorMessage, type PromiseFactory } from './internals.js'
+import { UnknownError } from './unknown-error.js'
+
+/**
+ * Checks if a value is a tagged error (has a _tag property).
+ */
+function isTaggedError(err: unknown): err is { _tag: string } {
+  return isError(err) && '_tag' in err && typeof (err as { _tag?: unknown })._tag === 'string'
+}
+
+/**
+ * Wraps an error based on the provided options (errorClass/systemErrorClass).
+ * Consistent with goTryRaw behavior.
+ */
+function wrapError<E>(err: unknown, errorClass: ErrorConstructor<E> | undefined, systemErrorClass: ErrorConstructor<E> | undefined): E {
+  // If errorClass is specified, wrap all errors with it
+  if (errorClass) {
+    if (err === undefined) {
+      return new errorClass('undefined')
+    }
+    if (isError(err)) {
+      return new errorClass(err.message, { cause: err })
+    }
+    return new errorClass(String(err))
+  }
+
+  // If systemErrorClass is specified (or defaulted to UnknownError), only wrap non-tagged errors
+  const actualSystemErrorClass = systemErrorClass ?? UnknownError
+  if (isTaggedError(err)) {
+    return err as unknown as E
+  }
+  if (err === undefined) {
+    return new actualSystemErrorClass('undefined') as unknown as E
+  }
+  if (isError(err)) {
+    return new actualSystemErrorClass(err.message, { cause: err }) as unknown as E
+  }
+  return new actualSystemErrorClass(String(err)) as unknown as E
+}
 
 async function runWithConcurrency<T extends readonly unknown[]>(
   items: { [K in keyof T]: Promise<T[K]> | PromiseFactory<T[K]> },
@@ -106,33 +144,39 @@ export async function goTryAll<T extends readonly unknown[]>(
 
 /**
  * Like `goTryAll`, but returns raw Error objects instead of error messages.
+ * Non-tagged errors are wrapped in `UnknownError` by default (consistent with `goTryRaw`).
+ * Tagged errors pass through unchanged.
+ *
+ * Supports `errorClass` and `systemErrorClass` options (mutually exclusive):
+ * - `errorClass`: Wrap ALL errors in the specified class
+ * - `systemErrorClass`: Only wrap non-tagged errors (defaults to UnknownError)
  *
  * @template T The tuple type of all promise results
+ * @template E The type of the error
  * @param {readonly [...{ [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) }]} items - Array of promises or factories
- * @param {GoTryAllOptions} options - Optional configuration
- * @returns {Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]>}
+ * @param {GoTryAllRawOptions<E>} options - Optional configuration
+ * @returns {Promise<[{ [K in keyof T]: E | undefined }, { [K in keyof T]: T[K] | undefined }]>}
  *          A tuple where the first element is a tuple of Error objects (or undefined) and
  *          the second element is a tuple of results (or undefined), preserving input order
  */
-export async function goTryAllRaw<T extends readonly unknown[]>(
+export async function goTryAllRaw<T extends readonly unknown[], E = InstanceType<typeof UnknownError>>(
   items: { [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) },
-  options?: GoTryAllOptions,
-): Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]> {
+  options?: GoTryAllRawOptions<E>,
+): Promise<[{ [K in keyof T]: E | undefined }, { [K in keyof T]: T[K] | undefined }]> {
+  const { errorClass, systemErrorClass } = options || {}
   const settled = await runWithConcurrency(items, options?.concurrency ?? 0)
 
-  const errors = [] as { [K in keyof T]: Error | undefined }
+  const errors = [] as { [K in keyof T]: E | undefined }
   const results = [] as { [K in keyof T]: T[K] | undefined }
 
   for (let i = 0; i < settled.length; i++) {
     const item = settled[i]!
     if (item.status === 'fulfilled') {
-      ;(errors as (Error | undefined)[])[i] = undefined
+      ;(errors as (E | undefined)[])[i] = undefined
       ;(results as unknown[])[i] = (item as PromiseFulfilledResult<T[number]>).value
     } else {
       const reason = (item as PromiseRejectedResult).reason
-      ;(errors as (Error | undefined)[])[i] = isError(reason)
-        ? reason
-        : new Error(String(reason))
+      ;(errors as (E | undefined)[])[i] = wrapError(reason, errorClass, systemErrorClass)
       ;(results as unknown[])[i] = undefined
     }
   }

package/src/index.test.ts

@@ -1107,7 +1107,7 @@ describe('goTryAllRaw', () => {
     assert.deepEqual(results, ['a', 42, true])
   })
 
-  test('returns Error objects for failed promises', async () => {
+  test('wraps non-tagged errors in UnknownError', async () => {
     const [errors, results] = await goTryAllRaw([
       Promise.resolve('success'),
       Promise.reject(new Error('fail1')),
@@ -1115,6 +1115,8 @@ describe('goTryAllRaw', () => {
     ])
 
     assert.equal(errors[0], undefined)
+    assert.ok(errors[1] instanceof UnknownError)
+    assert.equal(errors[1]?._tag, 'UnknownError')
     assert.equal(errors[1]?.message, 'fail1')
     assert.equal(errors[2], undefined)
 
@@ -1123,15 +1125,44 @@ describe('goTryAllRaw', () => {
     assert.equal(results[2], 42)
   })
 
-  test('converts non-Error rejections to Error objects', async () => {
+  test('tagged errors pass through unchanged', async () => {
+    const DatabaseError = taggedError('DatabaseError')
+    const NetworkError = taggedError('NetworkError')
+
+    const [errors] = await goTryAllRaw([
+      Promise.reject(new DatabaseError('db failed')),
+      Promise.reject(new NetworkError('network timeout')),
+      Promise.reject(new Error('plain error')),
+    ])
+
+    // Tagged errors pass through
+    assert.ok(errors[0] instanceof DatabaseError)
+    assert.equal(errors[0]?._tag, 'DatabaseError')
+    assert.equal(errors[0]?.message, 'db failed')
+    assert.ok(errors[1] instanceof NetworkError)
+    assert.equal(errors[1]?._tag, 'NetworkError')
+    assert.equal(errors[1]?.message, 'network timeout')
+    // Non-tagged errors get wrapped in UnknownError
+    assert.ok(errors[2] instanceof UnknownError)
+    assert.equal(errors[2]?._tag, 'UnknownError')
+    assert.equal(errors[2]?.message, 'plain error')
+  })
+
+  test('converts non-Error rejections to UnknownError objects', async () => {
     const [errors] = await goTryAllRaw([
       Promise.reject('string error'),
       Promise.reject(42),
       Promise.reject(undefined),
     ])
 
+    assert.ok(errors[0] instanceof UnknownError)
+    assert.equal(errors[0]?._tag, 'UnknownError')
     assert.equal(errors[0]?.message, 'string error')
+    assert.ok(errors[1] instanceof UnknownError)
+    assert.equal(errors[1]?._tag, 'UnknownError')
     assert.equal(errors[1]?.message, '42')
+    assert.ok(errors[2] instanceof UnknownError)
+    assert.equal(errors[2]?._tag, 'UnknownError')
     assert.equal(errors[2]?.message, 'undefined')
   })
 
@@ -1141,6 +1172,60 @@ describe('goTryAllRaw', () => {
     assert.deepEqual(errors, [])
     assert.deepEqual(results, [])
   })
+
+  test('errorClass wraps all errors', async () => {
+    const DatabaseError = taggedError('DatabaseError')
+    const NetworkError = taggedError('NetworkError')
+
+    const [errors] = await goTryAllRaw([
+      Promise.reject(new DatabaseError('db error')),
+      Promise.reject(new NetworkError('network error')),
+      Promise.reject(new Error('plain error')),
+    ], { errorClass: DatabaseError })
+
+    // All errors should be wrapped in DatabaseError
+    assert.ok(errors[0] instanceof DatabaseError)
+    assert.equal(errors[0]?._tag, 'DatabaseError')
+    assert.ok(errors[1] instanceof DatabaseError)
+    assert.equal(errors[1]?._tag, 'DatabaseError')
+    assert.ok(errors[2] instanceof DatabaseError)
+    assert.equal(errors[2]?._tag, 'DatabaseError')
+  })
+
+  test('systemErrorClass only wraps non-tagged errors', async () => {
+    const DatabaseError = taggedError('DatabaseError')
+    const NetworkError = taggedError('NetworkError')
+    const SystemError = taggedError('SystemError')
+
+    const [errors] = await goTryAllRaw([
+      Promise.reject(new DatabaseError('db error')),
+      Promise.reject(new NetworkError('network error')),
+      Promise.reject(new Error('plain error')),
+    ], { systemErrorClass: SystemError })
+
+    // Tagged errors pass through
+    assert.ok(errors[0] instanceof DatabaseError)
+    assert.equal(errors[0]?._tag, 'DatabaseError')
+    assert.ok(errors[1] instanceof NetworkError)
+    assert.equal(errors[1]?._tag, 'NetworkError')
+    // Non-tagged error wrapped in SystemError
+    assert.ok(errors[2] instanceof SystemError)
+    assert.equal(errors[2]?._tag, 'SystemError')
+  })
+
+  test('concurrency option works with errorClass', async () => {
+    const DatabaseError = taggedError('DatabaseError')
+
+    const [errors] = await goTryAllRaw([
+      Promise.reject(new Error('error 1')),
+      Promise.reject(new Error('error 2')),
+      Promise.reject(new Error('error 3')),
+    ], { concurrency: 2, errorClass: DatabaseError })
+
+    assert.ok(errors[0] instanceof DatabaseError)
+    assert.ok(errors[1] instanceof DatabaseError)
+    assert.ok(errors[2] instanceof DatabaseError)
+  })
 })
 
 

package/src/index.ts

@@ -10,6 +10,7 @@ export type {
   ErrorConstructor,
   TaggedUnion,
   GoTryRawOptions,
+  GoTryAllRawOptions,
 } from './types.js'
 
 // Export core functions

package/src/types.ts

@@ -47,6 +47,16 @@ export type GoTryRawOptions<E = Error> =
   | { errorClass?: never; systemErrorClass: ErrorConstructor<E> }
   | { errorClass?: never; systemErrorClass?: never }
 
+/**
+ * Options for goTryAllRaw function.
+ * Includes concurrency control and error class options.
+ * errorClass and systemErrorClass are mutually exclusive.
+ */
+export type GoTryAllRawOptions<E = Error> =
+  | { concurrency?: number; errorClass: ErrorConstructor<E>; systemErrorClass?: never }
+  | { concurrency?: number; errorClass?: never; systemErrorClass: ErrorConstructor<E> }
+  | { concurrency?: number; errorClass?: never; systemErrorClass?: never }
+
 /**
  * Creates a union type from multiple tagged error classes.
  *