go-go-try 7.3.0 → 7.4.0

package/README.md

@@ -46,10 +46,10 @@ const [err, todos = []] = await goTry(fetchTodos()) // err is string | undefined
 if (err) sendToErrorTrackingService(err)
 
 // goTry extracts the error message from the error object, if you want the raw error object, use goTryRaw
-const [err, value] = goTryRaw(() => JSON.parse('{/}')) // err is Error | undefined, value is T | undefined
+const [err, value] = goTryRaw(() => JSON.parse('{/}')) // err is UnknownError | undefined, value is T | undefined
 
 // fetch todos, fallback to empty array, send error to your error tracking service
-const [err, todos = []] = await goTryRaw(fetchTodos()) // err is Error | undefined
+const [err, todos = []] = await goTryRaw(fetchTodos()) // err is UnknownError | undefined
 if (err) sendToErrorTrackingService(err)
 ```
 
@@ -233,10 +233,10 @@ type AppErrorVerbose =
 
 // Use in functions with typed error returns
 async function fetchUser(id: string): Promise<Result<AppError, User>> {
-  const [dbErr, user] = await goTryRaw(queryDatabase(id), DatabaseError)
+  const [dbErr, user] = await goTryRaw(queryDatabase(id), { errorClass: DatabaseError })
   if (dbErr) return failure(dbErr)
   
-  const [netErr, enriched] = await goTryRaw(enrichUserData(user!), NetworkError)
+  const [netErr, enriched] = await goTryRaw(enrichUserData(user!), { errorClass: NetworkError })
   if (netErr) return failure(netErr)
   
   return [undefined, enriched] as const
@@ -318,32 +318,51 @@ Executes a function, promise, or value and returns a Result type with error mess
 function goTry<T>(value: T | Promise<T> | (() => T | Promise<T>)): Result<string, T> | Promise<Result<string, T>>
 ```
 
-### `goTryRaw<T, E>(value, ErrorClass?)`
+### `goTryRaw<T, E>(value, options?)`
 
 Like `goTry` but returns the raw Error object instead of just the message.
 
-Optionally accepts an error constructor to wrap caught errors - useful with `taggedError` for discriminated unions.
+By default, errors are wrapped in `UnknownError` (a tagged error class). You can customize this behavior with the options object:
 
 ```ts
-// Without ErrorClass - err is Error | undefined
-function goTryRaw<T, E = Error>(value: T | Promise<T> | (() => T | Promise<T>)): Result<E, T> | Promise<Result<E, T>>
+type GoTryRawOptions<E> =
+  | { errorClass: ErrorConstructor<E> }           // Wrap ALL errors in this class
+  | { systemErrorClass: ErrorConstructor<E> }     // Only wrap non-tagged errors
+  | {}                                            // Use defaults
+```
+
+> **Note:** `errorClass` and `systemErrorClass` are **mutually exclusive**. TypeScript will show an error if you try to pass both.
+> - Use `errorClass` when you want all errors wrapped in a specific type
+> - Use `systemErrorClass` when you want tagged errors to pass through and only wrap untagged errors
+
+```ts
+// Without options - err is UnknownError | undefined
+function goTryRaw<T>(value: T | Promise<T> | (() => T | Promise<T>)): Result<UnknownError, T> | Promise<Result<UnknownError, T>>
 
-// With ErrorClass - err is E | undefined (e.g., DatabaseError | undefined)
-function goTryRaw<T, E>(value: T | Promise<T> | (() => T | Promise<T>), ErrorClass: ErrorConstructor<E>): Result<E, T> | Promise<Result<E, T>>
+// With options object - err is E | undefined
+function goTryRaw<T, E>(value: T | Promise<T> | (() => T | Promise<T>), options: GoTryRawOptions<E>): Result<E, T> | Promise<Result<E, T>>
 ```
 
-**Example:**
+**Examples:**
+
 ```ts
 const DatabaseError = taggedError('DatabaseError')
+const NetworkError = taggedError('NetworkError')
 
-// Raw error (default)
+// Default - errors wrapped in UnknownError
 const [err1, data1] = await goTryRaw(fetchData())
-// err1 is Error | undefined
+// err1 is UnknownError | undefined
+// err1?._tag === 'UnknownError'
 
-// Tagged error
-const [err2, data2] = await goTryRaw(fetchData(), DatabaseError)
+// Options object - wrap all errors
+const [err2, data2] = await goTryRaw(fetchData(), { errorClass: DatabaseError })
 // err2 is DatabaseError | undefined
-// err2._tag is 'DatabaseError' - enables discriminated unions
+// err2?._tag === 'DatabaseError'
+
+// Options object - systemErrorClass only wraps non-tagged errors
+const [err3, data3] = await goTryRaw(fetchData(), { systemErrorClass: NetworkError })
+// If fetchData throws a tagged error (e.g., DatabaseError), it passes through
+// If fetchData throws a plain Error, it gets wrapped in NetworkError
 ```
 
 ### `goTryAll<T>(items, options?)`
