@@ -434,6 +434,10 @@ export class ResourceImpl<T, R> extends BaseWritableResource<T> implements Resou
     // we do not want the effect to depend on the state of the resource, only on the request.
     const {status: currentStatus, previousStatus} = untracked(this.state);
 
+    // A changed request invalidates the previous load even when the new params are unavailable
+    // or errored. Cancel it before returning so its pending task cannot keep the app unstable.
+    this.abortInProgressLoad();
+
     if (extRequest.request === undefined) {
       // Nothing to load (and we should already be in a non-loading state).
       return;
@@ -442,9 +446,6 @@ export class ResourceImpl<T, R> extends BaseWritableResource<T> implements Resou
       return;
     }
 
-    // Cancel any previous loading attempts.
-    this.abortInProgressLoad();
-
     // Capturing _this_ load's pending task in a local variable is important here. We may attempt to
     // resolve it twice:
     //
 
@@ -6,6 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
+import {timeout} from '@angular/private/testing';
+
 import {ApplicationRef, Injector, resource, ResourceParamsStatus, signal} from '../../src/core';
 import {TestBed} from '../../testing';
 
@@ -19,6 +21,42 @@ function throwStatusAndErrors<T>(source: () => T | ResourceParamsStatus | Error)
 }
 
 describe('resource with ResourceParamsStatus', () => {
+  for (const [paramsStatus, expectedStatus] of [
+    [ResourceParamsStatus.IDLE, 'idle'],
+    [ResourceParamsStatus.LOADING, 'loading'],
+    [new Error('params error'), 'error'],
+  ] as const) {
+    it(`should cancel a pending load and release stability when params throws ${expectedStatus}`, async () => {
+      const params = signal<string | ResourceParamsStatus | Error>('first');
+      const abortSignals: AbortSignal[] = [];
+      const res = resource({
+        params: throwStatusAndErrors(params),
+        loader: ({params, abortSignal}) => {
+          abortSignals.push(abortSignal);
+          // The first load deliberately remains pending even after it is aborted.
+          return params === 'first' ? new Promise<string>(() => {}) : Promise.resolve(params);
+        },
+        injector: TestBed.inject(Injector),
+      });
+      const appRef = TestBed.inject(ApplicationRef);
+
+      await timeout();
+      expect(abortSignals[0]?.aborted).toBeFalse();
+
+      params.set(paramsStatus);
+      await appRef.whenStable();
+
+      expect(res.status()).toBe(expectedStatus);
+      expect(abortSignals.map((signal) => signal.aborted)).toEqual([true]);
+
+      params.set('second');
+      await appRef.whenStable();
+
+      expect(res.snapshot()).toEqual({status: 'resolved', value: 'second'});
+      expect(abortSignals.map((signal) => signal.aborted)).toEqual([true, false]);
+    });
+  }
+
   it('should transition to idle when params throws ResourceParamsStatus.IDLE', async () => {
     const s = signal<string | ResourceParamsStatus>('foo');
     const res = await act(() =>
 
@@ -6,6 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
+import {timeout} from '@angular/private/testing';
+
 import {
   ApplicationRef,
   ɵCACHE_ACTIVE as CACHE_ACTIVE,
@@ -462,6 +464,72 @@ describe('resource', () => {
     expect(aborted).toEqual([{counter: 0}]);
   });
 
+  it('should cancel a pending load and release stability when params becomes undefined', async () => {
+    const params = signal<number | undefined>(1);
+    let abortSignal: AbortSignal | undefined;
+    const res = resource({
+      params,
+      loader: (options) => {
+        abortSignal = options.abortSignal;
+        // Aborting a loader does not require its promise to settle.
+        return new Promise<number>(() => {});
+      },
+      injector: TestBed.inject(Injector),
+    });
+    const appRef = TestBed.inject(ApplicationRef);
+
+    await timeout();
+    expect(abortSignal?.aborted).toBeFalse();
+
+    params.set(undefined);
+    await appRef.whenStable();
+
+    expect(abortSignal?.aborted).toBeTrue();
+    expect(res.snapshot()).toEqual({status: 'idle', value: undefined});
+  });
+
+  for (const settlement of ['resolve', 'reject'] as const) {
+    it(`should discard a cancelled load's late ${settlement} without releasing a newer load's pending task`, async () => {
+      const params = signal<number | undefined>(1);
+      const first = promiseWithResolvers<number>();
+      const second = promiseWithResolvers<number>();
+      const abortSignals: AbortSignal[] = [];
+      const res = resource({
+        params,
+        loader: ({params, abortSignal}) => {
+          abortSignals.push(abortSignal);
+          return params === 1 ? first.promise : second.promise;
+        },
+        injector: TestBed.inject(Injector),
+      });
+      const appRef = TestBed.inject(ApplicationRef);
+
+      await timeout();
+      params.set(undefined);
+      await appRef.whenStable();
+
+      params.set(2);
+      await timeout();
+
+      let stable = false;
+      const whenStable = appRef.whenStable().then(() => (stable = true));
+      if (settlement === 'resolve') {
+        first.resolve(1);
+      } else {
+        first.reject(new Error('cancelled load'));
+      }
+      await timeout();
+
+      expect(res.snapshot()).toEqual({status: 'loading', value: undefined});
+      expect(abortSignals.map((signal) => signal.aborted)).toEqual([true, false]);
+      expect(stable).toBeFalse();
+
+      second.resolve(2);
+      await whenStable;
+      expect(res.snapshot()).toEqual({status: 'resolved', value: 2});
+    });
+  }
+
   it('should cancel pending requests when the resource is destroyed via injector', async () => {
     const counter = signal(0);
     const backend = new MockEchoBackend<{counter: number}>();