fix(signals): destroy hook doesn't run in injection context.

modules/signals/spec/helpers.ts

@@ -2,7 +2,8 @@ import { Component, inject, Type } from '@angular/core';
 import { TestBed } from '@angular/core/testing';
 
 export function createLocalService<Service extends Type<unknown>>(
-  serviceToken: Service
+  serviceToken: Service,
+  provideLocally = true
 ): {
   service: InstanceType<Service>;
   flushEffects: () => void;
@@ -11,7 +12,7 @@ export function createLocalService<Service extends Type<unknown>>(
   @Component({
     standalone: true,
     template: '',
-    providers: [serviceToken],
+    providers: provideLocally ? [serviceToken] : [],
   })
   class TestComponent {
     service = inject(serviceToken);

modules/signals/spec/signal-store.spec.ts

@@ -1,5 +1,11 @@
-import { inject, InjectionToken, isSignal, signal } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
+import {
+  inject,
+  Injectable,
+  InjectionToken,
+  isSignal,
+  signal,
+} from '@angular/core';
+import { TestBed, waitForAsync } from '@angular/core/testing';
 import {
   patchState,
   signalStore,
@@ -275,15 +281,16 @@ describe('signalStore', () => {
         factory: () => 'ngrx',
       });
       const Store = signalStore(
-        withHooks({
-          onInit() {
-            inject(TOKEN);
-            messages.push('onInit');
-          },
-          onDestroy() {
-            inject(TOKEN);
-            messages.push('onDestroy');
-          },
+        withHooks(() => {
+          const token = inject(TOKEN);
+          return {
+            onInit() {
+              messages.push('onInit');
+            },
+            onDestroy() {
+              messages.push('onDestroy');
+            },
+          };
         })
       );
       const { destroy } = createLocalService(Store);
@@ -293,6 +300,29 @@ describe('signalStore', () => {
       destroy();
       expect(messages).toEqual(['onInit', 'onDestroy']);
     });
+
+    it('runs a destroy hook in a root-scoped store during instantiation', waitForAsync(() => {
+      const TOKEN = new InjectionToken('TOKEN', {
+        providedIn: 'root',
+        factory: () => 'ngrx',
+      });
+      let value = '';
+      const Store = signalStore(
+        { providedIn: 'root' },
+        withHooks(() => {
+          const token = inject(TOKEN);
+          return {
+            onDestroy: () => {
+              value = token;
+            },
+          };
+        })
+      );
+
+      createLocalService(Store, false);
+      TestBed.resetTestEnvironment();
+      expect(value).toBe('ngrx');
+    }));
   });
 
   describe('composition', () => {

modules/signals/src/signal-store.ts

@@ -331,10 +331,9 @@ export function signalStore(
 
       if (hooks.onDestroy) {
         const injector = inject(Injector);
+        const { onDestroy } = hooks;
 
-        inject(DestroyRef).onDestroy(() => {
-          runInInjectionContext(injector, hooks.onDestroy!);
-        });
+        inject(DestroyRef).onDestroy(onDestroy);
       }
     }
   }

modules/signals/src/with-hooks.ts

@@ -16,13 +16,24 @@ type HooksFactory<Input extends SignalStoreFeatureResult> = (
   >
 ) => void;
 
-export function withHooks<Input extends SignalStoreFeatureResult>(hooks: {
+type HooksSupplier<Input extends SignalStoreFeatureResult> = () => {
   onInit?: HooksFactory<Input>;
   onDestroy?: HooksFactory<Input>;
-}): SignalStoreFeature<Input, EmptyFeatureResult> {
+};
+
+export function withHooks<Input extends SignalStoreFeatureResult>(
+  hooks:
+    | {
+        onInit?: HooksFactory<Input>;
+        onDestroy?: HooksFactory<Input>;
+      }
+    | HooksSupplier<Input>
+): SignalStoreFeature<Input, EmptyFeatureResult> {
   return (store) => {
-    const createHook = (name: keyof typeof hooks) => {
-      const hook = hooks[name];
+    const _hooks = typeof hooks === 'function' ? hooks() : hooks;
+
+    const createHook = (name: keyof typeof _hooks) => {
+      const hook = _hooks[name];
       const currentHook = store.hooks[name];
 
       return hook