@@ -453,6 +472,47 @@ console.log(err.name)    // 'DatabaseError'
 console.log(err.cause)   // originalError
 ```
 
+### `UnknownError`
+
+A default tagged error class used by `goTryRaw` when no options are provided, or when `systemErrorClass` is not specified in the options object.
+
+```ts
+import { UnknownError, goTryRaw } from 'go-go-try'
+
+// Errors are automatically wrapped in UnknownError
+const [err, data] = goTryRaw(() => {
+  throw new Error('something went wrong')
+})
+
+if (err) {
+  console.log(err._tag)    // 'UnknownError'
+  console.log(err.message) // 'something went wrong'
+  console.log(err.cause)   // original Error
+}
+```
+
+Since `UnknownError` is the default for `systemErrorClass`, you can distinguish between known tagged errors and unexpected system errors without specifying any options:
+
+```ts
+const DatabaseError = taggedError('DatabaseError')
+
+function fetchData() {
+  // Operations that might throw DatabaseError should use errorClass to wrap them
+  const [err1, data1] = goTryRaw(() => queryDatabase(), { errorClass: DatabaseError })
+  
+  // Other operations use the default behavior - non-tagged errors become UnknownError
+  const [err2, data2] = goTryRaw(() => parseData(data1))
+  // err2 is UnknownError | undefined
+  
+  // Now you can distinguish between known and unknown error types
+  if (err1) {
+    console.log('Known DB error:', err1.message)
+  } else if (err2) {
+    console.log('Unexpected error:', err2.message)
+  }
+}
+```
+
 ### `TaggedUnion<T>`
 
 Creates a union type from multiple tagged error classes.
@@ -487,11 +547,11 @@ When using `goTryRaw` with different error classes in the same function, TypeScr
 // No explicit return type needed!
 async function fetchUserData(id: string) {
   // First operation might fail with DatabaseError
-  const [dbErr, user] = await goTryRaw(queryDb(id), DatabaseError)
+  const [dbErr, user] = await goTryRaw(queryDb(id), { errorClass: DatabaseError })
   if (dbErr) return failure(dbErr)  // returns Failure<DatabaseError>
 
   // Second operation might fail with NetworkError  
-  const [netErr, enriched] = await goTryRaw(enrichUser(user!), NetworkError)
+  const [netErr, enriched] = await goTryRaw(enrichUser(user!), { errorClass: NetworkError })
   if (netErr) return failure(netErr)  // returns Failure<NetworkError>
 
   return success(enriched)  // returns Success<User>
@@ -525,6 +585,12 @@ type Result<E, T> = Success<T> | Failure<E>
 type TaggedInstance<T> = T extends ErrorConstructor<infer E> ? E : never
 type TaggedUnion<T extends readonly ErrorConstructor<unknown>[]> = 
   { [K in keyof T]: T[K] extends ErrorConstructor<infer E> ? E : never }[number]
+
+// Options for goTryRaw (errorClass and systemErrorClass are mutually exclusive)
+type GoTryRawOptions<E> =
+  | { errorClass: ErrorConstructor<E>; systemErrorClass?: never }
+  | { errorClass?: never; systemErrorClass: ErrorConstructor<E> }
+  | { errorClass?: never; systemErrorClass?: never }
 ```
 
 ## License

package/dist/index.cjs

@@ -50,16 +50,46 @@ function goTry(value) {
   }
 }
 
