diff --git a/package.json b/package.json
index 73a964b7c..fc450030b 100644
--- a/package.json
+++ b/package.json
@@ -21,7 +21,8 @@
     "docs"
   ],
   "scripts": {
-    "lint": "eslint --cache --fix --ext .js,.cjs",
+    "lint:staged": "eslint --cache --fix --ext .js,.cjs",
+    "lint": "eslint --cache --fix --ext .js,.cjs .",
     "lint:ci": "eslint --ext .js,.cjs .",
     "prettier": "prettier --cache --write *.md \"./**/*.md\"",
     "prettier:ci": "prettier *.md \"./**/*.md\"",
@@ -73,7 +74,7 @@
   },
   "lint-staged": {
     "**/*.js": [
-      "npm run lint"
+      "npm run lint:staged"
     ],
     "packages/**/*.js": [
       "npm run types:check"
diff --git a/packages/core/src/Router.js b/packages/core/src/Router.js
index e77fcd22e..da82d9645 100644
--- a/packages/core/src/Router.js
+++ b/packages/core/src/Router.js
@@ -157,7 +157,20 @@ export default class Router {
 					// TODO may need to bring that flushy thing back.
 					// Add a test to combvine flush with abort
 					// done();
-					reject(new DOMException('The operation was aborted.', 'AbortError'));
+					const error = new DOMException(
+						'The operation was aborted.',
+						'AbortError',
+					);
+
+					const requestBody = request?.body || options?.body;
+					if (requestBody instanceof ReadableStream) {
+						requestBody.cancel(error);
+					}
+
+					if (callLog?.response?.body) {
+						callLog.response.body.cancel(error);
+					}
+					reject(error);
 				};
 				if (callLog.signal.aborted) {
 					abort();
diff --git a/packages/core/src/__tests__/FetchMock/response-negotiation.test.js b/packages/core/src/__tests__/FetchMock/response-negotiation.test.js
index bf4191bf6..e0e3acb73 100644
--- a/packages/core/src/__tests__/FetchMock/response-negotiation.test.js
+++ b/packages/core/src/__tests__/FetchMock/response-negotiation.test.js
@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import fetchMock from '../../FetchMock';
 
 describe('response negotiation', () => {
@@ -164,63 +164,115 @@ describe('response negotiation', () => {
 	});
 
 	describe('abortable fetch', () => {
-		const RESPONSE_DELAY = 50;
-		const ABORT_DELAY = 10;
-
-		const getDelayedOk = () =>
-			new Promise((res) => setTimeout(() => res(200), RESPONSE_DELAY));
-
-		const getDelayedAbortController = () => {
+		const getDelayedAbortController = (delay) => {
 			const controller = new AbortController();
-			setTimeout(() => controller.abort(), ABORT_DELAY);
+			setTimeout(() => controller.abort(), delay);
 			return controller;
 		};
-		const expectAbortError = async (...fetchArgs) => {
-			const result = fm.fetchHandler(...fetchArgs);
-			await expect(result).rejects.toThrowError(
-				new DOMException('The operation was aborted.', 'ABortError'),
-			);
-		};
 
-		it('error on signal abort', () => {
-			fm.route('*', getDelayedOk());
-			return expectAbortError('http://a.com', {
-				signal: getDelayedAbortController().signal,
-			});
+		it('error on signal abort', async () => {
+			fm.route('*', 200, { delay: 50 });
+			await expect(
+				fm.fetchHandler('http://a.com', {
+					signal: getDelayedAbortController(10).signal,
+				}),
+			).rejects.toThrowError(
+				new DOMException('The operation was aborted.', 'AbortError'),
+			);
 		});
 
-		it('error on signal abort for request object', () => {
-			fm.route('*', getDelayedOk());
-			return expectAbortError(
-				new fm.config.Request('http://a.com', {
-					signal: getDelayedAbortController().signal,
-				}),
+		it('error on signal abort for request object', async () => {
+			fm.route('*', 200, { delay: 50 });
+			await expect(
+				fm.fetchHandler(
+					new fm.config.Request('http://a.com', {
+						signal: getDelayedAbortController(10).signal,
+					}),
+				),
+			).rejects.toThrowError(
+				new DOMException('The operation was aborted.', 'AbortError'),
 			);
 		});
 
-		it('error when signal already aborted', () => {
+		it('error when signal already aborted', async () => {
 			fm.route('*', 200);
 			const controller = new AbortController();
 			controller.abort();
-			return expectAbortError('http://a.com', {
-				signal: controller.signal,
+			await expect(
+				fm.fetchHandler('http://a.com', {
+					signal: controller.signal,
+				}),
+			).rejects.toThrowError(
+				new DOMException('The operation was aborted.', 'AbortError'),
+			);
+		});
+
+		it('aborts sending request options body stream', async () => {
+			fm.route('*', 200, { delay: 50 });
+			const body = new ReadableStream();
+			vi.spyOn(body, 'cancel');
+			await expect(
+				fm.fetchHandler('http://a.com', {
+					method: 'post',
+					body,
+					signal: getDelayedAbortController(10).signal,
+				}),
+			).rejects.toThrowError(
+				new DOMException('The operation was aborted.', 'AbortError'),
+			);
+			expect(body.cancel).toHaveBeenCalledWith(
+				new DOMException('The operation was aborted.', 'AbortError'),
+			);
+		});
+
+		// this doesn't work as the callLog creatde from the request awaits the body
+		it.skip('aborts sending request body stream', async () => {
+			fm.route('*', 200, { delay: 50 });
+			const body = new ReadableStream();
+			vi.spyOn(body, 'cancel');
+			const request = new Request('http://a.com', {
+				method: 'post',
+				body,
+				duplex: 'half',
+				signal: getDelayedAbortController(10).signal,
 			});
+			await expect(fm.fetchHandler(request)).rejects.toThrowError(
+				new DOMException('The operation was aborted.', 'AbortError'),
+			);
+			expect(body.cancel).toHaveBeenCalledWith(
+				new DOMException('The operation was aborted.', 'AbortError'),
+			);
+		});
+
+		it.skip('aborts receiving response body stream', async () => {
+			// so fiddly to implement a test for this. Uses the same mechanism as cancelling request body though
+			// so I trust that if one works the other does
 		});
 
 		it('go into `done` state even when aborted', async () => {
-			fm.once('http://a.com', getDelayedOk());
-			await expectAbortError('http://a.com', {
-				signal: getDelayedAbortController().signal,
-			});
+			fm.once('http://a.com', 200, { delay: 50 });
+
+			await expect(
+				fm.fetchHandler('http://a.com', {
+					signal: getDelayedAbortController(10).signal,
+				}),
+			).rejects.toThrowError(
+				new DOMException('The operation was aborted.', 'AbortError'),
+			);
+
 			expect(fm.callHistory.done()).toBe(true);
 		});
 
 		it('will flush even when aborted', async () => {
-			fm.route('http://a.com', getDelayedOk());
+			fm.route('http://a.com', 200, { delay: 50 });
 
-			await expectAbortError('http://a.com', {
-				signal: getDelayedAbortController().signal,
-			});
+			await expect(
+				fm.fetchHandler('http://a.com', {
+					signal: getDelayedAbortController(10).signal,
+				}),
+			).rejects.toThrowError(
+				new DOMException('The operation was aborted.', 'AbortError'),
+			);
 			await fm.callHistory.flush();
 			expect(fm.callHistory.done()).toBe(true);
 		});