Why do modules need to be DynamicModules to access environment.ts?

[Falven]

I read an old thread where it is recommended to share NX environment variables like the following:

import { environment } from '../environments/environment';

@Module({
    providers: [
        {
            provider: 'someProviderName',
            useValue: environment.someEnvironmentValue
        }
    ],
    MyService
})
class AppModule {
}

Then, you access like:

@Injectable()
class MyService {
    constructor(@Inject('someProviderName') someEnvironmentValue: someType) {
    }
}

The justifications are that:

1. It keeps your libs env independent.
2. It allows you to build libs once, without knowing the apps they are used by or the env they ran in.

What is the intended method of sharing these environment variables across library modules?

Does every library module that need access to environment variables need to be a dynamic module in order to take advantage of environment variables this way?

This will lead to unnecessary chains of dynamic modules.
Ex: AppModule (Needs ENV so it becomes DynamicModule) -> CoreModule (Needs env from AppModule so it becomes a DynamicModule) .. so on and so forth.

Also what would making all modules that need environment values into DynamicModules do to performance?

Example:

@Module({})
export class MyLibModule {
  static register(providers: Provider[]): DynamicModule {
    return {
      module: MyLibModule ,
      providers: [...providers],
    };
  }
}

const ENV_VALUE_PROVIDERS: ValueProvider[] = [
  {
    provide: 'PRODUCTION',
    useValue: environment.production,
  },
];
@Module({
  providers: ENV_VALUE_PROVIDERS,
  imports: [MyLibModule.register(ENV_VALUE_PROVIDERS)],
})
export class AppModule {}

I do not understand why we are forcing any lib modules to be dynamic to access environment variables if these variables are available at compile-time.