@@ -113,17 +113,7 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 	// The waiting tasks, so that `.clear()` can reject their promises.
 	readonly #waitingTasks = new Set<WaitingTask>();
 
-	/**
-	Get or set the default timeout. A change applies to tasks added after it.
-
-	@example
-	```
-	const queue = new PQueue({timeout: 5000});
-
-	queue.timeout = 10000;
-	```
-	*/
-	timeout?: number | undefined;
+	#timeout: number | undefined;
 
 	constructor(options?: Options<QueueType, EnqueueOptionsType>) {
 		super();
@@ -170,9 +160,6 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 		this.#queue = new options.queueClass!();
 		this.#queueClass = options.queueClass!;
 		this.concurrency = options.concurrency!;
-
-		validateTimeout(options.timeout);
-
 		this.timeout = options.timeout;
 		this.#isPaused = options.autoStart === false;
 
@@ -571,7 +558,7 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 
 		// Create a copy to avoid mutating the original options object
 		options = {
-			timeout: this.timeout,
+			timeout: this.#timeout,
 			...options,
 			id,
 		};
@@ -740,6 +727,26 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 		});
 	}
 
+	/**
+	Get or set the default timeout. A change applies to tasks added after it.
+
+	@example
+	```
+	const queue = new PQueue({timeout: 5000});
+
+	queue.timeout = 10000;
+	```
+	*/
+	get timeout(): number | undefined {
+		return this.#timeout;
+	}
+
+	// Validated here, not only in `.add()`, so that an invalid value throws where it is set, instead of making every later `.add()` reject.
+	set timeout(timeout: number | undefined) {
+		validateTimeout(timeout);
+		this.#timeout = timeout;
+	}
+
 	get concurrency(): number {
 		return this.#concurrency;
 	}
 
@@ -155,9 +155,10 @@ test('timeout up to the maximum timer delay is accepted, and a larger one is rej
 	await assert.rejects(queue.add(async () => 'ignored', {timeout: maximumDelay + 1}), expectedError);
 	await assert.rejects(queue.add(async () => 'ignored', {timeout: Number.MAX_SAFE_INTEGER}), expectedError);
 
-	// The setter does not validate, so the next `.add()` rejects instead.
-	queue.timeout = maximumDelay + 1;
-	await assert.rejects(queue.add(async () => 'ignored'), expectedError);
+	assert.throws(() => {
+		queue.timeout = maximumDelay + 1;
+	}, expectedError);
+	assert.equal(queue.timeout, undefined);
 	assert.equal(addedCount, 0);
 	assert.equal(queue.pending, 0);
 	assert.equal(queue.size, 0);
@@ -386,3 +387,30 @@ test('interval must be a finite number from 0 and up', () => {
 	new PQueue({interval: 0}); // eslint-disable-line no-new
 	new PQueue({interval: 10}); // eslint-disable-line no-new
 });
+
+test('setting an invalid `timeout` on the queue throws and keeps the previous value', async () => {
+	const queue = new PQueue({timeout: 1000});
+
+	const assertRejected = (timeout: unknown) => {
+		assert.throws(() => {
+			queue.timeout = timeout as number;
+		}, {name: 'TypeError', message: /Expected `timeout` to be a positive finite number/v});
+	};
+
+	assertRejected(0);
+	assertRejected(-1);
+	assertRejected(NaN);
+	assertRejected(Infinity);
+	assertRejected(2_147_483_648);
+	assertRejected('1000');
+
+	assert.equal(queue.timeout, 1000);
+	assert.equal(await queue.add(() => '🦄'), '🦄');
+
+	queue.timeout = 2000;
+	assert.equal(queue.timeout, 2000);
+
+	queue.timeout = undefined;
+	assert.equal(queue.timeout, undefined);
+	assert.equal(await queue.add(() => '🦄'), '🦄');
+});