fix: ensure abort reason is always wrapped as Error

Previously, when abort() was called with a non-Error reason or when an
external signal aborted with a non-Error value, the raw value would be
returned directly from unwrapErr(). This was inconsistent and could cause
type safety issues.

Now both the abort() method and catch block wrap non-Error abort reasons
into proper Error objects with name=AbortError, preserving the original
reason in error.cause.

Author: jarvisjiang

src/fetch/fetch.ts

@@ -500,7 +500,16 @@ export function fetchT<T>(url: string | URL, init?: FetchInit): FetchTask<T> | F
         } catch (err) {
             cancelTimer?.();
             removeAbortListener?.();
-            return Err(err as Error);
+
+            if (err instanceof Error) {
+                return Err(err);
+            }
+
+            // Non-Error type, most likely an abort reason
+            const error = new Error(typeof err === 'string' ? err : String(err));
+            error.name = ABORT_ERROR;
+            error.cause = err;
+            return Err(error);
         }
     };
 
@@ -563,7 +572,16 @@ export function fetchT<T>(url: string | URL, init?: FetchInit): FetchTask<T> | F
         return {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             abort(reason?: any): void {
-                masterController.abort(reason);
+                if (reason instanceof Error) {
+                    masterController.abort(reason);
+                } else if (reason != null) {
+                    const error = new Error(typeof reason === 'string' ? reason : String(reason));
+                    error.name = ABORT_ERROR;
+                    error.cause = reason;
+                    masterController.abort(error);
+                } else {
+                    masterController.abort();
+                }
             },
 
             get aborted(): boolean {

tests/fetch.test.ts

@@ -422,7 +422,10 @@ describe('fetchT', () => {
             setTimeout(() => fetchTask.abort('custom-cancel'), 50);
 
             const res = await fetchTask.response;
-            expect(res.unwrapErr()).toBe('custom-cancel');
+            const err = res.unwrapErr() as Error;
+            expect(err.name).toBe(ABORT_ERROR);
+            expect(err.message).toBe('custom-cancel');
+            expect(err.cause).toBe('custom-cancel');
         });
 
         it('should abort stream fetch with default reason', async () => {
@@ -449,7 +452,10 @@ describe('fetchT', () => {
 
             const res = await fetchTask.response;
             expect(res.isErr()).toBe(true);
-            expect(res.unwrapErr()).toBe('stream-cancelled');
+            const err = res.unwrapErr() as Error;
+            expect(err.name).toBe(ABORT_ERROR);
+            expect(err.message).toBe('stream-cancelled');
+            expect(err.cause).toBe('stream-cancelled');
         });
 
         it('should return FetchTask when abortable is true', () => {
@@ -467,6 +473,76 @@ describe('fetchT', () => {
             fetchTask.abort();
             expect(fetchTask.aborted).toBe(true);
         });
+
+        it('should abort fetch with Error reason', async () => {
+            const fetchTask = fetchT(`${ baseUrl }/api/slow`, {
+                abortable: true,
+            });
+
+            const customError = new Error('custom-error');
+            customError.name = 'CustomError';
+            setTimeout(() => fetchTask.abort(customError), 50);
+
+            const res = await fetchTask.response;
+            const err = res.unwrapErr() as Error;
+            expect(err).toBe(customError);
+            expect(err.name).toBe('CustomError');
+            expect(err.message).toBe('custom-error');
+        });
+
+        it('should handle external signal abort with string reason', async () => {
+            const externalController = new AbortController();
+
+            const response = fetchT(`${ baseUrl }/api/slow`, {
+                signal: externalController.signal,
+                responseType: 'text',
+            });
+
+            // Abort with a string reason via external controller
+            setTimeout(() => externalController.abort('external-abort-reason'), 50);
+
+            const res = await response;
+            expect(res.isErr()).toBe(true);
+            const err = res.unwrapErr() as Error;
+            expect(err.name).toBe(ABORT_ERROR);
+            expect(err.message).toBe('external-abort-reason');
+            expect(err.cause).toBe('external-abort-reason');
+        });
+
+        it('should handle external signal abort with non-string reason', async () => {
+            const externalController = new AbortController();
+
+            const response = fetchT(`${ baseUrl }/api/slow`, {
+                signal: externalController.signal,
+                responseType: 'text',
+            });
+
+            // Abort with a non-string reason (number) via external controller
+            setTimeout(() => externalController.abort(42), 50);
+
+            const res = await response;
+            expect(res.isErr()).toBe(true);
+            const err = res.unwrapErr() as Error;
+            expect(err.name).toBe(ABORT_ERROR);
+            expect(err.message).toBe('42');
+            expect(err.cause).toBe(42);
+        });
+
+        it('should abort fetch with non-string reason', async () => {
+            const fetchTask = fetchT(`${ baseUrl }/api/slow`, {
+                abortable: true,
+            });
+
+            // Abort with a non-string reason (object)
+            const reason = { code: 'CANCELLED', id: 123 };
+            setTimeout(() => fetchTask.abort(reason), 50);
+
+            const res = await fetchTask.response;
+            const err = res.unwrapErr() as Error;
+            expect(err.name).toBe(ABORT_ERROR);
+            expect(err.message).toBe('[object Object]');
+            expect(err.cause).toBe(reason);
+        });
     });
 
     // ============ Error Handling Tests ============