export const booksRoutes: Routes = [
  {
    path: '',
    providers: [provideState(booksFeature), provideEffects(BooksEffects)],
    children: [
      { path: '', component: BookListComponent },
      { path: ':id', component: BookDetailComponent },
    ],
  },
];

function provideState(featureNameOrSlice, reducers, config = {}) {
    return makeEnvironmentProviders([
        ..._provideState(featureNameOrSlice, reducers, config),
        ENVIRONMENT_STATE_PROVIDER,
    ]);
}

function featureStateProviderFactory() {
    inject(ROOT_STORE_PROVIDER);
    const features = inject(_STORE_FEATURES);
    const featureReducers = inject(FEATURE_REDUCERS);
    const reducerManager = inject(ReducerManager);
    inject(_ACTION_TYPE_UNIQUENESS_CHECK, { optional: true });
    const feats = features.map((feature, index) => {
        const featureReducerCollection = featureReducers.shift();
        const reducers = featureReducerCollection[index];
        return {
            ...feature,
            reducers,
            initialState: _initialStateFactory(feature.initialState),
        };
    });
    reducerManager.addFeatures(feats);
}

const ENVIRONMENT_STATE_PROVIDER = [
    {
        provide: FEATURE_STATE_PROVIDER,
        useFactory: featureStateProviderFactory,
    },
    provideEnvironmentInitializer(() => inject(FEATURE_STATE_PROVIDER)),
];

function getOrCreateRouteInjectorIfNeeded(route, currentInjector) {
  if (route.providers && !route._injector) {
    route._injector = createEnvironmentInjector(route.providers, currentInjector, `Route: ${route.path}`);
  }
  return route._injector ?? currentInjector;
}

function matchWithChecks(segmentGroup, route, segments, injector, urlSerializer, createSnapshot, abortSignal) {
  const result = match(segmentGroup, route, segments);
  if (!result.matched) {
    return of(result);
  }
  const currentSnapshot = createPreMatchRouteSnapshot(createSnapshot(result));
  injector = getOrCreateRouteInjectorIfNeeded(route, injector);
  return runCanMatchGuards(injector, route, segments, urlSerializer, currentSnapshot, abortSignal).pipe(map(v => v === true ? result : {
    ...noMatch
  }));
}

@Reviewer: `provideState(adminFeature)` を `canActivate: [adminGuard]` のルートに置いていますが、ルートの注入器は `canMatch` より前に作られるため、ガードが拒否しても reducer は登録されます。DevTools や永続化のメタリデューサーに管理画面の state が出るので、state 自体を見せたくないのであれば、登録を遷移の成否と結び付けない形にしてください。

addFeatures(features) {
    const reducers = features.reduce((reducerDict, { reducers, reducerFactory, metaReducers, initialState, key }) => {
        const reducer = typeof reducers === 'function'
            ? createFeatureReducerFactory(metaReducers)(reducers, initialState)
            : createReducerFactory(reducerFactory, metaReducers)(reducers, initialState);
        reducerDict[key] = reducer;
        return reducerDict;
    }, {});
    this.addReducers(reducers);
}
removeFeatures(features) {
    this.removeReducers(features.map((p) => p.key));
}
addReducers(reducers) {
    this.reducers = { ...this.reducers, ...reducers };
    this.updateReducers(Object.keys(reducers));
}

ngOnDestroy() {
    this.reducerManager.removeFeatures(this.features);
}

return function combination(state, action) {
    state = state === undefined ? initialState : state;
    let hasChanged = false;
    const nextState = {};
    for (let i = 0; i < finalReducerKeys.length; i++) {
        const key = finalReducerKeys[i];
        const reducer = finalReducers[key];
        const previousStateForKey = state[key];
        const nextStateForKey = reducer(previousStateForKey, action);
        nextState[key] = nextStateForKey;
        hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
    }
    return hasChanged ? nextState : state;
};

export const booksFeature = createFeature({
  name: 'books',
  reducer: createReducer(
    initialState,
    on(BooksPageActions.leave, () => initialState),
    // ...
  ),
});

@Reviewer: 一覧から詳細へ入り、ブラウザの戻るで一覧へ帰ると前回の検索条件が残ります。`provideState` はルートから出ても reducer を外さず、`combineReducers` は残った slice を reducer へ渡すため、初期値へは戻りません。離脱時の Action を1つ置いて、reducer で初期値へ戻してください。

addReducers(reducers) {
    this.reducers = { ...this.reducers, ...reducers };
    this.updateReducers(Object.keys(reducers));
}

{
    provide: STORE_FEATURES,
    multi: true,
    useValue: {
        key: featureNameOrSlice instanceof Object
            ? featureNameOrSlice.name
            : featureNameOrSlice,
        // ...
    },
},

function createFeatureSelector(featureName) {
    return createSelector((state) => {
        const featureState = state[featureName];
        if (!isNgrxMockEnvironment() && isDevMode() && !(featureName in state)) {
            console.warn(`@ngrx/store: The feature name "${featureName}" does ` +
                'not exist in the state, therefore createFeatureSelector ' +
                'cannot access it.  Be sure it is imported in a loaded module ' +
                `using StoreModule.forRoot('${featureName}', ...) or ` +
                `StoreModule.forFeature('${featureName}', ...).  If the default ` +
                'state is intended to be undefined, as is the case with router ' +
                'state, this development-only warning message can be ignored.');
        }
        return featureState;
    }, (featureState) => featureState);
}

provideEnvironmentInitializer(() => {
    inject(ROOT_STORE_PROVIDER);
    inject(FEATURE_STATE_PROVIDER, { optional: true });
    const effectsRunner = inject(EffectsRunner);
    const effectSources = inject(EffectSources);
    const shouldInitEffects = !effectsRunner.isStarted;
    // ...
}),

return this.pipe(groupBy((effectsInstance) => isClassInstance(effectsInstance)
    ? getSourceForInstance(effectsInstance)
    : effectsInstance), mergeMap((source$) => {
    return source$.pipe(groupBy(effectsInstance));
}), mergeMap((source$) => {
    const effect$ = source$.pipe(exhaustMap((sourceInstance) => {
        return resolveEffectSource(this.errorHandler, this.effectsErrorHandler)(sourceInstance);
    }),
    // ...

providers?: Provider[];