@theia/core 1.74.0-next.5 → 1.74.0-next.53

package/src/browser/tree/tree-widget.tsx

@@ -64,28 +64,10 @@ export const TREE_NODE_CAPTION_CLASS = 'theia-TreeNodeCaption';
 export const TREE_NODE_INDENT_GUIDE_CLASS = 'theia-tree-node-indent';
 
 /**
- * Threshold in pixels to consider the view as being scrolled to the bottom
+ * Threshold in pixels to consider the view as being scrolled to the bottom.
  */
 export const SCROLL_BOTTOM_THRESHOLD = 30;
 
-/**
- * Tree scroll event data.
- */
-export interface TreeScrollEvent {
-    readonly scrollTop: number;
-    readonly scrollLeft: number;
-}
-
-/**
- * Tree scroll state data.
- */
-export interface TreeScrollState {
-    readonly scrollTop: number;
-    readonly isAtBottom: boolean;
-    readonly scrollHeight?: number;
-    readonly clientHeight?: number;
-}
-
 export const TreeProps = Symbol('TreeProps');
 
 /**
@@ -189,8 +171,8 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
     protected searchBox: SearchBox;
     protected searchHighlights: Map<string, TreeDecoration.CaptionHighlight>;
 
-    protected readonly onScrollEmitter = new Emitter<TreeScrollEvent>();
-    readonly onScroll: TheiaEvent<TreeScrollEvent> = this.onScrollEmitter.event;
+    protected readonly onAtBottomStateChangeEmitter = new Emitter<boolean>();
+    readonly onAtBottomStateChange: TheiaEvent<boolean> = this.onAtBottomStateChangeEmitter.event;
 
     @inject(TreeDecoratorService)
     protected readonly decoratorService: TreeDecoratorService;
@@ -285,7 +267,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         this.node.addEventListener('mouseup', this.handleMiddleClickEvent.bind(this));
         this.node.addEventListener('auxclick', this.handleMiddleClickEvent.bind(this));
         this.toDispose.pushAll([
-            this.onScrollEmitter,
+            this.onAtBottomStateChangeEmitter,
             this.model,
             this.model.onChanged(() => this.updateRows()),
             this.model.onSelectionChanged(() => this.scheduleUpdateScrollToRow({ resize: false })),
@@ -551,7 +533,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 rows={rows}
                 renderNodeRow={this.renderNodeRow}
                 scrollToRow={this.scrollToRow}
-                onScrollEmitter={this.onScrollEmitter}
+                onAtBottomStateChangeEmitter={this.onAtBottomStateChangeEmitter}
                 {...this.props.viewProps}
             />;
         }
@@ -1201,39 +1183,6 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         return this.node;
     }
 
-    /**
-     * Get the current scroll state from the virtualized view.
-     * This should be used instead of accessing the DOM scroll properties directly
-     * when the tree is virtualized.
-     */
-    protected getVirtualizedScrollState(): TreeScrollState | undefined {
-        return this.view?.getScrollState();
-    }
-
-    /**
-     * Check if the tree is scrolled to the bottom.
-     * Works with both virtualized and non-virtualized trees.
-     */
-    isScrolledToBottom(): boolean {
-        if (this.props.virtualized !== false && this.view) {
-            // Use virtualized scroll state
-            const scrollState = this.getVirtualizedScrollState();
-            return scrollState?.isAtBottom ?? true;
-        } else {
-            // Fallback to DOM-based calculation for non-virtualized trees
-            const scrollContainer = this.node;
-            const scrollHeight = scrollContainer.scrollHeight;
-            const scrollTop = scrollContainer.scrollTop;
-            const clientHeight = scrollContainer.clientHeight;
-
-            if (scrollHeight <= clientHeight) {
-                return true;
-            }
-
-            return scrollHeight - scrollTop - clientHeight <= SCROLL_BOTTOM_THRESHOLD;
-        }
-    }
-
     protected override onAfterAttach(msg: Message): void {
         const up = [
             Key.ARROW_UP,
@@ -1658,11 +1607,14 @@ export namespace TreeWidget {
         /**
          * Optional scroll event emitter.
          */
-        onScrollEmitter?: Emitter<TreeScrollEvent>
+        /**
+         * Optional emitter fired when the at-bottom state changes.
+         */
+        onAtBottomStateChangeEmitter?: Emitter<boolean>
     }
     export class View extends React.Component<ViewProps> {
         list: VirtuosoHandle | undefined;
-        private lastScrollState: TreeScrollState = { scrollTop: 0, isAtBottom: true, scrollHeight: 0, clientHeight: 0 };
+
         /**
          * Ensure the selected row is scrolled into view when virtualization finishes updating.
          */
@@ -1687,28 +1639,14 @@ export namespace TreeWidget {
         }
 
         override render(): React.ReactNode {
-            const { rows, width, height, scrollToRow, renderNodeRow, onScrollEmitter, ...other } = this.props;
+            const { rows, width, height, scrollToRow, renderNodeRow, onAtBottomStateChangeEmitter, ...other } = this.props;
             return <Virtuoso
                 ref={(list: VirtuosoHandle | null) => {
                     this.list = (list || undefined);
                     this.scrollIntoViewIfNeeded();
                 }}
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                onScroll={(e: any) => {
-                    const scrollTop = e.target.scrollTop;
-                    const scrollHeight = e.target.scrollHeight;
-                    const clientHeight = e.target.clientHeight;
-                    const isAtBottom = scrollHeight - scrollTop - clientHeight <= SCROLL_BOTTOM_THRESHOLD;
-
-                    // Store scroll state before firing the event to prevent jitter during inference and scrolling
-                    this.lastScrollState = { scrollTop, isAtBottom, scrollHeight, clientHeight };
-                    onScrollEmitter?.fire({ scrollTop, scrollLeft: e.target.scrollLeft || 0 });
-                }}
                 atBottomStateChange={(atBottom: boolean) => {
-                    this.lastScrollState = {
-                        ...this.lastScrollState,
-                        isAtBottom: atBottom
-                    };
+                    onAtBottomStateChangeEmitter?.fire(atBottom);
                 }}
                 atBottomThreshold={SCROLL_BOTTOM_THRESHOLD}
                 totalCount={rows.length}
@@ -1721,9 +1659,5 @@ export namespace TreeWidget {
                 {...other}
             />;
         }
-
-        getScrollState(): TreeScrollState {
-            return { ...this.lastScrollState };
-        }
     }
 }

package/src/browser/widgets/select-component.tsx

@@ -91,7 +91,20 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         return selected;
     }
 
-    override componentDidUpdate(prevProps: SelectComponentProps): void {
+    override componentDidUpdate(prevProps: SelectComponentProps, prevState: SelectComponentState): void {
+        if (prevState.selected !== this.state.selected && this.state.dimensions) {
+            const dropdownContainer = this.dropdownRef?.current;
+            const selectedOption = dropdownContainer?.querySelector(`[data-option-index="${this.state.selected}"]`) as HTMLElement | undefined;
+            if (dropdownContainer && selectedOption) {
+                const optionBottom = selectedOption.offsetTop + selectedOption.offsetHeight;
+                const visibleBottom = dropdownContainer.scrollTop + dropdownContainer.clientHeight;
+                if (optionBottom > visibleBottom) {
+                    dropdownContainer.scrollTop = optionBottom - dropdownContainer.clientHeight;
+                } else if (selectedOption.offsetTop < dropdownContainer.scrollTop) {
+                    dropdownContainer.scrollTop = selectedOption.offsetTop;
+                }
+            }
+        }
         if (prevProps.defaultValue !== this.props.defaultValue || prevProps.options !== this.props.options) {
             const selected = this.getInitialSelectedIndex(this.props);
             this.setState({
@@ -230,13 +243,18 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
             selected = this.nextNotSeparator('forwards');
         }
         const selectedItemLabel = options[selected]?.label ?? options[selected]?.value;
+        // Expose when the currently shown option is disabled so consumers can style the field to match
+        // it (e.g. the option previewed while navigating), instead of a fixed committed-value class.
+        const selectionDisabled = !!options[selected]?.disabled;
+        const fieldClassName = `theia-select-component${this.props.className ? ` ${this.props.className}` : ''}`
+            + `${selectionDisabled ? ' theia-select-component-selection-disabled' : ''}`;
         return <>
             <div
                 id={this.props.id}
                 key="select-component"
                 ref={this.fieldRef}
                 tabIndex={0}
-                className={`theia-select-component${this.props.className ? ` ${this.props.className}` : ''}`}
+                className={fieldClassName}
                 onClick={e => this.handleClickEvent(e)}
                 onBlur={
                     () => {
@@ -254,11 +272,11 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         </>;
     }
 
-    protected nextNotSeparator(direction: 'forwards' | 'backwards'): number {
+    protected nextNotSeparator(direction: 'forwards' | 'backwards', startFrom?: number): number {
         const { options } = this.props;
         const step = direction === 'forwards' ? 1 : -1;
         const length = this.props.options.length;
-        let selected = this.state.selected;
+        let selected = startFrom ?? this.state.selected;
         let count = 0;
         do {
             selected = (selected + step) % length;
@@ -267,7 +285,8 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
             }
             count++;
         }
-        while (options[selected]?.separator && count < length);
+        // Skip separators and disabled options so keyboard navigation never lands on a non-selectable entry.
+        while ((options[selected]?.separator || options[selected]?.disabled) && count < length);
         return selected;
     }
 
@@ -276,23 +295,26 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
             return;
         }
         if (ev.key === 'ArrowUp') {
-            const selected = this.nextNotSeparator('backwards');
+            const selected = this.nextNotSeparator('backwards', this.state.hover);
             this.setState({
                 selected,
                 hover: selected
             });
         } else if (ev.key === 'ArrowDown') {
             if (this.state.dimensions) {
-                const selected = this.nextNotSeparator('forwards');
+                const selected = this.nextNotSeparator('forwards', this.state.hover);
                 this.setState({
                     selected,
                     hover: selected
                 });
             } else {
                 this.toggleVisibility();
+                // Start on the first selectable option (startFrom -1 evaluates index 0 first), so a
+                // leading separator or disabled option is skipped instead of becoming the active row.
+                const selected = this.nextNotSeparator('forwards', -1);
                 this.setState({
-                    selected: 0,
-                    hover: 0,
+                    selected,
+                    hover: selected,
                 });
             }
         } else if (ev.key === 'Enter') {
@@ -300,7 +322,10 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
                 this.toggleVisibility();
             } else {
                 const selected = this.state.selected;
-                this.selectOption(selected, this.props.options[selected]);
+                const option = this.props.options[selected];
+                if (!option?.disabled) {
+                    this.selectOption(selected, option);
+                }
             }
         } else if (ev.key === 'Escape' || ev.key === 'Tab') {
             this.hide(undefined, true);
@@ -401,17 +426,21 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
             return <div key={index} className="theia-select-component-separator" />;
         }
         const selected = this.state.hover;
+        const disabled = !!option.disabled;
         return (
             <div
                 key={index}
-                className={`theia-select-component-option${index === selected ? ' selected' : ''}`}
+                data-option-index={index}
+                className={`theia-select-component-option${index === selected ? ' selected' : ''}${disabled ? ' disabled' : ''}`}
                 onMouseOver={() => {
                     this.setState({
                         hover: index
                     });
                 }}
                 onMouseDown={() => {
-                    this.selectOption(index, option);
+                    if (!disabled) {
+                        this.selectOption(index, option);
+                    }
                 }}
             >
                 <div key="value" className="theia-select-component-option-value">{option.label ?? option.value}</div>

package/src/common/preferences/index.ts

@@ -16,6 +16,7 @@
 
 export * from './defaults-preference-provider';
 export * from './preference-language-override-service';
+export * from './session-preference-provider';
 export * from './preference-provider-impl';
 export * from './preference-provider';
 export * from './preference-schema-service';

package/src/common/preferences/preference-scope.spec.ts

@@ -20,11 +20,11 @@ import { PreferenceScope } from './preference-scope';
 describe('PreferenceScope', () => {
 
     it('getScopes() should return numbers from broadest to narrowest', () => {
-        expect(PreferenceScope.getScopes()).deep.equal([0, 1, 2, 3]);
+        expect(PreferenceScope.getScopes()).deep.equal([0, 1, 2, 3, 4]);
     });
 
     it('getReversedScopes() should return numbers from narrowest to broadest', () => {
-        expect(PreferenceScope.getReversedScopes()).deep.equal([3, 2, 1, 0]);
+        expect(PreferenceScope.getReversedScopes()).deep.equal([4, 3, 2, 1, 0]);
     });
 
     it('getScopeNames() should return the names of scopes broader than the current one', () => {
@@ -36,11 +36,13 @@ describe('PreferenceScope', () => {
         expect(PreferenceScope.is(PreferenceScope.User)).to.be.true;
         expect(PreferenceScope.is(PreferenceScope.Workspace)).to.be.true;
         expect(PreferenceScope.is(PreferenceScope.Folder)).to.be.true;
+        expect(PreferenceScope.is(PreferenceScope.Session)).to.be.true;
         expect(PreferenceScope.is(0)).to.be.true;
         expect(PreferenceScope.is(1)).to.be.true;
         expect(PreferenceScope.is(2)).to.be.true;
         expect(PreferenceScope.is(3)).to.be.true;
-        expect(PreferenceScope.is(4)).to.be.false;
+        expect(PreferenceScope.is(4)).to.be.true;
+        expect(PreferenceScope.is(5)).to.be.false;
         expect(PreferenceScope.is(-1)).to.be.false;
         expect(PreferenceScope.is({})).to.be.false;
         expect(PreferenceScope.is('Default')).to.be.false;

package/src/common/preferences/preference-scope.ts

@@ -23,7 +23,12 @@ export enum PreferenceScope {
     Default,
     User,
     Workspace,
-    Folder
+    Folder,
+    /**
+     * Process-lifetime, in-memory scope used by `--session-preference` CLI overrides.
+     * Has the highest precedence and is never persisted to disk.
+     */
+    Session
 }
 
 export namespace PreferenceScope {

package/src/common/preferences/preference-service.ts

@@ -254,6 +254,10 @@ export interface PreferenceInspection<T = JSONValue> {
      * Value in folder scope.
      */
     workspaceFolderValue: T | undefined,
+    /**
+     * Value in session scope (in-memory, set via `--session-preference`).
+     */
+    sessionValue?: T | undefined,
     /**
      * The value that is active, i.e. the value set in the lowest scope available.
      */
@@ -453,11 +457,37 @@ export class PreferenceServiceImpl implements PreferenceService {
         }
         const provider = this.getProvider(resolvedScope);
         if (provider && await provider.setPreference(preferenceName, value, resourceUri)) {
+            await this.evictSessionOverride(preferenceName, resolvedScope);
             return;
         }
         throw new Error(`Unable to write to ${PreferenceScope[resolvedScope]} Settings.`);
     }
 
+    /**
+     * When a preference is written to a persistent scope, drop any in-memory session
+     * override (set via `--session-preference`) for the same key so that the explicit
+     * change takes effect for the remainder of the session. Without this, the session
+     * scope would keep shadowing the user's change because it has higher precedence.
+     *
+     * Note: this fires for any write to a persistent scope, including programmatic
+     * writes from extensions. Extensions that race with startup CLI overrides will
+     * therefore clear them. This is intentional: a programmatic write is "explicit"
+     * from the preference system's point of view, but consumers should be aware.
+     *
+     * Session preferences are global (no per-resource scoping), so `resourceUri` is
+     * not threaded through.
+     */
+    protected async evictSessionOverride(preferenceName: string, writtenScope: PreferenceScope): Promise<void> {
+        if (writtenScope === PreferenceScope.Session || writtenScope === PreferenceScope.Default) {
+            return;
+        }
+        const sessionProvider = this.getProvider(PreferenceScope.Session);
+        if (sessionProvider && sessionProvider.get(preferenceName) !== undefined) {
+            // Passing `undefined` clears the value in the session provider.
+            await sessionProvider.setPreference(preferenceName, undefined as unknown as JSONValue);
+        }
+    }
+
     getBoolean(preferenceName: string): boolean | undefined;
     getBoolean(preferenceName: string, defaultValue: boolean): boolean;
     getBoolean(preferenceName: string, defaultValue: boolean, resourceUri: string): boolean;
@@ -499,10 +529,11 @@ export class PreferenceServiceImpl implements PreferenceService {
         const globalValue = this.inspectInScope<T>(preferenceName, PreferenceScope.User, resourceUri, forceLanguageOverride);
         const workspaceValue = this.inspectInScope<T>(preferenceName, PreferenceScope.Workspace, resourceUri, forceLanguageOverride);
         const workspaceFolderValue = this.inspectInScope<T>(preferenceName, PreferenceScope.Folder, resourceUri, forceLanguageOverride);
+        const sessionValue = this.inspectInScope<T>(preferenceName, PreferenceScope.Session, resourceUri, forceLanguageOverride);
 
-        const valueApplied = workspaceFolderValue ?? workspaceValue ?? globalValue ?? defaultValue;
+        const valueApplied = sessionValue ?? workspaceFolderValue ?? workspaceValue ?? globalValue ?? defaultValue;
 
-        return { preferenceName, defaultValue, globalValue, workspaceValue, workspaceFolderValue, value: valueApplied };
+        return { preferenceName, defaultValue, globalValue, workspaceValue, workspaceFolderValue, sessionValue, value: valueApplied };
     }
 
     inspectInScope<T extends JSONValue>(preferenceName: string, scope: PreferenceScope, resourceUri?: string, forceLanguageOverride?: boolean): T | undefined {
@@ -526,6 +557,8 @@ export class PreferenceServiceImpl implements PreferenceService {
                 return inspection.workspaceValue;
             case PreferenceScope.Folder:
                 return inspection.workspaceFolderValue;
+            case PreferenceScope.Session:
+                return inspection.sessionValue;
         }
         unreachable(scope, 'Not all PreferenceScope enum variants handled.');
     }
@@ -551,9 +584,10 @@ export class PreferenceServiceImpl implements PreferenceService {
         }
 
         // Scopes in ascending order of scope breadth.
-        const allScopes = [...this.schemaService.validScopes].reverse();
-        // Get rid of Default scope. We can't set anything there.
-        allScopes.pop();
+        const allScopes = [...this.schemaService.validScopes].reverse()
+            // Default is read-only, and Session is populated only by `--session-preference`,
+            // so neither is a valid target for a regular user edit.
+            .filter(scope => scope !== PreferenceScope.Default && scope !== PreferenceScope.Session);
 
         const isScopeDefined = (scope: PreferenceScope) => this.getScopedValueFromInspection(inspection, scope) !== undefined;
 

package/src/common/preferences/session-preference-provider.spec.ts

@@ -0,0 +1,78 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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 { SessionPreferenceProvider } from './session-preference-provider';
+import { PreferenceScope } from './preference-scope';
+
+describe('SessionPreferenceProvider', () => {
+
+    let provider: SessionPreferenceProvider;
+
+    beforeEach(() => {
+        provider = new SessionPreferenceProvider();
+        // PostConstruct emulation
+        (provider as unknown as { init(): void }).init();
+    });
+
+    it('claims only the Session scope', () => {
+        expect(provider.canHandleScope(PreferenceScope.Session)).to.be.true;
+        expect(provider.canHandleScope(PreferenceScope.User)).to.be.false;
+        expect(provider.canHandleScope(PreferenceScope.Workspace)).to.be.false;
+        expect(provider.canHandleScope(PreferenceScope.Folder)).to.be.false;
+        expect(provider.canHandleScope(PreferenceScope.Default)).to.be.false;
+    });
+
+    it('starts empty', () => {
+        expect(provider.getPreferences()).to.deep.equal({});
+    });
+
+    it('stores set values in memory and exposes them via get/resolve', async () => {
+        const ok = await provider.setPreference('editor.fontSize', 18);
+        expect(ok).to.be.true;
+        expect(provider.get('editor.fontSize')).to.equal(18);
+        expect(provider.resolve('editor.fontSize').value).to.equal(18);
+        expect(provider.getPreferences()).to.deep.equal({ 'editor.fontSize': 18 });
+    });
+
+    it('emits a change event on set', async () => {
+        let received: { name: string; newValue: unknown; oldValue: unknown; scope: PreferenceScope } | undefined;
+        provider.onDidPreferencesChanged(changes => {
+            const key = Object.keys(changes)[0];
+            received = {
+                name: changes[key].preferenceName,
+                newValue: changes[key].newValue,
+                oldValue: changes[key].oldValue,
+                scope: changes[key].scope
+            };
+        });
+        await provider.setPreference('foo', 'bar');
+        expect(received).to.deep.equal({ name: 'foo', newValue: 'bar', oldValue: undefined, scope: PreferenceScope.Session });
+    });
+
+    it('removes a value when set to undefined', async () => {
+        await provider.setPreference('foo', 'bar');
+        const removed = await provider.setPreference('foo', undefined as never);
+        expect(removed).to.be.true;
+        expect(provider.get('foo')).to.equal(undefined);
+        expect(provider.getPreferences()).to.deep.equal({});
+    });
+
+    it('returns false when removing a key that was never set', async () => {
+        const removed = await provider.setPreference('missing', undefined as never);
+        expect(removed).to.be.false;
+    });
+});

package/src/common/preferences/session-preference-provider.ts

@@ -0,0 +1,69 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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 { JSONObject, JSONValue } from '@lumino/coreutils';
+import { injectable, postConstruct } from 'inversify';
+import { PreferenceProvider, PreferenceProviderDataChange } from './preference-provider';
+import { PreferenceProviderImpl } from './preference-provider-impl';
+import { PreferenceScope } from './preference-scope';
+
+/**
+ * In-memory preference provider used for process-lifetime overrides such as those
+ * supplied via the `--session-preference` CLI option. Values live in memory only
+ * and are dropped when the process exits.
+ */
+@injectable()
+export class SessionPreferenceProvider extends PreferenceProviderImpl implements PreferenceProvider {
+
+    protected readonly preferences = new Map<string, JSONValue>();
+
+    @postConstruct()
+    protected init(): void {
+        this._ready.resolve();
+    }
+
+    override canHandleScope(scope: PreferenceScope): boolean {
+        return scope === PreferenceScope.Session;
+    }
+
+    getPreferences(): JSONObject {
+        const result: JSONObject = {};
+        for (const [name, value] of this.preferences) {
+            result[name] = value;
+        }
+        return result;
+    }
+
+    async setPreference(key: string, value: JSONValue | undefined): Promise<boolean> {
+        const oldValue = this.preferences.get(key);
+        if (value === undefined) {
+            if (!this.preferences.has(key)) {
+                return false;
+            }
+            this.preferences.delete(key);
+        } else {
+            this.preferences.set(key, value);
+        }
+        const change: PreferenceProviderDataChange = {
+            preferenceName: key,
+            newValue: value,
+            oldValue,
+            scope: PreferenceScope.Session
+        };
+        await this.emitPreferencesChangedEvent([change]);
+        return true;
+    }
+}

package/src/electron-node/hosting/electron-backend-hosting-module.spec.ts

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// 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 { Container } from 'inversify';
+import electronBackendHostingModule from './electron-backend-hosting-module';
+import { HttpConnectionValidator } from '../../node/hosting/browser-connection-token';
+
+describe('electron-backend-hosting-module', () => {
+
+    it('should bind a no-op HttpConnectionValidator that calls next() unconditionally', () => {
+        const container = new Container();
+        container.load(electronBackendHostingModule);
+        const validator = container.get<HttpConnectionValidator>(HttpConnectionValidator);
+
+        let nextCalled = false;
+        let sentStatus: number | undefined;
+        // No cookie provided: the no-op validator must still call next() and never send a status.
+        const req = { headers: {} as Record<string, string | undefined> };
+        const res = { sendStatus: (status: number) => { sentStatus = status; } };
+        const next = (): void => { nextCalled = true; };
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        validator.validateRequest(req as any, res as any, next as any);
+
+        expect(nextCalled).to.be.true;
+        expect(sentStatus).to.be.undefined;
+    });
+});

package/src/electron-node/hosting/electron-backend-hosting-module.ts

@@ -16,9 +16,17 @@
 
 import { ContainerModule } from 'inversify';
 import { WsRequestValidatorContribution } from '../../node/ws-request-validators';
+import { HttpConnectionValidator } from '../../node/hosting/browser-connection-token';
 import { ElectronWsOriginValidator } from './electron-ws-origin-validator';
 
 export default new ContainerModule(bind => {
     bind(ElectronWsOriginValidator).toSelf().inSingletonScope();
     bind(WsRequestValidatorContribution).toService(ElectronWsOriginValidator);
+
+    // Electron uses its own `ElectronSecurityToken`, so the connection-token cookie is not used.
+    // Bind a no-op validator so consumers can inject it uniformly.
+    const noopValidator: HttpConnectionValidator = {
+        validateRequest: (_req, _res, next) => next()
+    };
+    bind(HttpConnectionValidator).toConstantValue(noopValidator);
 });

package/src/node/hosting/backend-hosting-module.ts

@@ -19,7 +19,7 @@ import { BackendApplicationContribution } from '../backend-application';
 import { WsRequestValidatorContribution } from '../ws-request-validators';
 import { BackendApplicationHosts } from './backend-application-hosts';
 import {
-    BrowserConnectionToken, BrowserConnectionTokenBackendContribution, createBrowserConnectionToken
+    BrowserConnectionToken, BrowserConnectionTokenBackendContribution, HttpConnectionValidator, createBrowserConnectionToken
 } from './browser-connection-token';
 import { WsOriginValidator } from './ws-origin-validator';
 
@@ -28,9 +28,12 @@ export default new ContainerModule(bind => {
     bind(WsOriginValidator).toSelf().inSingletonScope();
     bind(WsRequestValidatorContribution).toService(WsOriginValidator);
 
-    // Cookie-based connection token protects both HTTP and WebSocket endpoints.
+    // Cookie-based connection token. It is validated on WebSocket upgrades and bootstrapped
+    // (set as a cookie) on every HTTP request; HTTP enforcement is opt-in per route via
+    // `HttpConnectionValidator`.
     bind(BrowserConnectionToken).toConstantValue(createBrowserConnectionToken());
     bind(BrowserConnectionTokenBackendContribution).toSelf().inSingletonScope();
     bind(BackendApplicationContribution).toService(BrowserConnectionTokenBackendContribution);
     bind(WsRequestValidatorContribution).toService(BrowserConnectionTokenBackendContribution);
+    bind(HttpConnectionValidator).toService(BrowserConnectionTokenBackendContribution);
 });