Unclear behavior of translateSignal() in combination with scopes / provideTranslocoScope()

[dw-0]

Hi, so im trying to figure out transloco's signal api and it mostly seems to make sense to me.
One thing is unclear to me though.

Im using an NX monorepo, have a frontend app and some frontend libraries.
The project structure looks something like this:

my-project/
├── apps/
│   ├── frontend/
│   │   ├── app/
│   │   │   ├── app.component.html
│   │   │   └── app.component.ts
│   │   └── src/
│   │        └── assets/
│   │           └── i18n/
│   │               └── en.json
│   └── config/
│       ├── app.config.ts
│       └── transloco.config.ts
│
├── libs/
│  └── frontend/ 
│      └── lib-A/
│           └──src/
│              └── assets/
│                  └── i18n/
│                      └── en.json
└── dist/
    └── frontend/ 
        └── browser/
                └── assets/
                    └── i18n/
                        ├── lib-A/
                        │  └── en.json
                        └── en.json

Content of apps/frontend/src/assets/i18n/en.json:

{
  "hello": "world",
  "greet": "hello {{name}}"
}

Content of libs/frontend/lib-A/src/assets/i18n/en.json:

{
  "hello": "world lib-A",
  "greet": "hello {{name}} lib-A"
}

Content of transloco-loader.service.ts:

@Injectable({
  providedIn: 'root',
})
export class TranslocoHttpLoader implements TranslocoLoader {
  private http = inject(HttpClient);

  getTranslation(lang: string): Observable<Translation> {
    return this.http.get<Translation>(`/assets/i18n/${lang}.json`);
  }
}

Content of app.component.ts:

@Component({
  selector: 'app-root',
  imports: [],
  templateUrl: 'app.component.html',
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export class AppComponent {
  text = translateSignal('hello');
}

Content of app.component.html:

<p>translateSignal: {{ text() }}</p>

As you can see from the app.component.ts, only the translation key 'hello' is used here, which lets suggest, that the returned translation is always the one from the apps/frontend/src/assets/i18n/en.json.
It is getting odd, when using provideTranslocoScope({ scope: 'lib-A' }) in the app.config.ts now, which looks like this:

export const appConfig: ApplicationConfig = {
  providers: [
    provideExperimentalZonelessChangeDetection(),
    provideHttpClient(),
    provideRouter(routes, withPreloading(PreloadAllModules)),
    provideTransloco(translocoConfig),
    provideTranslocoScope({ scope: 'liba-A' }),
  ],
};

As you can see, i use provideTransloco as described in the documentation. Additionally, to provide the translations from lib-A in the app.component.ts/html i use provideTranslocoScope, which is working fine and the translations are successfully loaded.

What is odd now is, that i would expect the translateSignal, to return the string world, because no scope was provided.
But what it actually returns is world lib-A.
So even though there is no lib-A scope provided within translateSignal('hello') i get the value from the lib-A translation file.

There seems to be no way of explicitly stating "do not use a scope here", so Im wondering if im using the translateSignal wrong or if this is an actual bug / unintended behavior of the translateSignal api.

When i do not provide a scope for the translateSignal function, i would expect it to grab the translation from the unscoped translation file and have it return world. Only if i specifically set the scope to lib-A like this translateSignal('hello', {}, {scope: 'lib-A'}) i would expect to get world lib-A returned.

I try to reproduce the issue in a Stackblitz example. But maybe someone else already experienced that issue?

[dw-0]

In another attempt to try and understand how the signal api is working, i configured the project so that the asset directory after build will look like this:

dist/
    └── frontend/ 
        └── browser/
                └── assets/
                    └── i18n/
                        ├── core/
                        │  └── en.json
                        └── lib-A/
                            └── en.json

So now, the translation of the app is located in core/en.json and the one from the lib is located in lib-A/en.json.
The app.config.ts was changed, so that both scopes get provided with provideTranslocoScope('core', 'electricity')

app.component.ts:

@Component({
  selector: 'app-root',
  imports: [],
  templateUrl: 'app.component.html',
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export class AppComponent {
  text1 = translateSignal('hello');
  text2 = translateSignal('greet', { name: 'Hans' });
  text3 = translateSignal('hello', {}, { scope: 'lib-A' });
  text4 = translateSignal('greet', { name: 'Hans' }, { scope: 'lib-A' });
}

app.component.html:

<p>core: {{ text1() }}</p> <-- results in text1() = world
<p>core: {{ text2() }}</p> <-- results in text2() = hello Hans
<p>lib-A: {{ text3() }}</p> <-- results in text1() = world lib-A
<p>lib-A: {{ text4() }}</p> <-- results in text2() = hello Hans lib-A

Now im really confused, why text1 and text2 load the translation from the scope core. Is this some undocumented behavior?