@theia/preferences 1.76.0-next.6 → 1.76.0

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@theia/preferences",
-  "version": "1.76.0-next.6+5358262f7",
+  "version": "1.76.0",
   "description": "Theia - Preferences Extension",
   "dependencies": {
-    "@theia/core": "1.76.0-next.6+5358262f7",
-    "@theia/editor": "1.76.0-next.6+5358262f7",
-    "@theia/filesystem": "1.76.0-next.6+5358262f7",
-    "@theia/monaco": "1.76.0-next.6+5358262f7",
+    "@theia/core": "1.76.0",
+    "@theia/editor": "1.76.0",
+    "@theia/filesystem": "1.76.0",
+    "@theia/monaco": "1.76.0",
     "@theia/monaco-editor-core": "1.108.201",
-    "@theia/userstorage": "1.76.0-next.6+5358262f7",
-    "@theia/workspace": "1.76.0-next.6+5358262f7",
+    "@theia/userstorage": "1.76.0",
+    "@theia/workspace": "1.76.0",
     "async-mutex": "^0.3.2",
     "fast-deep-equal": "^3.1.3",
     "jsonc-parser": "^3.3.1",
@@ -50,10 +50,10 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.75.0"
+    "@theia/ext-scripts": "1.76.0"
   },
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "5358262f7ca40ba9a5e7b514914a18202bd2b7e6"
+  "gitHead": "b9b54c500b46515512e2b44371bc0c7122947bed"
 }

package/src/browser/preference-frontend-contribution.spec.ts

@@ -0,0 +1,92 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { LaunchArguments } from '@theia/core/lib/common/launch-arguments';
+
+const launchArgs = (values: Record<string, string[]>): LaunchArguments => ({ values, negated: [] });
+import { PreferenceFrontendContribution } from './preference-frontend-contribution';
+
+class TestPreferenceFrontendContribution extends PreferenceFrontendContribution {
+
+    forwardedArgs: LaunchArguments | undefined;
+    sessionBackendCalls = 0;
+    persistentBackendCalls = 0;
+
+    resolve(): Promise<{ session: [string, unknown][], persistent: [string, unknown][] }> {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (this as any).launchArgs = { getLaunchArgs: () => this.forwardedArgs };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (this as any).CliPreferences = {
+            getSessionPreferences: async () => {
+                this.sessionBackendCalls++;
+                return [['backend.session', 1]] as [string, unknown][];
+            },
+            getPreferences: async () => {
+                this.persistentBackendCalls++;
+                return [['backend.persistent', 2]] as [string, unknown][];
+            }
+        };
+        return this.resolveCliPreferences();
+    }
+}
+
+describe('PreferenceFrontendContribution#resolveCliPreferences', () => {
+
+    let contribution: TestPreferenceFrontendContribution;
+
+    beforeEach(() => {
+        contribution = new TestPreferenceFrontendContribution();
+    });
+
+    it('reads preferences from the backend on a cold-start window (no forwarded options)', async () => {
+        contribution.forwardedArgs = undefined;
+
+        const result = await contribution.resolve();
+
+        expect(result.session).to.deep.equal([['backend.session', 1]]);
+        expect(result.persistent).to.deep.equal([['backend.persistent', 2]]);
+        expect(contribution.sessionBackendCalls).to.equal(1);
+    });
+
+    it('layers --session-preference from the forwarded options on top of the backend values', async () => {
+        contribution.forwardedArgs = launchArgs({ 'session-preference': ['editor.fontSize=20'], 'attach-container': ['B'] });
+
+        const result = await contribution.resolve();
+
+        // Process-wide backend values are kept (base) and the forwarded value is added on top.
+        expect(result.session).to.deep.equal([['backend.session', 1], ['editor.fontSize', 20]]);
+        expect(result.persistent).to.deep.equal([['backend.persistent', 2]]);
+        expect(contribution.sessionBackendCalls).to.equal(1);
+    });
+
+    it('layers --set-preference from the forwarded options on top of the backend values', async () => {
+        contribution.forwardedArgs = launchArgs({ 'set-preference': ['editor.tabSize=2'] });
+
+        const result = await contribution.resolve();
+
+        expect(result.persistent).to.deep.equal([['backend.persistent', 2], ['editor.tabSize', 2]]);
+        expect(result.session).to.deep.equal([['backend.session', 1]]);
+    });
+
+    it('lets a forwarded value override a same-key backend value', async () => {
+        contribution.forwardedArgs = launchArgs({ 'session-preference': ['backend.session=99'] });
+
+        const result = await contribution.resolve();
+
+        expect(result.session).to.deep.equal([['backend.session', 99]]);
+    });
+});