-function goTryRaw(value, ErrorClass) {
+function taggedError(tag) {
+  return class TaggedErrorClass extends Error {
+    constructor(message, options) {
+      super(message);
+      this._tag = tag;
+      this.name = tag;
+      this.cause = options?.cause;
+    }
+  };
+}
+
+const UnknownError = taggedError("UnknownError");
+
+function isTaggedError(err) {
+  return isError(err) && "_tag" in err && typeof err._tag === "string";
+}
+function goTryRaw(value, options) {
+  const { errorClass, systemErrorClass } = options || {};
+  const actualSystemErrorClass = systemErrorClass ?? UnknownError;
   const wrapError = (err) => {
-    if (ErrorClass) {
+    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));
+    }
+    if (actualSystemErrorClass) {
+      if (isTaggedError(err)) {
+        return err;
+      }
       if (err === void 0) {
-        return new ErrorClass("undefined");
+        return new actualSystemErrorClass("undefined");
       }
       if (isError(err)) {
-        return new ErrorClass(err.message, { cause: err });
+        return new actualSystemErrorClass(err.message, { cause: err });
       }
-      return new ErrorClass(String(err));
+      return new actualSystemErrorClass(String(err));
     }
     if (err === void 0) {
       return new Error("undefined");
@@ -153,17 +183,6 @@ async function goTryAllRaw(items, options) {
   return [errors, results];
 }
 
-function taggedError(tag) {
-  return class TaggedErrorClass extends Error {
-    constructor(message, options) {
-      super(message);
-      this._tag = tag;
-      this.name = tag;
-      this.cause = options?.cause;
-    }
-  };
-}
-
 function assert(condition, errorOrClass, message) {
   if (!condition) {
     if (typeof errorOrClass === "string") {
@@ -176,6 +195,7 @@ function assert(condition, errorOrClass, message) {
   }
 }
 
+exports.UnknownError = UnknownError;
 exports.assert = assert;
 exports.assertNever = assertNever;
 exports.failure = failure;

package/dist/index.d.cts

@@ -28,6 +28,20 @@ interface GoTryAllOptions {
 type ErrorConstructor<E> = new (message: string, options?: {
     cause?: unknown;
 }) => E;
+/**
+ * Options for goTryRaw function.
+ * errorClass and systemErrorClass are mutually exclusive - you can only provide one.
+ */
+type GoTryRawOptions<E = Error> = {
+    errorClass: ErrorConstructor<E>;
+    systemErrorClass?: never;
+} | {
+    errorClass?: never;
+    systemErrorClass: ErrorConstructor<E>;
+} | {
+    errorClass?: never;
+    systemErrorClass?: never;
+};
 /**
  * Creates a union type from multiple tagged error classes.
  *
@@ -71,14 +85,44 @@ declare function goTry<T>(promise: Promise<T>): Promise<Result<string, T>>;
 declare function goTry<T>(fn: () => T): Result<string, T>;
 declare function goTry<T>(value: T): Result<string, T>;
 
+/**
+ * Default system error class for errors that aren't already wrapped in a tagged error class.
+ *
+ * @example
+ * // By default, goTryRaw wraps unknown errors in UnknownError
+ * const [err, result] = goTryRaw(() => mightThrow())
+ * if (err) {
+ *   console.log(err._tag) // 'UnknownError'
+ * }
+ *
+ * @example
+ * // Use a custom system error class
+ * const SystemError = taggedError('SystemError')
+ * const [err, result] = goTryRaw(() => mightThrow(), {
+ *   systemErrorClass: SystemError
+ * })
+ */
+declare const UnknownError: {
+    new (message: string, options?: {
+        cause?: unknown;
+    } | undefined): {
+        readonly _tag: "UnknownError";
+        readonly cause?: unknown;
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    isError(error: unknown): error is Error;
+};
+
 /**
  * Executes a function, promise, or value and returns a Result type.
  * If an error occurs, it returns a Failure with the raw error object.
  *
  * @template T The type of the successful result
- * @template E The type of the error, defaults to Error
+ * @template E The type of the error
  * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
- * @param {ErrorConstructor<E>} [ErrorClass] - Optional error constructor to wrap caught errors
+ * @param {GoTryRawOptions<E>} [options] - Optional options object
  * @returns {Result<E, T> | Promise<Result<E, T>>} A Result type or a Promise of a Result type
  *
  * @example
@@ -94,21 +138,26 @@ declare function goTry<T>(value: T): Result<string, T>;
  * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
  *
  * @example
- * // With tagged error for discriminated unions
+ * // With options object - wrap all errors
  * const DatabaseError = taggedError('DatabaseError');
- * const [err, result] = await goTryRaw(fetchData(), DatabaseError);
- * // err is InstanceType<typeof DatabaseError> | undefined
+ * const [err, result] = await goTryRaw(fetchData(), { errorClass: DatabaseError });
+ *
+ * @example
+ * // With options object - systemErrorClass only wraps non-tagged errors
+ * const [err, result] = await goTryRaw(fetchData(), { systemErrorClass: UnknownError });
+ * // Errors thrown as tagged errors pass through
+ * // Other errors are wrapped in UnknownError
  */
-declare function goTryRaw<T, E = Error>(fn: () => never): Result<E, never>;
-declare function goTryRaw<T, E = Error>(fn: () => never, ErrorClass: ErrorConstructor<E>): Result<E, never>;
-declare function goTryRaw<T, E = Error>(fn: () => Promise<T>): Promise<Result<E, T>>;
-declare function goTryRaw<T, E = Error>(fn: () => Promise<T>, ErrorClass: ErrorConstructor<E>): Promise<Result<E, T>>;
-declare function goTryRaw<T, E = Error>(promise: Promise<T>): Promise<Result<E, T>>;
-declare function goTryRaw<T, E = Error>(promise: Promise<T>, ErrorClass: ErrorConstructor<E>): Promise<Result<E, T>>;
-declare function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>;
-declare function goTryRaw<T, E = Error>(fn: () => T, ErrorClass: ErrorConstructor<E>): Result<E, T>;
-declare function goTryRaw<T, E = Error>(value: T): Result<E, T>;
-declare function goTryRaw<T, E = Error>(value: T, ErrorClass: ErrorConstructor<E>): Result<E, T>;
+declare function goTryRaw<T>(fn: () => never): Result<Error, never>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(fn: () => never, options: GoTryRawOptions<E>): Result<E, never>;
+declare function goTryRaw<T>(fn: () => Promise<T>): Promise<Result<Error, T>>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(fn: () => Promise<T>, options: GoTryRawOptions<E>): Promise<Result<E, T>>;
+declare function goTryRaw<T>(promise: Promise<T>): Promise<Result<Error, T>>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(promise: Promise<T>, options: GoTryRawOptions<E>): Promise<Result<E, T>>;
+declare function goTryRaw<T>(fn: () => T): Result<Error, T>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(fn: () => T, options: GoTryRawOptions<E>): Result<E, T>;
+declare function goTryRaw<T>(value: T): Result<Error, T>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(value: T, options: GoTryRawOptions<E>): Result<E, T>;
 
 /**
  * Executes a function, promise, or value and returns a Result type with a fallback default.
@@ -301,6 +350,6 @@ declare function failure<E>(error: E): Failure<E>;
  */
 declare function assertNever(value: never): never;
 
-export { assert, assertNever, failure, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };
-export type { ErrorConstructor, Failure, GoTryAllOptions, MaybePromise, Result, ResultWithDefault, Success, TaggedError, TaggedUnion };
+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 };
 //# 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/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;;;AAE5B;;;;;;;;;;;;;AAaM,KAAM,WAAW,oBAAoB,gBAAgB;iCAC1B,gBAAgB;;;AC7CjD;;;;;;;;;;;;;;;;;;;;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;;ACxB1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,iBAAgB,QAAQ,QAAQ,KAAK,oBAAoB,MAAM;AAC/D,iBAAgB,QAAQ,QAAQ,KAAK,+BAA+B,gBAAgB,MAAM,MAAM;AAChG,iBAAgB,QAAQ,QAAQ,KAAK,YACzB,OAAO,MAChB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,QAAQ,KAAK,YACzB,OAAO,iBACL,gBAAgB,MAC3B,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,QAAQ,KAAK,WAC1B,OAAO,MACf,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,QAAQ,KAAK,WAC1B,OAAO,iBACJ,gBAAgB,MAC3B,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,QAAQ,KAAK,gBAAgB,MAAM;AAC3D,iBAAgB,QAAQ,QAAQ,KAAK,2BAA2B,gBAAgB,MAAM,MAAM;AAC5F,iBAAgB,QAAQ,QAAQ,KAAK,aAAa,MAAM;AACxD,iBAAgB,QAAQ,QAAQ,KAAK,wBAAwB,gBAAgB,MAAM,MAAM;;AC/CzF;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;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":[]}

package/dist/index.d.mts

@@ -28,6 +28,20 @@ interface GoTryAllOptions {
 type ErrorConstructor<E> = new (message: string, options?: {
     cause?: unknown;
 }) => E;
+/**
+ * Options for goTryRaw function.
+ * errorClass and systemErrorClass are mutually exclusive - you can only provide one.
+ */
+type GoTryRawOptions<E = Error> = {
+    errorClass: ErrorConstructor<E>;
+    systemErrorClass?: never;
+} | {
+    errorClass?: never;
+    systemErrorClass: ErrorConstructor<E>;
+} | {
+    errorClass?: never;
+    systemErrorClass?: never;
+};
 /**
  * Creates a union type from multiple tagged error classes.
  *
@@ -71,14 +85,44 @@ declare function goTry<T>(promise: Promise<T>): Promise<Result<string, T>>;
 declare function goTry<T>(fn: () => T): Result<string, T>;
 declare function goTry<T>(value: T): Result<string, T>;
 
+/**
+ * Default system error class for errors that aren't already wrapped in a tagged error class.
+ *
+ * @example
+ * // By default, goTryRaw wraps unknown errors in UnknownError
+ * const [err, result] = goTryRaw(() => mightThrow())
+ * if (err) {
+ *   console.log(err._tag) // 'UnknownError'
+ * }
+ *
+ * @example
+ * // Use a custom system error class
+ * const SystemError = taggedError('SystemError')
+ * const [err, result] = goTryRaw(() => mightThrow(), {
+ *   systemErrorClass: SystemError
+ * })
+ */
+declare const UnknownError: {
+    new (message: string, options?: {
+        cause?: unknown;
+    } | undefined): {
+        readonly _tag: "UnknownError";
+        readonly cause?: unknown;
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    isError(error: unknown): error is Error;
+};
+
 /**
  * Executes a function, promise, or value and returns a Result type.
  * If an error occurs, it returns a Failure with the raw error object.
  *
  * @template T The type of the successful result
- * @template E The type of the error, defaults to Error
+ * @template E The type of the error
  * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
- * @param {ErrorConstructor<E>} [ErrorClass] - Optional error constructor to wrap caught errors
+ * @param {GoTryRawOptions<E>} [options] - Optional options object
  * @returns {Result<E, T> | Promise<Result<E, T>>} A Result type or a Promise of a Result type
  *
  * @example
@@ -94,21 +138,26 @@ declare function goTry<T>(value: T): Result<string, T>;
  * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
  *
  * @example
- * // With tagged error for discriminated unions
+ * // With options object - wrap all errors
  * const DatabaseError = taggedError('DatabaseError');
- * const [err, result] = await goTryRaw(fetchData(), DatabaseError);
- * // err is InstanceType<typeof DatabaseError> | undefined
+ * const [err, result] = await goTryRaw(fetchData(), { errorClass: DatabaseError });
+ *
+ * @example
+ * // With options object - systemErrorClass only wraps non-tagged errors
+ * const [err, result] = await goTryRaw(fetchData(), { systemErrorClass: UnknownError });
+ * // Errors thrown as tagged errors pass through
+ * // Other errors are wrapped in UnknownError
  */
-declare function goTryRaw<T, E = Error>(fn: () => never): Result<E, never>;
-declare function goTryRaw<T, E = Error>(fn: () => never, ErrorClass: ErrorConstructor<E>): Result<E, never>;
-declare function goTryRaw<T, E = Error>(fn: () => Promise<T>): Promise<Result<E, T>>;
-declare function goTryRaw<T, E = Error>(fn: () => Promise<T>, ErrorClass: ErrorConstructor<E>): Promise<Result<E, T>>;
-declare function goTryRaw<T, E = Error>(promise: Promise<T>): Promise<Result<E, T>>;
-declare function goTryRaw<T, E = Error>(promise: Promise<T>, ErrorClass: ErrorConstructor<E>): Promise<Result<E, T>>;
-declare function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>;
-declare function goTryRaw<T, E = Error>(fn: () => T, ErrorClass: ErrorConstructor<E>): Result<E, T>;
-declare function goTryRaw<T, E = Error>(value: T): Result<E, T>;
-declare function goTryRaw<T, E = Error>(value: T, ErrorClass: ErrorConstructor<E>): Result<E, T>;
+declare function goTryRaw<T>(fn: () => never): Result<Error, never>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(fn: () => never, options: GoTryRawOptions<E>): Result<E, never>;
+declare function goTryRaw<T>(fn: () => Promise<T>): Promise<Result<Error, T>>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(fn: () => Promise<T>, options: GoTryRawOptions<E>): Promise<Result<E, T>>;
+declare function goTryRaw<T>(promise: Promise<T>): Promise<Result<Error, T>>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(promise: Promise<T>, options: GoTryRawOptions<E>): Promise<Result<E, T>>;
+declare function goTryRaw<T>(fn: () => T): Result<Error, T>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(fn: () => T, options: GoTryRawOptions<E>): Result<E, T>;
+declare function goTryRaw<T>(value: T): Result<Error, T>;
+declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(value: T, options: GoTryRawOptions<E>): Result<E, T>;
 
 /**
  * Executes a function, promise, or value and returns a Result type with a fallback default.
@@ -301,6 +350,6 @@ declare function failure<E>(error: E): Failure<E>;
  */
 declare function assertNever(value: never): never;
 
-export { assert, assertNever, failure, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };
-export type { ErrorConstructor, Failure, GoTryAllOptions, MaybePromise, Result, ResultWithDefault, Success, TaggedError, TaggedUnion };
+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 };
 //# 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/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;;;AAE5B;;;;;;;;;;;;;AAaM,KAAM,WAAW,oBAAoB,gBAAgB;iCAC1B,gBAAgB;;;AC7CjD;;;;;;;;;;;;;;;;;;;;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;;ACxB1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,iBAAgB,QAAQ,QAAQ,KAAK,oBAAoB,MAAM;AAC/D,iBAAgB,QAAQ,QAAQ,KAAK,+BAA+B,gBAAgB,MAAM,MAAM;AAChG,iBAAgB,QAAQ,QAAQ,KAAK,YACzB,OAAO,MAChB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,QAAQ,KAAK,YACzB,OAAO,iBACL,gBAAgB,MAC3B,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,QAAQ,KAAK,WAC1B,OAAO,MACf,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,QAAQ,KAAK,WAC1B,OAAO,iBACJ,gBAAgB,MAC3B,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,QAAQ,KAAK,gBAAgB,MAAM;AAC3D,iBAAgB,QAAQ,QAAQ,KAAK,2BAA2B,gBAAgB,MAAM,MAAM;AAC5F,iBAAgB,QAAQ,QAAQ,KAAK,aAAa,MAAM;AACxD,iBAAgB,QAAQ,QAAQ,KAAK,wBAAwB,gBAAgB,MAAM,MAAM;;AC/CzF;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;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":[]}

package/dist/index.mjs

@@ -48,16 +48,46 @@ function goTry(value) {
   }
 }
 
-function goTryRaw(value, ErrorClass) {
+function taggedError(tag) {
+  return class TaggedErrorClass extends Error {
+    constructor(message, options) {
+      super(message);
+      this._tag = tag;
+      this.name = tag;
+      this.cause = options?.cause;
+    }
+  };
+}
+
+const UnknownError = taggedError("UnknownError");
+
+function isTaggedError(err) {
+  return isError(err) && "_tag" in err && typeof err._tag === "string";
+}
+function goTryRaw(value, options) {
+  const { errorClass, systemErrorClass } = options || {};
+  const actualSystemErrorClass = systemErrorClass ?? UnknownError;
   const wrapError = (err) => {
-    if (ErrorClass) {
+    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));
+    }
+    if (actualSystemErrorClass) {
+      if (isTaggedError(err)) {
+        return err;
+      }
       if (err === void 0) {
-        return new ErrorClass("undefined");
+        return new actualSystemErrorClass("undefined");
       }
       if (isError(err)) {
-        return new ErrorClass(err.message, { cause: err });
+        return new actualSystemErrorClass(err.message, { cause: err });
       }
-      return new ErrorClass(String(err));
+      return new actualSystemErrorClass(String(err));
     }
     if (err === void 0) {
       return new Error("undefined");
@@ -151,17 +181,6 @@ async function goTryAllRaw(items, options) {
   return [errors, results];
 }
 
-function taggedError(tag) {
-  return class TaggedErrorClass extends Error {
-    constructor(message, options) {
-      super(message);
-      this._tag = tag;
-      this.name = tag;
-      this.cause = options?.cause;
-    }
-  };
-}
-
 function assert(condition, errorOrClass, message) {
   if (!condition) {
     if (typeof errorOrClass === "string") {
@@ -174,4 +193,4 @@ function assert(condition, errorOrClass, message) {
   }
 }
 
-export { assert, assertNever, failure, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };
+export { UnknownError, assert, assertNever, failure, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "go-go-try",
-	"version": "7.3.0",
+	"version": "7.4.0",
 	"description": "Tries to execute a sync/async function, returns a result tuple",
 	"license": "MIT",
 	"repository": "thelinuxlich/go-go-try",
@@ -48,11 +48,11 @@
 	],
 	"devDependencies": {
 		"@ark/attest": "^0.56.0",
-		"@biomejs/biome": "^2.3.14",
+		"@biomejs/biome": "^2.4.2",
 		"@vitest/coverage-v8": "^4.0.18",
 		"husky": "^9.1.7",
 		"lint-staged": "^16.2.7",
-		"pkgroll": "^2.23.0",
+		"pkgroll": "^2.26.2",
 		"tsx": "^4.21.0",
 		"typescript": "^5.9.3",
 		"vitest": "^4.0.18"

package/src/goTryRaw.ts

@@ -1,15 +1,23 @@
-import type { Result, ErrorConstructor } from './types.js'
+import type { Result, GoTryRawOptions } from './types.js'
 import { success, failure } from './result-helpers.js'
 import { isPromise, isError } 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'
+}
 
 /**
  * Executes a function, promise, or value and returns a Result type.
  * If an error occurs, it returns a Failure with the raw error object.
  *
  * @template T The type of the successful result
- * @template E The type of the error, defaults to Error
+ * @template E The type of the error
  * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
- * @param {ErrorConstructor<E>} [ErrorClass] - Optional error constructor to wrap caught errors
+ * @param {GoTryRawOptions<E>} [options] - Optional options object
  * @returns {Result<E, T> | Promise<Result<E, T>>} A Result type or a Promise of a Result type
  *
  * @example
@@ -25,47 +33,76 @@ import { isPromise, isError } from './internals.js'
  * const [err, result] = await goTryRaw(fetch('https://api.example.com/data'));
  *
  * @example
- * // With tagged error for discriminated unions
+ * // With options object - wrap all errors
  * const DatabaseError = taggedError('DatabaseError');
- * const [err, result] = await goTryRaw(fetchData(), DatabaseError);
- * // err is InstanceType<typeof DatabaseError> | undefined
+ * const [err, result] = await goTryRaw(fetchData(), { errorClass: DatabaseError });
+ *
+ * @example
+ * // With options object - systemErrorClass only wraps non-tagged errors
+ * const [err, result] = await goTryRaw(fetchData(), { systemErrorClass: UnknownError });
+ * // Errors thrown as tagged errors pass through
+ * // Other errors are wrapped in UnknownError
  */
-export function goTryRaw<T, E = Error>(fn: () => never): Result<E, never>
-export function goTryRaw<T, E = Error>(fn: () => never, ErrorClass: ErrorConstructor<E>): Result<E, never>
-export function goTryRaw<T, E = Error>(
+export function goTryRaw<T>(fn: () => never): Result<Error, never>
+export function goTryRaw<T, E = InstanceType<typeof UnknownError>>(fn: () => never, options: GoTryRawOptions<E>): Result<E, never>
+export function goTryRaw<T>(
   fn: () => Promise<T>,
-): Promise<Result<E, T>>
-export function goTryRaw<T, E = Error>(
+): Promise<Result<Error, T>>
+export function goTryRaw<T, E = InstanceType<typeof UnknownError>>(
   fn: () => Promise<T>,
-  ErrorClass: ErrorConstructor<E>,
+  options: GoTryRawOptions<E>,
 ): Promise<Result<E, T>>
-export function goTryRaw<T, E = Error>(
+export function goTryRaw<T>(
   promise: Promise<T>,
-): Promise<Result<E, T>>
-export function goTryRaw<T, E = Error>(
+): Promise<Result<Error, T>>
+export function goTryRaw<T, E = InstanceType<typeof UnknownError>>(
   promise: Promise<T>,
-  ErrorClass: ErrorConstructor<E>,
+  options: GoTryRawOptions<E>,
 ): Promise<Result<E, T>>
-export function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>
-export function goTryRaw<T, E = Error>(fn: () => T, ErrorClass: ErrorConstructor<E>): Result<E, T>
-export function goTryRaw<T, E = Error>(value: T): Result<E, T>
-export function goTryRaw<T, E = Error>(value: T, ErrorClass: ErrorConstructor<E>): Result<E, T>
+export function goTryRaw<T>(fn: () => T): Result<Error, T>
+export function goTryRaw<T, E = InstanceType<typeof UnknownError>>(fn: () => T, options: GoTryRawOptions<E>): Result<E, T>
+export function goTryRaw<T>(value: T): Result<Error, T>
+export function goTryRaw<T, E = InstanceType<typeof UnknownError>>(value: T, options: GoTryRawOptions<E>): Result<E, T>
 export function goTryRaw<T, E = Error>(
   value: T | Promise<T> | (() => T | Promise<T>),
-  ErrorClass?: ErrorConstructor<E>,
+  options?: GoTryRawOptions<E>,
 ): Result<E, T> | Promise<Result<E, T>> {
-  // Helper to wrap error in the provided class or return as-is
+  const { errorClass, systemErrorClass } = options || {}
+
+  // Determine the actual system error class to use
+  // Default to UnknownError when systemErrorClass is not specified
+  const actualSystemErrorClass = systemErrorClass ?? UnknownError
+
+  // Helper to wrap error based on the options
   const wrapError = (err: unknown): E => {
-    if (ErrorClass) {
+    // If errorClass is specified, wrap all errors with it
+    if (errorClass) {
       if (err === undefined) {
-        return new ErrorClass('undefined')
+        return new errorClass('undefined')
       }
       if (isError(err)) {
-        return new ErrorClass(err.message, { cause: err })
+        return new errorClass(err.message, { cause: err })
       }
-      return new ErrorClass(String(err))
+      return new errorClass(String(err))
     }
-    // Default behavior: return raw error
+
+    // If actualSystemErrorClass is specified, only wrap non-tagged errors
+    if (actualSystemErrorClass) {
+      if (isTaggedError(err)) {
+        return err as unknown as E
+      }
+
+      // Wrap non-tagged errors with systemErrorClass
+      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
+    }
+
+    // No options - original behavior: return raw error
     if (err === undefined) {
       return new Error('undefined') as unknown as E
     }

package/src/index.test.ts

@@ -15,6 +15,7 @@ import {
   isSuccess,
   success,
   taggedError,
+  UnknownError,
 } from './index.js'
 
 test(`value returned by callback is used when callback doesn't throw`, async () => {
@@ -319,8 +320,12 @@ describe('edge cases', () => {
     assert.equal(value1, undefined)
     assert.equal(value2, undefined)
     assert.equal(err1, 'custom error')
-    assert.equal(err2 instanceof CustomError, true)
-    assert.equal((err2 as CustomError).code, 500)
+    // goTryRaw now wraps errors in UnknownError by default
+    assert.equal(err2 instanceof UnknownError, true)
+    assert.equal((err2 as InstanceType<typeof UnknownError>)?._tag, 'UnknownError')
+    assert.equal(err2?.message, 'custom error')
+    // Original error is preserved in cause
+    assert.equal(((err2 as unknown as { cause?: unknown })?.cause as CustomError)?.code, 500)
   })
 
   test('throwing a string', () => {
@@ -367,38 +372,41 @@ describe('assert helper', () => {
   })
 
   test('throws with string message when condition is false', () => {
+    let caught = false
     try {
       assertTry(false, 'custom error message')
-      // Should not reach here
-      assert.equal(true, false)
     } catch (err) {
+      caught = true
       assert.ok(err instanceof Error)
       assert.equal((err as Error).message, 'custom error message')
     }
+    assert.equal(caught, true)
   })
 
   test('throws with Error instance when condition is false', () => {
     const customError = new Error('custom error instance')
+    let caught = false
     try {
       assertTry(false, customError)
-      // Should not reach here
-      assert.equal(true, false)
     } catch (err) {
+      caught = true
       assert.equal(err, customError)
     }
+    assert.equal(caught, true)
   })
 
   test('throws with tagged error when condition is false', () => {
     const DatabaseError = taggedError('DatabaseError')
+    let caught = false
     try {
       assertTry(false, new DatabaseError('database connection failed'))
-      // Should not reach here
-      assert.equal(true, false)
     } catch (err) {
+      caught = true
       assert.ok(err instanceof DatabaseError)
       assert.equal((err as InstanceType<typeof DatabaseError>)._tag, 'DatabaseError')
       assert.equal((err as Error).message, 'database connection failed')
     }
+    assert.equal(caught, true)
   })
 
   test('type narrowing works with Result types using err === undefined', () => {
@@ -434,7 +442,7 @@ describe('assert helper', () => {
 
   test('type narrowing works with tagged errors', () => {
     const DatabaseError = taggedError('DatabaseError')
-    const [err, user] = goTryRaw(() => ({ id: '123', name: 'John' }), DatabaseError)
+    const [err, user] = goTryRaw(() => ({ id: '123', name: 'John' }), { errorClass: DatabaseError })
 
     // Before assert
     attest<InstanceType<typeof DatabaseError> | undefined>(err)
@@ -452,13 +460,13 @@ describe('assert helper', () => {
     const DatabaseError = taggedError('DatabaseError')
 
     function fetchUserOldStyle(): Result<InstanceType<typeof DatabaseError>, { id: string }> {
-      const [err, user] = goTryRaw(() => ({ id: '123' }), DatabaseError)
+      const [err, user] = goTryRaw(() => ({ id: '123' }), { errorClass: DatabaseError })
       if (err) return failure(err)  // Old style
       return [undefined, user] as const
     }
 
     function fetchUserNewStyle(): Result<InstanceType<typeof DatabaseError>, { id: string }> {
-      const [err, user] = goTryRaw(() => ({ id: '123' }), DatabaseError)
+      const [err, user] = goTryRaw(() => ({ id: '123' }), { errorClass: DatabaseError })
       assertTry(err === undefined, new DatabaseError('Failed to fetch user'))
       // TypeScript now knows user is defined
       return [undefined, user] as const
@@ -526,7 +534,7 @@ describe('assert helper', () => {
 
   test('shorter syntax with tagged errors provides type narrowing', () => {
     const DatabaseError = taggedError('DatabaseError')
-    const [err, user] = goTryRaw(() => ({ id: '123', name: 'John' }), DatabaseError)
+    const [err, user] = goTryRaw(() => ({ id: '123', name: 'John' }), { errorClass: DatabaseError })
 
     // Before assert
     attest<InstanceType<typeof DatabaseError> | undefined>(err)
@@ -1187,8 +1195,8 @@ describe('taggedError', () => {
     }
 
     // Wrap in functions so goTryRaw can catch the errors
-    const [dbErr, dbResult] = goTryRaw(fetchFromDb, DatabaseError)
-    const [netErr, netResult] = goTryRaw(fetchFromNetwork, NetworkError)
+    const [dbErr, dbResult] = goTryRaw(fetchFromDb, { errorClass: DatabaseError })
+    const [netErr, netResult] = goTryRaw(fetchFromNetwork, { errorClass: NetworkError })
 
     // Type narrowing via discriminated union
     if (dbErr) {
@@ -1214,14 +1222,14 @@ describe('taggedError', () => {
     async function fetchUser(id: string): Promise<Result<AppError, { id: string; name: string }>> {
       const [dbErr, user] = await goTryRaw(
         Promise.resolve({ id, name: 'John' }),
-        DatabaseError,
+        { errorClass: DatabaseError },
       )
       if (dbErr) return failure<AppError>(dbErr)
       return [undefined, user] as const
     }
 
     async function fetchData(): Promise<Result<AppError, string>> {
-      const [netErr, data] = await goTryRaw(Promise.resolve('data'), NetworkError)
+      const [netErr, data] = await goTryRaw(Promise.resolve('data'), { errorClass: NetworkError })
       if (netErr) return failure<AppError>(netErr)
       return [undefined, data] as const
     }
@@ -1374,7 +1382,7 @@ describe('TaggedUnion type helper', () => {
     async function fetchData(): Promise<Result<AppError, string>> {
       const [err, data] = await goTryRaw(
         Promise.reject(new Error('timeout')),
-        NetworkError,
+        { errorClass: NetworkError },
       )
       if (err) return failure<AppError>(err)
       return [undefined, data] as const
@@ -1398,14 +1406,14 @@ describe('inferred return types with tagged errors', () => {
       // First operation might fail with DatabaseError
       const [dbErr, user] = await goTryRaw(
         Promise.resolve({ id, name: 'John' }),
-        DatabaseError,
+        { errorClass: DatabaseError },
       )
       if (dbErr) return failure(dbErr)
 
       // Second operation might fail with NetworkError
       const [netErr, enriched] = await goTryRaw(
         Promise.resolve({ ...user!, email: 'john@example.com' }),
-        NetworkError,
+        { errorClass: NetworkError },
       )
       if (netErr) return failure(netErr)
 
@@ -1443,14 +1451,14 @@ describe('inferred return types with tagged errors', () => {
     // No explicit return type annotation
     function processConfig(input: string) {
       // Parse step
-      const [parseErr, parsed] = goTryRaw(() => JSON.parse(input), ParseError)
+      const [parseErr, parsed] = goTryRaw(() => JSON.parse(input), { errorClass: ParseError })
       if (parseErr) return failure(parseErr)
 
       // Validate step
       const [validateErr, validated] = goTryRaw(() => {
         if (!parsed!.port) throw new Error('Missing port')
         return parsed as { port: number }
-      }, ValidateError)
+      }, { errorClass: ValidateError })
       if (validateErr) return failure(validateErr)
 
       return [undefined, validated] as const
@@ -1481,19 +1489,19 @@ describe('inferred return types with tagged errors', () => {
     async function complexOperation(shouldFail: 'a' | 'b' | 'c' | 'none') {
       const [errA, valA] = await goTryRaw(
         shouldFail === 'a' ? Promise.reject(new Error('a')) : Promise.resolve('step1'),
-        ErrorA,
+        { errorClass: ErrorA },
       )
       if (errA) return failure(errA)
 
       const [errB, valB] = await goTryRaw(
         shouldFail === 'b' ? Promise.reject(new Error('b')) : Promise.resolve('step2'),
-        ErrorB,
+        { errorClass: ErrorB },
       )
       if (errB) return failure(errB)
 
       const [errC, valC] = await goTryRaw(
         shouldFail === 'c' ? Promise.reject(new Error('c')) : Promise.resolve('step3'),
-        ErrorC,
+        { errorClass: ErrorC },
       )
       if (errC) return failure(errC)
 
@@ -1530,3 +1538,204 @@ describe('inferred return types with tagged errors', () => {
     )
   })
 })
+
+
+describe('UnknownError', () => {
+  test('UnknownError is exported as a tagged error class', () => {
+    const err = new UnknownError('something went wrong')
+    assert.equal(err._tag, 'UnknownError')
+    assert.equal(err.message, 'something went wrong')
+    assert.equal(err.name, 'UnknownError')
+    assert.ok(err instanceof Error)
+    assert.ok(err instanceof UnknownError)
+  })
+
+  test('UnknownError supports cause option', () => {
+    const cause = new Error('original error')
+    const err = new UnknownError('wrapped error', { cause })
+    assert.equal(err.cause, cause)
+  })
+
+  test('goTryRaw defaults to UnknownError for system errors', () => {
+    const fn = () => {
+      throw new Error('system error')
+    }
+
+    const [err, value] = goTryRaw(fn)
+
+    assert.equal(value, undefined)
+    assert.ok(err instanceof UnknownError)
+    assert.equal(err._tag, 'UnknownError')
+    assert.equal(err.message, 'system error')
+  })
+
+  test('goTryRaw defaults to UnknownError for thrown strings', () => {
+    const fn = () => {
+      throw 'string error'
+    }
+
+    const [err, value] = goTryRaw(fn)
+
+    assert.equal(value, undefined)
+    assert.ok(err instanceof UnknownError)
+    assert.equal(err._tag, 'UnknownError')
+    assert.equal(err.message, 'string error')
+  })
+
+  test('goTryRaw defaults to UnknownError for thrown undefined', () => {
+    const fn = () => {
+      throw undefined
+    }
+
+    const [err, value] = goTryRaw(fn)
+
+    assert.equal(value, undefined)
+    assert.ok(err instanceof UnknownError)
+    assert.equal(err._tag, 'UnknownError')
+    assert.equal(err.message, 'undefined')
+  })
+
+  test('goTryRaw with async defaults to UnknownError', async () => {
+    const promise = Promise.reject(new Error('async error'))
+
+    const [err, value] = await goTryRaw(promise)
+
+    assert.equal(value, undefined)
+    assert.ok(err instanceof UnknownError)
+    assert.equal(err._tag, 'UnknownError')
+    assert.equal(err.message, 'async error')
+  })
+})
+
+describe('goTryRaw with options object', () => {
+  test('errorClass wraps all errors including tagged ones', () => {
+    const DatabaseError = taggedError('DatabaseError')
+    const NetworkError = taggedError('NetworkError')
+
+    // When a DatabaseError is thrown, it gets wrapped in NetworkError
+    const fn = () => {
+      throw new DatabaseError('db connection failed')
+    }
+
+    const [err, value] = goTryRaw(fn, { errorClass: NetworkError })
+
+    assert.equal(value, undefined)
+    assert.ok(err instanceof NetworkError)
+    assert.equal(err._tag, 'NetworkError')
+    assert.equal(err.message, 'db connection failed')
+    // Original error is preserved in cause
+    assert.ok(err.cause instanceof DatabaseError)
+  })
+
+  test('errorClass wraps non-tagged errors', () => {
+    const NetworkError = taggedError('NetworkError')
+
+    const fn = () => {
+      throw new Error('plain error')
+    }
+
+    const [err, value] = goTryRaw(fn, { errorClass: NetworkError })
+
+    assert.equal(value, undefined)
+    assert.ok(err instanceof NetworkError)
+    assert.equal(err._tag, 'NetworkError')
+    assert.equal(err.message, 'plain error')
+  })
+
+  test('systemErrorClass only wraps non-tagged errors', () => {
+    const DatabaseError = taggedError('DatabaseError')
+    const SystemError = taggedError('SystemError')
+
+    // Tagged errors should pass through
+    const fnTagged = () => {
+      throw new DatabaseError('db error')
+    }
+
+    const [err1, value1] = goTryRaw(fnTagged, { systemErrorClass: SystemError })
+
+    assert.equal(value1, undefined)
+    assert.ok(err1 instanceof DatabaseError)
+    assert.equal(err1._tag, 'DatabaseError')
+
+    // Non-tagged errors should be wrapped
+    const fnPlain = () => {
+      throw new Error('system error')
+    }
+
+    const [err2, value2] = goTryRaw(fnPlain, { systemErrorClass: SystemError })
+
+    assert.equal(value2, undefined)
+    assert.ok(err2 instanceof SystemError)
+    assert.equal(err2._tag, 'SystemError')
+    assert.equal(err2.message, 'system error')
+  })
+
+  test('systemErrorClass defaults to UnknownError when not specified', () => {
+    const fn = () => {
+      throw new Error('plain error')
+    }
+
+    const [err, value] = goTryRaw(fn, {})
+
+    assert.equal(value, undefined)
+    assert.ok(err instanceof UnknownError)
+    assert.equal(err._tag, 'UnknownError')
+  })
+
+  test('async with options object', async () => {
+    const DatabaseError = taggedError('DatabaseError')
+
+    const promise = Promise.reject(new Error('async error'))
+
+    const [err, value] = await goTryRaw(promise, { errorClass: DatabaseError })
+
+    assert.equal(value, undefined)
+    assert.ok(err instanceof DatabaseError)
+    assert.equal(err._tag, 'DatabaseError')
+  })
+
+})
+
+describe('goTryRaw options type tests', () => {
+  test('systemErrorClass preserves tagged errors', () => {
+    const DatabaseError = taggedError('DatabaseError')
+    const SystemError = taggedError('SystemError')
+
+    // Wrap in a function so goTryRaw can catch the error
+    const [err, _value] = goTryRaw(() => {
+      throw new DatabaseError('db error')
+    }, { systemErrorClass: SystemError })
+
+    // Type is systemErrorClass since TypeScript cannot know which tagged errors
+    // might be thrown at runtime (tagged errors pass through, others get wrapped)
+    attest<InstanceType<typeof SystemError> | undefined>(err)
+
+    // But at runtime, tagged errors are preserved
+    if (err) {
+      assert.equal(err._tag, 'DatabaseError')
+    }
+  })
+
+  test('errorClass wraps all errors to specified type', () => {
+    const DatabaseError = taggedError('DatabaseError')
+
+    const [err, value] = goTryRaw(() => 'test', { errorClass: DatabaseError })
+
+    attest<InstanceType<typeof DatabaseError> | undefined>(err)
+    attest<string | undefined>(value)
+  })
+
+  test('no options defaults to Error type (backward compatible)', () => {
+    const [err, value] = goTryRaw(() => 'test')
+
+    attest<Error | undefined>(err)
+    attest<string | undefined>(value)
+  })
+
+  test('empty options object defaults to UnknownError type', () => {
+    const [err, value] = goTryRaw(() => 'test', {})
+
+    attest<InstanceType<typeof UnknownError> | undefined>(err)
+    attest<string | undefined>(value)
+  })
+})

package/src/index.ts

@@ -9,6 +9,7 @@ export type {
   GoTryAllOptions,
   ErrorConstructor,
   TaggedUnion,
+  GoTryRawOptions,
 } from './types.js'
 
 // Export core functions
@@ -21,3 +22,6 @@ export { goTryAll, goTryAllRaw } from './goTryAll.js'
 export { taggedError } from './tagged-error.js'
 export { assert } from './assert.js'
 export { isSuccess, isFailure, success, failure, assertNever } from './result-helpers.js'
+
+// Export UnknownError tagged error
+export { UnknownError } from './unknown-error.js'

package/src/types.ts

@@ -33,6 +33,20 @@ export interface GoTryAllOptions {
  */
 export type ErrorConstructor<E> = new (message: string, options?: { cause?: unknown }) => E
 
+/**
+ * Checks if a value is a tagged error (has a _tag property).
+ */
+export type IsTaggedError<T> = T extends { _tag: string } ? true : false
+
+/**
+ * Options for goTryRaw function.
+ * errorClass and systemErrorClass are mutually exclusive - you can only provide one.
+ */
+export type GoTryRawOptions<E = Error> =
+  | { errorClass: ErrorConstructor<E>; systemErrorClass?: never }
+  | { errorClass?: never; systemErrorClass: ErrorConstructor<E> }
+  | { errorClass?: never; systemErrorClass?: never }
+
 /**
  * Creates a union type from multiple tagged error classes.
  *

package/src/unknown-error.ts

@@ -0,0 +1,20 @@
+import { taggedError } from './tagged-error.js'
+
+/**
+ * Default system error class for errors that aren't already wrapped in a tagged error class.
+ *
+ * @example
+ * // By default, goTryRaw wraps unknown errors in UnknownError
+ * const [err, result] = goTryRaw(() => mightThrow())
+ * if (err) {
+ *   console.log(err._tag) // 'UnknownError'
+ * }
+ *
+ * @example
+ * // Use a custom system error class
+ * const SystemError = taggedError('SystemError')
+ * const [err, result] = goTryRaw(() => mightThrow(), {
+ *   systemErrorClass: SystemError
+ * })
+ */
+export const UnknownError = taggedError('UnknownError')