@@ -12,6 +12,7 @@ import {effect, EffectRef} from '../render3/reactivity/effect';
 import {signal, signalAsReadonlyFn, WritableSignal} from '../render3/reactivity/signal';
 import {untracked} from '../render3/reactivity/untracked';
 import {
+  PromiseResourceOptions,
   Resource,
   ResourceDependencyError,
   ResourceOptions,
@@ -74,14 +75,17 @@ export function resource<T, R>(options: ResourceOptions<T, R>): ResourceRef<T |
     options as ResourceOptions<T, R> & {request: ResourceOptions<T, R>['params']}
   ).request;
   const params = options.params ?? oldNameForParams ?? (() => null!);
+  const isStreaming = isStreamingResourceOptions(options);
   return new ResourceImpl<T | undefined, R>(
     params,
-    getLoader(options),
+    isStreaming ? options.stream : createLoader(options),
     options.defaultValue,
     options.equal ? wrapEqualityFn(options.equal) : undefined,
     options.debugName,
     options.injector ?? inject(Injector),
     options.id as StateKey<T>,
+    undefined,
+    isStreaming,
   );
 }
 
@@ -210,6 +214,7 @@ export class ResourceImpl<T, R> extends BaseWritableResource<T> implements Resou
     injector: Injector,
     private transferCacheKey: StateKey<T> | undefined,
     getInitialStream?: (request: R) => Signal<ResourceStreamItem<T>> | undefined,
+    private readonly isStreaming = false,
   ) {
     if (isInParamsFunction()) {
       throw invalidResourceCreationInParams();
@@ -526,11 +531,17 @@ export class ResourceImpl<T, R> extends BaseWritableResource<T> implements Resou
       // Resolve the pending task now that the resource has a value.
       resolvePendingTask?.();
       resolvePendingTask = undefined;
+
+      // For non-streaming resources, once the load is complete (settled),
+      // there is no longer an in-progress operation to abort.
+      if (!this.isStreaming && this.pendingController?.signal === abortSignal) {
+        this.pendingController = undefined;
+      }
     }
   }
 
   private abortInProgressLoad(): void {
-    untracked(() => this.pendingController?.abort());
+    untracked(() => this.pendingController?.abort(getAbortReason()));
     this.pendingController = undefined;
 
     // Once the load is aborted, we no longer want to block stability on its resolution.
@@ -539,6 +550,16 @@ export class ResourceImpl<T, R> extends BaseWritableResource<T> implements Resou
   }
 }
 
+let abortReason: DOMException | undefined;
+
+/**
+ * Returns a shared `AbortError` reason, since `abort()` without a reason creates a new one (with a
+ * stack trace) on every call, causing performance degradation on deep component trees.
+ */
+function getAbortReason(): DOMException {
+  return (abortReason ??= new DOMException('The operation was aborted.', 'AbortError'));
+}
+
 function saveToTransferState<R, T>(
   result: ResourceStreamItem<T> | undefined,
   transferCacheKey: StateKey<T> | undefined,
@@ -556,11 +577,9 @@ function wrapEqualityFn<T>(equal: ValueEqualityFn<T>): ValueEqualityFn<T | undef
   return (a, b) => (a === undefined || b === undefined ? a === b : equal(a, b));
 }
 
-function getLoader<T, R>(options: ResourceOptions<T, R>): ResourceStreamingLoader<T, R> {
-  if (isStreamingResourceOptions(options)) {
-    return options.stream;
-  }
-
+function createLoader<T, R>(
+  options: PromiseResourceOptions<T, R> & {debugName?: string},
+): ResourceStreamingLoader<T, R> {
   return async (params) => {
     try {
       return signal(
 
@@ -527,6 +527,79 @@ describe('resource', () => {
     expect(aborted).toEqual([{counter: 0}]);
   });
 
+  it('should reuse the same abort reason when aborting in-progress resource loads', async () => {
+    const signals: AbortSignal[] = [];
+    const injector = createEnvironmentInjector([], TestBed.inject(EnvironmentInjector));
+    const resources = [0, 1].map((id) =>
+      resource({
+        params: () => id,
+        loader: ({abortSignal}) => {
+          signals.push(abortSignal);
+          return new Promise(() => {}); // never resolves
+        },
+        injector,
+      }),
+    );
+
+    TestBed.tick();
+    await Promise.resolve();
+
+    resources.forEach((res) => res.destroy());
+
+    expect(signals.length).toBe(2);
+    expect(signals[0].aborted).toBeTrue();
+    expect(signals[0].reason).toEqual(jasmine.any(DOMException));
+    expect(signals[0].reason.name).toBe('AbortError');
+    expect(signals[1].reason).toBe(signals[0].reason);
+  });
+
+  it('should not abort completed non-streaming resources on destroy', async () => {
+    let capturedSignal: AbortSignal | undefined;
+    const res = resource({
+      loader: async ({abortSignal}) => {
+        capturedSignal = abortSignal;
+        return 'loaded';
+      },
+      injector: TestBed.inject(Injector),
+    });
+
+    TestBed.tick();
+    await flushMicrotasks();
+
+    expect(res.status()).toBe('resolved');
+    expect(res.value()).toBe('loaded');
+    expect(capturedSignal!.aborted).toBeFalse();
+
+    res.destroy();
+
+    // The load was already completed, so destroying the resource should not trigger abort
+    expect(capturedSignal!.aborted).toBeFalse();
+  });
+
+  it('should abort streaming resources on destroy using the shared abort reason', async () => {
+    let capturedSignal: AbortSignal | undefined;
+    const streamSignal = signal<any>({value: 42});
+    const res = resource({
+      stream: ({abortSignal}) => {
+        capturedSignal = abortSignal;
+        return streamSignal;
+      },
+      injector: TestBed.inject(Injector),
+    });
+
+    TestBed.tick();
+    await flushMicrotasks();
+
+    expect(res.status()).toBe('resolved');
+    expect(capturedSignal!.aborted).toBeFalse();
+
+    res.destroy();
+
+    expect(capturedSignal!.aborted).toBeTrue();
+    expect(capturedSignal!.reason).toEqual(jasmine.any(DOMException));
+    expect(capturedSignal!.reason.name).toBe('AbortError');
+  });
+
   it('should not respond to reactive state changes in a loader', async () => {
     const unrelated = signal('a');
     const backend = new MockResponseCountingBackend();