package/src/browser/preference-frontend-contribution.ts

@@ -16,7 +16,9 @@
 
 import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { FrontendApplicationContribution } from '@theia/core/lib/browser';
-import { CliPreferences } from '../common/cli-preferences';
+import { LaunchArguments } from '@theia/core/lib/common/launch-arguments';
+import { WindowLaunchArgs } from '@theia/core/lib/browser/window/window-launch-args';
+import { CliPreferences, CliPreferenceEntry } from '../common/cli-preferences';
 import { PreferenceService, PreferenceScope } from '@theia/core/lib/common/preferences';
 import { ILogger } from '@theia/core';
 
@@ -31,23 +33,15 @@ export class PreferenceFrontendContribution implements FrontendApplicationContri
     @inject(ILogger) @named('preferences:PreferenceFrontendContribution')
     protected readonly logger: ILogger;
 
+    @inject(WindowLaunchArgs)
+    protected readonly launchArgs: WindowLaunchArgs;
+
     onStart(): void {
         this.applyCliPreferences();
     }
 
     protected async applyCliPreferences(): Promise<void> {
-        // Fetch both buckets in parallel; both are RPC hops to the same backend and
-        // can overlap with the preference service initialising its providers.
-        const [session, persistent] = await Promise.all([
-            this.CliPreferences.getSessionPreferences().catch(e => {
-                this.logger.warn('Failed to fetch --session-preference values:', e);
-                return [] as [string, unknown][];
-            }),
-            this.CliPreferences.getPreferences().catch(e => {
-                this.logger.warn('Failed to fetch --set-preference values:', e);
-                return [] as [string, unknown][];
-            })
-        ]);
+        const { session, persistent } = await this.resolveCliPreferences();
 
         // `preferenceService.set()` needs the target provider registered in the providers
         // map, which only happens once `initializeProviders()` has walked every scope and
@@ -70,6 +64,49 @@ export class PreferenceFrontendContribution implements FrontendApplicationContri
         await this.applyAll(persistent, PreferenceScope.User);
     }
 
+    /**
+     * Resolves the CLI-provided preferences to apply to this window.
+     *
+     * The shared backend reflects the original cold-start launch (it cannot distinguish between
+     * windows), so it supplies the process-wide CLI preferences. A forwarded (second-instance)
+     * window additionally carries its own options, provided by the trusted main process, and layers
+     * them on top, overriding by key. Merging (rather than replacing) means a plain
+     * second-instance window keeps the process-wide values instead of dropping them, while an attach
+     * window still gets its own overrides.
+     */
+    protected async resolveCliPreferences(): Promise<{ session: [string, unknown][], persistent: [string, unknown][] }> {
+        // Fetch both buckets in parallel; both are RPC hops to the same backend and
+        // can overlap with the preference service initialising its providers.
+        const [session, persistent] = await Promise.all([
+            this.CliPreferences.getSessionPreferences().catch(e => {
+                this.logger.warn('Failed to fetch --session-preference values:', e);
+                return [] as [string, unknown][];
+            }),
+            this.CliPreferences.getPreferences().catch(e => {
+                this.logger.warn('Failed to fetch --set-preference values:', e);
+                return [] as [string, unknown][];
+            })
+        ]);
+        const forwarded = this.launchArgs.getLaunchArgs();
+        if (forwarded === undefined) {
+            return { session, persistent };
+        }
+        const warn = (message: string) => this.logger.warn(message);
+        return {
+            session: this.mergeEntries(session, CliPreferenceEntry.parseAll(LaunchArguments.values(forwarded, 'session-preference'), warn)),
+            persistent: this.mergeEntries(persistent, CliPreferenceEntry.parseAll(LaunchArguments.values(forwarded, 'set-preference'), warn))
+        };
+    }
+
+    /** Overlays `overrides` onto `base`, later entries winning per key while preserving order (base first). */
+    protected mergeEntries(base: ReadonlyArray<[string, unknown]>, overrides: ReadonlyArray<[string, unknown]>): [string, unknown][] {
+        const merged = new Map<string, unknown>();
+        for (const [key, value] of [...base, ...overrides]) {
+            merged.set(key, value);
+        }
+        return [...merged];
+    }
+
     /**
      * Applies a batch of CLI-provided preferences sequentially. A rejection from an
      * individual write (bad key, invalid scope, etc.) is logged and does not abort the

package/src/browser/preference-frontend-module.ts

@@ -32,6 +32,8 @@ import { PreferenceOpenHandler } from './preference-open-handler';
 import { CliPreferences, CliPreferencesPath } from '../common/cli-preferences';
 import { ServiceConnectionProvider } from '@theia/core/lib/browser/messaging/service-connection-provider';
 import { PreferenceFrontendContribution } from './preference-frontend-contribution';
+import { RemoteCliArgsContribution } from '@theia/core/lib/common/remote-cli-args-contribution';
+import { SessionPreferenceRemoteCliContribution } from './session-preference-remote-cli-contribution';
 import { SessionPreferenceStatusBarContribution } from './session-preference-status-bar-contribution';
 import { PreferenceLayoutProvider } from './util/preference-layout';
 import { PreferencesWidget } from './views/preference-widget';
@@ -71,6 +73,8 @@ export function bindPreferences(bind: interfaces.Bind, unbind: interfaces.Unbind
     bind(CliPreferences).toDynamicValue(ctx => ServiceConnectionProvider.createProxy<CliPreferences>(ctx.container, CliPreferencesPath)).inSingletonScope();
     bind(PreferenceFrontendContribution).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(PreferenceFrontendContribution);
+    bind(SessionPreferenceRemoteCliContribution).toSelf().inSingletonScope();
+    bind(RemoteCliArgsContribution).toService(SessionPreferenceRemoteCliContribution);
     bind(SessionPreferenceStatusBarContribution).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(SessionPreferenceStatusBarContribution);
 

package/src/browser/preference-tree-model.spec.ts

@@ -0,0 +1,362 @@
+// *****************************************************************************
+// Copyright (C) 2026 Safi Seid-Ahmad, K2view and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { Container } from '@theia/core/shared/inversify';
+import { Emitter, ILogger, PreferenceSchemaService, PreferenceScope, PreferenceService } from '@theia/core';
+import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
+import { CompositeTreeNode, createTreeContainer, LabelProvider } from '@theia/core/lib/browser';
+import { PreferenceTreeModel } from './preference-tree-model';
+import { PreferencesSearchbarWidget } from './views/preference-searchbar-widget';
+import { PreferenceTreeGenerator } from './util/preference-tree-generator';
+import { PreferencesScopeTabBar } from './views/preference-scope-tabbar-widget';
+import { Preference } from './util/preference-types';
+import { COMMONLY_USED_SECTION_PREFIX } from './util/preference-layout';
+
+disableJSDOM();
+
+interface TreeFixture {
+    root: CompositeTreeNode;
+    commonlyUsed?: Preference.CompositeTreeNode;
+    editor: Preference.CompositeTreeNode;
+    editorCursor: Preference.CompositeTreeNode;
+    extensions: Preference.CompositeTreeNode;
+}
+
+describe('PreferenceTreeModel', () => {
+
+    let searchbarEmitter: Emitter<string>;
+    let schemaEmitter: Emitter<CompositeTreeNode>;
+    let scopeEmitter: Emitter<Preference.SelectedScopeDetails>;
+    let isValidInScope: (preferenceId: string, scope: number) => boolean;
+
+    function createComposite(group: string, id: string, parent: CompositeTreeNode, depth: number, expandable: boolean): Preference.CompositeTreeNode {
+        const node: Preference.CompositeTreeNode = {
+            id: `${group}@${id}`,
+            visible: true,
+            parent,
+            children: [],
+            expanded: false,
+            selected: false,
+            depth,
+            label: id,
+        } as Preference.CompositeTreeNode;
+        if (!expandable) {
+            delete node.expanded;
+        }
+        CompositeTreeNode.addChild(parent, node);
+        return node;
+    }
+
+    function createLeaf(group: string, preferenceId: string, parent: Preference.CompositeTreeNode, depth: number): Preference.LeafNode {
+        const node: Preference.LeafNode = {
+            id: `${group}@${preferenceId}`,
+            preferenceId,
+            parent,
+            preference: { data: {} },
+            depth,
+        };
+        CompositeTreeNode.addChild(parent, node);
+        return node;
+    }
+
+    function createFixture(withCommonlyUsed: boolean = true): TreeFixture {
+        const root: CompositeTreeNode = {
+            id: 'root-node-id',
+            name: '',
+            parent: undefined,
+            visible: true,
+            children: [],
+        };
+        let commonlyUsed: Preference.CompositeTreeNode | undefined;
+        if (withCommonlyUsed) {
+            commonlyUsed = createComposite(COMMONLY_USED_SECTION_PREFIX, COMMONLY_USED_SECTION_PREFIX, root, 0, true);
+            createLeaf(COMMONLY_USED_SECTION_PREFIX, 'files.autoSave', commonlyUsed, 1);
+        }
+        const editor = createComposite('editor', 'editor', root, 0, true);
+        createLeaf('editor', 'editor.fontSize', editor, 1);
+        const editorCursor = createComposite('editor', 'editor.cursor', editor, 1, false);
+        createLeaf('editor', 'editor.cursorStyle', editorCursor, 2);
+        const extensions = createComposite('extensions', 'extensions', root, 0, true);
+        createLeaf('extensions', 'extensions.autoUpdate', extensions, 1);
+        return { root, commonlyUsed, editor, editorCursor, extensions };
+    }
+
+    /**
+     * Creates the model. The `onCreated` callback runs after the tree model's listeners are
+     * registered but before the (async) initial schema is applied, which simulates state that
+     * is restored before initialization completes, e.g. a restored search term.
+     */
+    async function createModel(fixture: TreeFixture, onCreated?: (model: PreferenceTreeModel) => void): Promise<PreferenceTreeModel> {
+        const parent = new Container();
+        searchbarEmitter = new Emitter<string>();
+        schemaEmitter = new Emitter<CompositeTreeNode>();
+        scopeEmitter = new Emitter<Preference.SelectedScopeDetails>();
+        isValidInScope = () => true;
+        parent.bind(ILogger).to(MockLogger).inSingletonScope();
+        parent.bind(LabelProvider).toConstantValue({
+            getName: () => '',
+            getIcon: () => '',
+            getLongName: () => '',
+        } as any);
+        parent.bind(PreferenceSchemaService).toConstantValue({
+            getSchemaProperties: () => new Map(),
+            isValidInScope: (preferenceId: string, scope: number) => isValidInScope(preferenceId, scope),
+        } as any);
+        parent.bind(PreferenceService).toConstantValue({
+            ready: Promise.resolve(),
+        } as any);
+        parent.bind(PreferencesSearchbarWidget).toConstantValue({
+            onFilterChanged: searchbarEmitter.event,
+            updateResultsCount: () => { },
+        } as any);
+        parent.bind(PreferenceTreeGenerator).toConstantValue({
+            onSchemaChanged: schemaEmitter.event,
+            root: fixture.root,
+            getNodeId: () => '',
+        } as any);
+        parent.bind(PreferencesScopeTabBar).toConstantValue({
+            onScopeChanged: scopeEmitter.event,
+            currentScope: Preference.DEFAULT_SCOPE,
+        } as any);
+        const child = createTreeContainer(parent, { model: PreferenceTreeModel });
+        const model = child.get(PreferenceTreeModel);
+        onCreated?.(model);
+        await new Promise(resolve => setTimeout(resolve));
+        return model;
+    }
+
+    describe('category filter', () => {
+
+        it('selects the Commonly Used category by default', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            expect(model.selectedNodes[0]?.id).to.equal(fixture.commonlyUsed!.id);
+            expect(model.categoryFilterId).to.equal(fixture.commonlyUsed!.id);
+        });
+
+        it('applies the category filter when a category is selected', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.extensions);
+            expect(model.categoryFilterId).to.equal(fixture.extensions.id);
+        });
+
+        it('keeps the user selection across schema reloads', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.extensions);
+            schemaEmitter.fire(fixture.root);
+            expect(model.selectedNodes[0]?.id).to.equal(fixture.extensions.id);
+            expect(model.categoryFilterId).to.equal(fixture.extensions.id);
+        });
+
+        it('restores the user selection when the schema is rebuilt with new nodes', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.extensions);
+            const rebuilt = createFixture();
+            schemaEmitter.fire(rebuilt.root);
+            expect(model.selectedNodes[0]).to.equal(model.getNode(rebuilt.extensions.id));
+            expect(model.selectedNodes[0]?.selected).to.be.true;
+            expect(model.categoryFilterId).to.equal(rebuilt.extensions.id);
+        });
+
+        it('keeps the default selection highlighted when the schema is rebuilt with new nodes', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            const rebuilt = createFixture();
+            schemaEmitter.fire(rebuilt.root);
+            expect(model.selectedNodes[0]).to.equal(model.getNode(rebuilt.commonlyUsed!.id));
+            expect(model.selectedNodes[0]?.selected).to.be.true;
+        });
+
+        it('preserves the category filter when restoring a synced selection after a schema rebuild', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.editor);
+            model.selectIfNotSelected(fixture.editorCursor);
+            const rebuilt = createFixture();
+            schemaEmitter.fire(rebuilt.root);
+            expect(model.selectedNodes[0]).to.equal(model.getNode(rebuilt.editorCursor.id));
+            expect(model.selectedNodes[0]?.selected).to.be.true;
+            expect(model.categoryFilterId).to.equal(rebuilt.editor.id);
+        });
+
+        it('falls back to the default category when the selected category disappears from the schema', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.extensions);
+            const newFixture = createFixture();
+            newFixture.root.children = newFixture.root.children.filter(child => child !== newFixture.extensions);
+            schemaEmitter.fire(newFixture.root);
+            expect(model.selectedNodes[0]).to.equal(model.getNode(newFixture.commonlyUsed!.id));
+            expect(model.categoryFilterId).to.equal(newFixture.commonlyUsed!.id);
+        });
+
+        it('falls back to the default category when the selected category has no settings left after a schema change', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.extensions);
+            const rebuilt = createFixture();
+            rebuilt.extensions.children = [];
+            schemaEmitter.fire(rebuilt.root);
+            expect(model.selectedNodes[0]?.id).to.equal(rebuilt.commonlyUsed!.id);
+            expect(model.categoryFilterId).to.equal(rebuilt.commonlyUsed!.id);
+        });
+
+        it('selects the Commonly Used category by its exact id', async () => {
+            const fixture = createFixture(false);
+            // A group whose id merely starts with the Commonly Used prefix must not be mistaken for it.
+            const lookalikeGroup = `${COMMONLY_USED_SECTION_PREFIX}-lookalike`;
+            const lookalike = createComposite(lookalikeGroup, lookalikeGroup, fixture.root, 0, true);
+            createLeaf(lookalikeGroup, 'lookalike.setting', lookalike, 1);
+            fixture.commonlyUsed = createComposite(COMMONLY_USED_SECTION_PREFIX, COMMONLY_USED_SECTION_PREFIX, fixture.root, 0, true);
+            createLeaf(COMMONLY_USED_SECTION_PREFIX, 'files.autoSave', fixture.commonlyUsed, 1);
+            const model = await createModel(fixture);
+            expect(model.selectedNodes[0]?.id).to.equal(fixture.commonlyUsed.id);
+            expect(model.categoryFilterId).to.equal(fixture.commonlyUsed.id);
+        });
+    });
+
+    describe('scope change', () => {
+
+        function fireScopeChange(scope: number): void {
+            scopeEmitter.fire({ scope, uri: undefined, activeScopeIsFolder: false });
+        }
+
+        it('keeps the selected category when it still has settings in the new scope', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.extensions);
+            fireScopeChange(PreferenceScope.Workspace);
+            expect(model.selectedNodes[0]?.id).to.equal(fixture.extensions.id);
+            expect(model.categoryFilterId).to.equal(fixture.extensions.id);
+        });
+
+        it('falls back to the default category when the selected category has no settings in the new scope', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.extensions);
+            isValidInScope = (preferenceId, scope) => scope !== PreferenceScope.Workspace || !preferenceId.startsWith('extensions.');
+            fireScopeChange(PreferenceScope.Workspace);
+            expect(model.selectedNodes[0]?.id).to.equal(fixture.commonlyUsed!.id);
+            expect(model.categoryFilterId).to.equal(fixture.commonlyUsed!.id);
+        });
+
+        it('clears the selection when neither the selected nor the default category has settings in the new scope', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.extensions);
+            isValidInScope = (preferenceId, scope) => scope !== PreferenceScope.Workspace || preferenceId.startsWith('editor.');
+            fireScopeChange(PreferenceScope.Workspace);
+            expect(model.selectedNodes).to.have.lengthOf(0);
+            expect(model.categoryFilterId).to.be.undefined;
+        });
+    });
+
+    describe('editor scroll sync', () => {
+
+        it('does not change the category filter when the selection syncs to the editor scroll position', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.editor);
+            model.selectIfNotSelected(fixture.editorCursor);
+            expect(model.selectedNodes[0]?.id).to.equal(fixture.editorCursor.id);
+            expect(model.categoryFilterId).to.equal(fixture.editor.id);
+        });
+
+        it('does not narrow active search results when the selection syncs to the editor scroll position', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            searchbarEmitter.fire('font');
+            model.selectIfNotSelected(fixture.editor);
+            expect(model.categoryFilterId).to.be.undefined;
+        });
+    });
+
+    describe('search interaction', () => {
+
+        it('clears the category filter and the selection when a search starts', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            model.selectNode(fixture.editor);
+            searchbarEmitter.fire('font');
+            expect(model.isFiltered).to.be.true;
+            expect(model.categoryFilterId).to.be.undefined;
+            expect(model.selectedNodes).to.have.lengthOf(0);
+        });
+
+        it('applies the category filter when a category is explicitly selected during a search', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            searchbarEmitter.fire('font');
+            model.selectNode(fixture.editor);
+            expect(model.categoryFilterId).to.equal(fixture.editor.id);
+        });
+
+        it('resets to all results when the search term changes after a category was selected', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            searchbarEmitter.fire('font');
+            model.selectNode(fixture.editor);
+            searchbarEmitter.fire('fonts');
+            expect(model.categoryFilterId).to.be.undefined;
+            expect(model.selectedNodes).to.have.lengthOf(0);
+        });
+
+        it('returns to the Commonly Used category when the search is cleared', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture);
+            searchbarEmitter.fire('font');
+            model.selectNode(fixture.editor);
+            searchbarEmitter.fire('');
+            expect(model.selectedNodes[0]?.id).to.equal(fixture.commonlyUsed!.id);
+            expect(model.categoryFilterId).to.equal(fixture.commonlyUsed!.id);
+        });
+    });
+
+    describe('initial selection', () => {
+
+        it('does not apply the default selection while a restored search is active', async () => {
+            const fixture = createFixture();
+            const model = await createModel(fixture, () => searchbarEmitter.fire('font'));
+            expect(model.selectedNodes).to.have.lengthOf(0);
+            expect(model.categoryFilterId).to.be.undefined;
+            searchbarEmitter.fire('');
+            expect(model.selectedNodes[0]?.id).to.equal(fixture.commonlyUsed!.id);
+            expect(model.categoryFilterId).to.equal(fixture.commonlyUsed!.id);
+        });
+
+        it('applies the default selection on a later schema change if Commonly Used is not present initially', async () => {
+            const withoutCommonlyUsed = createFixture(false);
+            const model = await createModel(withoutCommonlyUsed);
+            expect(model.selectedNodes).to.have.lengthOf(0);
+            const withCommonlyUsed = createFixture();
+            schemaEmitter.fire(withCommonlyUsed.root);
+            expect(model.selectedNodes[0]?.id).to.equal(withCommonlyUsed.commonlyUsed!.id);
+            expect(model.categoryFilterId).to.equal(withCommonlyUsed.commonlyUsed!.id);
+        });
+    });
+});