@theia/plugin-ext 1.76.0-next.7 → 1.77.0-next.0

package/src/main/browser/editors-and-documents-main.spec.ts

@@ -0,0 +1,140 @@
+// *****************************************************************************
+// Copyright (C) 2026 JuliaHub, Inc. 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { Emitter, URI } from '@theia/core';
+import { BaseWidget, Navigatable, Saveable, SaveableSource, Widget } from '@theia/core/lib/browser';
+import { SaveableService } from '@theia/core/lib/browser/saveable-service';
+import { EditorManager, EditorWidget } from '@theia/editor/lib/browser';
+import { EditorsAndDocumentsMain } from './editors-and-documents-main';
+
+disableJSDOM();
+
+class TestSaveable implements Saveable {
+    dirty = true;
+    readonly onDirtyChanged = new Emitter<void>().event;
+    readonly onContentChanged = new Emitter<void>().event;
+    saveCount = 0;
+
+    async save(): Promise<void> {
+        this.saveCount++;
+        this.dirty = false;
+    }
+}
+
+/** Navigatable to the resource, but with nothing to save. */
+class TestNavigatableWidget extends BaseWidget implements Navigatable {
+    constructor(private readonly uri: URI) {
+        super();
+    }
+
+    getResourceUri(): URI {
+        return this.uri;
+    }
+
+    createMoveToUri(): URI {
+        return this.uri;
+    }
+}
+
+/** Stands in for a `CustomEditorWidget`: saveable and navigatable, but not an `EditorWidget`. */
+class TestSaveableWidget extends TestNavigatableWidget implements SaveableSource {
+    readonly saveable = new TestSaveable();
+}
+
+function createEditorsAndDocumentsMain(
+    editor: EditorWidget | undefined,
+    widgets: Widget[]
+): EditorsAndDocumentsMain {
+    // Bypass the constructor's RPC/container wiring: `save` and `saveAs` only touch the
+    // editor manager, the shell and the saveable service.
+    const main = Object.create(EditorsAndDocumentsMain.prototype) as EditorsAndDocumentsMain;
+    const fields = main as unknown as Record<string, unknown>;
+    fields.editorManager = { getByUri: async () => editor } as unknown as EditorManager;
+    fields.shell = { widgets };
+    fields.saveResourceService = new SaveableService();
+    return main;
+}
+
+describe('EditorsAndDocumentsMain#save', () => {
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    const uri = new URI('custom-editor:/some/resource?viewType=test');
+
+    it('saves a saveable widget that the editor manager does not know', async () => {
+        const widget = new TestSaveableWidget(uri);
+        const main = createEditorsAndDocumentsMain(undefined, [widget]);
+
+        const saved = await main.save(uri);
+
+        expect(widget.saveable.saveCount).to.equal(1);
+        expect(saved?.toString()).to.equal(uri.toString());
+    });
+
+    it('prefers the text editor when the editor manager has one', async () => {
+        const editor = new TestSaveableWidget(uri);
+        const custom = new TestSaveableWidget(uri);
+        const main = createEditorsAndDocumentsMain(editor as unknown as EditorWidget, [custom]);
+
+        await main.save(uri);
+
+        expect(editor.saveable.saveCount).to.equal(1);
+        expect(custom.saveable.saveCount).to.equal(0);
+    });
+
+    it('leaves widgets bound to another resource alone', async () => {
+        const other = new TestSaveableWidget(new URI('custom-editor:/other/resource'));
+        const main = createEditorsAndDocumentsMain(undefined, [other]);
+
+        const saved = await main.save(uri);
+
+        expect(other.saveable.saveCount).to.equal(0);
+        expect(saved).to.be.undefined;
+    });
+
+    it('ignores a widget that is navigatable to the resource but not saveable', async () => {
+        const main = createEditorsAndDocumentsMain(undefined, [new TestNavigatableWidget(uri)]);
+
+        expect(await main.save(uri)).to.be.undefined;
+    });
+
+    it('resolves saveAs through the same fallback', async () => {
+        const widget = new TestSaveableWidget(uri);
+        const main = createEditorsAndDocumentsMain(undefined, [widget]);
+        const saveAsTargets: Widget[] = [];
+        // `SaveableService.canSaveAs` is unconditionally false on the base class, so the
+        // service is stubbed to reach the `saveAs` branch at all.
+        (main as unknown as Record<string, unknown>).saveResourceService = {
+            canSaveAs: (candidate: Widget) => candidate === widget,
+            saveAs: async (target: Widget) => { saveAsTargets.push(target); return uri; }
+        };
+
+        const saved = await main.saveAs(uri);
+
+        expect(saveAsTargets).to.deep.equal([widget]);
+        expect(saved?.toString()).to.equal(uri.toString());
+    });
+});

package/src/main/browser/editors-and-documents-main.ts

@@ -33,6 +33,7 @@ import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
 import { TextEditorMain } from './text-editor-main';
 import { DisposableCollection, Emitter, URI } from '@theia/core';
 import { EditorManager, EditorWidget } from '@theia/editor/lib/browser';
+import { ApplicationShell, NavigatableWidget, Saveable, Widget } from '@theia/core/lib/browser';
 import { SaveableService } from '@theia/core/lib/browser/saveable-service';
 import { TabsMainImpl } from './tabs/tabs-main';
 import { NotebookCellEditorService, NotebookEditorWidgetService } from '@theia/notebook/lib/browser';
@@ -48,6 +49,7 @@ export class EditorsAndDocumentsMain implements Disposable {
 
     private readonly modelService: EditorModelService;
     private readonly editorManager: EditorManager;
+    private readonly shell: ApplicationShell;
     private readonly saveResourceService: SaveableService;
     private readonly encodingRegistry: EncodingRegistry;
 
@@ -69,6 +71,7 @@ export class EditorsAndDocumentsMain implements Disposable {
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.EDITORS_AND_DOCUMENTS_EXT);
 
         this.editorManager = container.get(EditorManager);
+        this.shell = container.get(ApplicationShell);
         this.modelService = container.get(EditorModelService);
         this.saveResourceService = container.get(SaveableService);
         this.encodingRegistry = container.get(EncodingRegistry);
@@ -183,22 +186,31 @@ export class EditorsAndDocumentsMain implements Disposable {
     }
 
     async save(uri: URI): Promise<URI | undefined> {
-        const editor = await this.editorManager.getByUri(uri);
-        if (!editor) {
+        const widget = await this.getSaveTarget(uri);
+        if (!widget) {
             return undefined;
         }
-        return this.saveResourceService.save(editor);
+        return this.saveResourceService.save(widget);
     }
 
     async saveAs(uri: URI): Promise<URI | undefined> {
-        const editor = await this.editorManager.getByUri(uri);
-        if (!editor) {
+        const widget = await this.getSaveTarget(uri);
+        if (!widget) {
             return undefined;
         }
-        if (!this.saveResourceService.canSaveAs(editor)) {
+        if (!this.saveResourceService.canSaveAs(widget)) {
             return undefined;
         }
-        return this.saveResourceService.saveAs(editor);
+        return this.saveResourceService.saveAs(widget);
+    }
+
+    /**
+     * Resolve the widget holding `uri`, preferring a text editor. Custom editors and notebooks
+     * are not opened by the `EditorManager`, so they are only reachable through the shell.
+     */
+    protected async getSaveTarget(uri: URI): Promise<Widget | undefined> {
+        return await this.editorManager.getByUri(uri)
+            ?? this.shell.widgets.find(widget => Saveable.get(widget) && NavigatableWidget.getUri(widget)?.isEqual(uri));
     }
 
     saveAll(includeUntitled?: boolean): Promise<boolean> {

package/src/main/browser/languages-main.spec.ts

@@ -0,0 +1,101 @@
+// *****************************************************************************
+// Copyright (C) 2026 JuliaHub, Inc. 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+// `languages-main` transitively pulls in Monaco and several frontend modules that touch `document`
+// at module-load time.
+const disableJSDOM = enableJSDOM();
+import { expect } from 'chai';
+import * as monaco from '@theia/monaco-editor-core';
+import { mainWindow } from '@theia/monaco-editor-core/esm/vs/base/browser/window';
+import { URI } from '@theia/core/lib/common/uri';
+import { expectThrowsAsync } from '@theia/core/lib/common/test/expect';
+import { CellEditType, CellUri } from '@theia/notebook/lib/common';
+import { CellEditOperation } from '@theia/notebook/lib/browser/notebook-types';
+import type { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
+import { LanguagesMainImpl } from './languages-main';
+
+after(() => disableJSDOM());
+
+const notebookUri = new URI('file:///notebook.ipynb');
+const cellHandle = 3;
+const cellComponents = CellUri.generate(notebookUri, cellHandle).toComponents();
+
+type FakeNotebookModel = Pick<NotebookModel, 'getCellIndexByHandle' | 'applyEdits'> & {
+    edits: CellEditOperation[][];
+};
+
+function createNotebookModel(handles: number[]): FakeNotebookModel {
+    const edits: CellEditOperation[][] = [];
+    return {
+        edits,
+        getCellIndexByHandle: handle => handles.indexOf(handle),
+        applyEdits: applied => { edits.push(applied); }
+    };
+}
+
+/**
+ * Bypasses the constructor's RPC/container wiring.
+ */
+function createLanguagesMain(notebook?: FakeNotebookModel): LanguagesMainImpl {
+    const languagesMain = Object.create(LanguagesMainImpl.prototype) as LanguagesMainImpl;
+    (languagesMain as unknown as Record<string, unknown>).notebookService = {
+        getNotebookEditorModel: (uri: URI) => uri.toString() === notebookUri.toString() ? notebook : undefined
+    };
+    return languagesMain;
+}
+
+describe('LanguagesMainImpl#$changeLanguage', () => {
+
+    before(() => {
+        // Resolving a language id boots Monaco's standalone services, whose theme service reaches for
+        // DOM APIs JSDOM does not provide. Monaco captures its window at module load.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (global as any).CSS ??= { escape: (value: string) => value };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (mainWindow as any).matchMedia ??= () => ({ matches: false, addEventListener: () => { }, removeEventListener: () => { } });
+        monaco.languages.register({ id: 'julia' });
+    });
+
+    it('applies a cell language edit for a notebook cell', async () => {
+        const notebook = createNotebookModel([1, 2, cellHandle]);
+        const languagesMain = createLanguagesMain(notebook);
+
+        await languagesMain.$changeLanguage(cellComponents, 'julia');
+
+        expect(notebook.edits).to.deep.equal([[{ editType: CellEditType.CellLanguage, index: 2, language: 'julia' }]]);
+    });
+
+    it('rejects for a cell of a notebook that is not open', async () => {
+        const languagesMain = createLanguagesMain();
+
+        await expectThrowsAsync(languagesMain.$changeLanguage(cellComponents, 'julia'), 'Invalid uri');
+    });
+
+    it('rejects for a cell handle the notebook does not know', async () => {
+        const languagesMain = createLanguagesMain(createNotebookModel([1, 2]));
+
+        await expectThrowsAsync(languagesMain.$changeLanguage(cellComponents, 'julia'), 'Invalid uri');
+    });
+
+    it('rejects an unknown language id before touching the notebook', async () => {
+        const notebook = createNotebookModel([cellHandle]);
+        const languagesMain = createLanguagesMain(notebook);
+
+        await expectThrowsAsync(languagesMain.$changeLanguage(cellComponents, 'no-such-language'), /Unknown language ID/);
+        expect(notebook.edits).to.be.empty;
+    });
+});

package/src/main/browser/languages-main.ts

@@ -88,6 +88,8 @@ import { CodeActionTriggerKind } from '../../plugin/types-impl';
 import { IReadonlyVSDataTransfer } from '@theia/monaco-editor-core/esm/vs/base/common/dataTransfer';
 import { FileUploadService } from '@theia/filesystem/lib/common/upload/file-upload';
 import { ILogger } from '@theia/core';
+import { NotebookService } from '@theia/notebook/lib/browser';
+import { CellEditType, CellUri } from '@theia/notebook/lib/common';
 
 @injectable()
 export class LanguagesMainImpl implements LanguagesMain, Disposable {
@@ -110,6 +112,9 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     @inject(FileUploadService)
     protected readonly fileUploadService: FileUploadService;
 
+    @inject(NotebookService)
+    protected readonly notebookService: NotebookService;
+
     @inject(ILogger) @named('plugin-ext:LanguagesMainImpl')
     protected readonly logger: ILogger;
 
@@ -129,18 +134,35 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         return Promise.resolve(monaco.languages.getLanguages().map(l => l.id));
     }
 
-    $changeLanguage(resource: UriComponents, languageId: string): Promise<void> {
-        const uri = monaco.Uri.revive(resource);
-        const model = monaco.editor.getModel(uri);
-        if (!model) {
-            return Promise.reject(new Error('Invalid uri'));
+    async $changeLanguage(resource: UriComponents, languageId: string): Promise<void> {
+        if (!monaco.languages.getEncodedLanguageId(languageId)) {
+            throw new Error(`Unknown language ID: ${languageId}`);
         }
-        const langId = monaco.languages.getEncodedLanguageId(languageId);
-        if (!langId) {
-            return Promise.reject(new Error(`Unknown language ID: ${languageId}`));
+        const cell = CellUri.parse(URI.fromComponents(resource));
+        if (cell) {
+            this.changeCellLanguage(cell.notebook, cell.handle, languageId);
+            return;
+        }
+        const model = monaco.editor.getModel(monaco.Uri.revive(resource));
+        if (!model) {
+            throw new Error('Invalid uri');
         }
         monaco.editor.setModelLanguage(model, languageId);
-        return Promise.resolve(undefined);
+    }
+
+    /**
+     * The cell model owns a cell's language; kernel selection, serialization, and the cell editor all follow it.
+     */
+    protected changeCellLanguage(notebookUri: URI, handle: number, languageId: string): void {
+        const notebook = this.notebookService.getNotebookEditorModel(notebookUri);
+        if (!notebook) {
+            throw new Error('Invalid uri');
+        }
+        const index = notebook.getCellIndexByHandle(handle);
+        if (index < 0) {
+            throw new Error('Invalid uri');
+        }
+        notebook.applyEdits([{ editType: CellEditType.CellLanguage, index, language: languageId }], true);
     }
 
     protected register(handle: number, service: Disposable): void {

package/src/main/browser/main-context.ts

@@ -68,6 +68,7 @@ import { UriMainImpl } from './uri-main';
 import { LoggerMainImpl } from './logger-main';
 import { McpServerDefinitionRegistryMainImpl } from './lm-main';
 import { LanguageModelToolsMainImpl } from './lm-tool-main';
+import { TelemetryMainImpl } from './telemetry-main';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const loggerMain = new LoggerMainImpl(container);
@@ -215,4 +216,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
 
     const languageModelToolsMain = new LanguageModelToolsMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.LM_TOOLS_MAIN, languageModelToolsMain);
+
+    const telemetryMain = new TelemetryMainImpl(rpc, container);
+    rpc.set(PLUGIN_RPC_CONTEXT.TELEMETRY_MAIN, telemetryMain);
 }

package/src/main/browser/menus/vscode-theia-menu-mappings.ts

@@ -128,6 +128,11 @@ export const codeToTheiaMappings = new Map<string, MenuPath[]>([
 
 type CodeEditorWidget = EditorWidget | WebviewWidget;
 export namespace CodeEditorWidgetUtil {
+    /**
+     * The widgets `editor/title` contributions apply to. `WebviewContextKeys.getContextKeyValues` describes
+     * exactly this set; a widget admitted to the menu delegate without also being described there reads a
+     * stale `activeCustomEditorId` from the focused editor.
+     */
     export function is(arg: unknown): arg is CodeEditorWidget {
         return arg instanceof EditorWidget || arg instanceof WebviewWidget;
     }

package/src/main/browser/plugin-ext-frontend-module.ts

@@ -24,7 +24,7 @@ import {
     ViewContainerIdentifier, ViewContainer, createTreeContainer, TreeWidget, LabelProviderContribution, LabelProvider,
     UndoRedoHandler, DiffUris, Navigatable, SplitWidget,
     noopWidgetStatusBarContribution,
-    WidgetStatusBarContribution
+    WidgetStatusBarContribution, WidgetContextKeyContribution
 } from '@theia/core/lib/browser';
 import { MaybePromise, CommandContribution, ResourceResolver, bindRootContributionProvider, URI, generateUuid, PreferenceContribution, nls } from '@theia/core/lib/common';
 import { WebSocketConnectionProvider } from '@theia/core/lib/browser/messaging';
@@ -198,6 +198,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(WebviewSecondaryWindowSupport).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(WebviewSecondaryWindowSupport);
     bind(FrontendApplicationContribution).toService(WebviewContextKeys);
+    bind(WidgetContextKeyContribution).toService(WebviewContextKeys);
     bind(WidgetStatusBarContribution).toConstantValue(noopWidgetStatusBarContribution(WebviewWidget));
 
     bind(PluginCustomEditorRegistry).toSelf().inSingletonScope();

package/src/main/browser/plugin-icon-service.spec.ts

@@ -0,0 +1,101 @@
+// *****************************************************************************
+// Copyright (C) 2026 Robert Jandow
+//
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+// `PluginIconService` transitively imports monaco modules that touch `document` at load time,
+// and `toPluginUrl` itself needs `self.location` (via `Endpoint`) at call time, so JSDOM is
+// re-enabled for the test run below.
+let disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { URI } from '@theia/core/shared/vscode-uri';
+import { PLUGINS_SCHEME } from '@theia/plugin-utils/lib/common/constants';
+import { PluginIconService } from './plugin-icon-service';
+
+disableJSDOM();
+
+/** Widens `protected` members to `public` so the tests can call them directly. */
+class TestablePluginIconService extends PluginIconService {
+    public callToPluginRelativePath(fontUri: URI): string {
+        return this.toPluginRelativePath(fontUri);
+    }
+
+    public callToPluginUrl(id: string, relativePath: string): URI {
+        return this.toPluginUrl(id, relativePath);
+    }
+}
+
+describe('PluginIconService', () => {
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    let service: TestablePluginIconService;
+
+    beforeEach(() => {
+        service = new TestablePluginIconService();
+    });
+
+    describe('toPluginRelativePath', () => {
+
+        it('drops the plugin id segment of a plugin asset URI and keeps the rest verbatim', () => {
+            const uri = URI.parse(`${PLUGINS_SCHEME}:/acme_ext/dist/font.woff`);
+            expect(service.callToPluginRelativePath(uri)).to.equal('dist/font.woff');
+        });
+
+        it('resolves a deeply nested path under a plugin asset URI', () => {
+            const uri = URI.parse(`${PLUGINS_SCHEME}:/acme_ext/a/b/c/d/font.woff`);
+            expect(service.callToPluginRelativePath(uri)).to.equal('a/b/c/d/font.woff');
+        });
+
+        it('resolves a single-segment path under a plugin asset URI', () => {
+            const uri = URI.parse(`${PLUGINS_SCHEME}:/acme_ext/font.woff`);
+            expect(service.callToPluginRelativePath(uri)).to.equal('font.woff');
+        });
+
+        it('decodes characters that were percent-encoded in a plugin asset URI', () => {
+            const uri = URI.parse(`${PLUGINS_SCHEME}:/acme_ext/dist/my%20font%23file.woff`);
+            expect(service.callToPluginRelativePath(uri)).to.equal('dist/my font#file.woff');
+        });
+
+        it('falls back to cutting a backend (non-plugin-asset) path at its `extension` segment', () => {
+            const uri = URI.parse('file:///plugins/acme.ext-1.0.0/extension/dist/font.woff');
+            expect(service.callToPluginRelativePath(uri)).to.equal('dist/font.woff');
+        });
+
+        it('returns an empty string for a backend path that has no `extension` segment', () => {
+            const uri = URI.parse('file:///plugins/acme.ext-1.0.0/dist/font.woff');
+            expect(service.callToPluginRelativePath(uri)).to.equal('');
+        });
+
+    });
+
+    describe('toPluginUrl', () => {
+
+        it('keeps `/` literal while percent-encoding special characters within each segment', () => {
+            const url = service.callToPluginUrl('acme.ext', 'dist/sub dir/a#b?c%d.woff');
+            expect(url.toString()).to.match(/\/hostedPlugin\/acme_ext\/dist\/sub%20dir\/a%23b%3Fc%25d\.woff$/);
+            // the slashes between segments must not themselves be encoded
+            expect(url.toString()).to.not.include('%2F');
+        });
+
+        it('replaces non-word characters in the plugin id to build the URL segment', () => {
+            const url = service.callToPluginUrl('acme.ext-1.0.0', 'font.woff');
+            expect(url.toString()).to.match(/\/hostedPlugin\/acme_ext_1_0_0\/font\.woff$/);
+        });
+
+    });
+
+});

package/src/main/browser/plugin-icon-service.ts

@@ -21,7 +21,8 @@ import { URI } from '@theia/core/shared/vscode-uri';
 import { MonacoIconRegistry } from '@theia/monaco/lib/browser/monaco-icon-registry';
 import * as path from 'path';
 import { IconContribution, DeployedPlugin, IconDefinition } from '../../common/plugin-protocol';
-import { PLUGINS_BASE_PATH } from '@theia/plugin-utils/lib/common/constants';
+import { PLUGINS_BASE_PATH, PLUGINS_SCHEME } from '@theia/plugin-utils/lib/common/constants';
+import { encodePluginAssetPath } from '@theia/plugin-utils/lib/common/plugin-model';
 
 @injectable()
 export class PluginIconService implements Disposable {
@@ -49,7 +50,7 @@ export class PluginIconService implements Disposable {
     }
 
     protected registerFontIcon(contribution: IconContribution, defaultIcon: IconDefinition): void {
-        const location = this.toPluginUrl(contribution.extensionId, getIconRelativePath(URI.parse(defaultIcon.location).path));
+        const location = this.toPluginUrl(contribution.extensionId, this.toPluginRelativePath(URI.parse(defaultIcon.location)));
         const format = getFileExtension(location.path);
         const fontId = getFontId(contribution.extensionId, location.path);
 
@@ -67,9 +68,21 @@ export class PluginIconService implements Disposable {
         this.iconRegistry.registerIcon(contribution.id, { id: defaultIconId }, contribution.description);
     }
 
+    /**
+     * With a backend the font sits in the extracted VSIX, so the path has to be cut at its
+     * `extension` segment. Browser-only emits `<PLUGINS_SCHEME>:/<id>/<path>` instead, where
+     * everything past the plugin id already is the path relative to the plugin root.
+     */
+    protected toPluginRelativePath(fontUri: URI): string {
+        if (fontUri.scheme === PLUGINS_SCHEME) {
+            return fontUri.path.split('/').slice(2).join('/');
+        }
+        return getIconRelativePath(fontUri.path);
+    }
+
     protected toPluginUrl(id: string, relativePath: string): URI {
         return URI.from(new Endpoint({
-            path: `${PLUGINS_BASE_PATH}/${this.formatExtensionId(id)}/${encodeURIComponent(relativePath)}`
+            path: `${PLUGINS_BASE_PATH}/${this.formatExtensionId(id)}/${encodePluginAssetPath(relativePath)}`
         }).getRestUrl().toComponents());
     }
 

package/src/main/browser/plugin-icon-theme-service.spec.ts

@@ -0,0 +1,103 @@
+// *****************************************************************************
+// Copyright (C) 2026 Robert Jandow
+//
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+// `PluginIconTheme` transitively imports monaco/filesystem/workspace modules that touch `document`
+// at load time, and `toCSSUrl` needs `self.location` (via `Endpoint`) at call time, so JSDOM is
+// re-enabled for the test run below.
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+// `WorkspaceService`, transitively imported for `PluginIconTheme`'s `@inject` property, reads the
+// frontend application config at module load time.
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import URI from '@theia/core/lib/common/uri';
+import { PLUGINS_SCHEME } from '@theia/plugin-utils/lib/common/constants';
+import { PluginIconTheme } from './plugin-icon-theme-service';
+
+disableJSDOM();
+
+/**
+ * Widens `protected` members to `public`/settable so the tests can drive `toCSSUrl` without going
+ * through `@postConstruct` and the full Inversify container - none of the injected services
+ * (`FileService`, `LabelProvider`, etc.) are touched by it.
+ */
+class TestablePluginIconTheme extends PluginIconTheme {
+
+    setState(state: { uri: string; pluginId: string; packageUri: string }): void {
+        this.uri = state.uri;
+        this.pluginId = state.pluginId;
+        this.packageUri = state.packageUri;
+        this.locationUri = new URI(state.uri).parent;
+        this.packageRootUri = new URI(state.packageUri);
+    }
+
+    callToCSSUrl(iconPath: string | undefined): string | undefined {
+        return this.toCSSUrl(iconPath);
+    }
+}
+
+describe('PluginIconTheme', () => {
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    describe('toCSSUrl', () => {
+
+        it('resolves an icon path relative to a browser-only plugin package root into a static plugin asset URL', () => {
+            const theme = new TestablePluginIconTheme();
+            theme.setState({
+                uri: `${PLUGINS_SCHEME}:/acme_ext/themes/my-icon-theme.json`,
+                pluginId: 'acme_ext',
+                packageUri: `${PLUGINS_SCHEME}:/acme_ext/`
+            });
+            expect(theme.callToCSSUrl('icons/file.svg')).to.equal("url('http://localhost/hostedPlugin/acme_ext/themes/icons/file.svg')");
+        });
+
+        it('resolves `..` segments in a browser-only icon path back within the plugin root', () => {
+            const theme = new TestablePluginIconTheme();
+            theme.setState({
+                uri: `${PLUGINS_SCHEME}:/acme_ext/themes/my-icon-theme.json`,
+                pluginId: 'acme_ext',
+                packageUri: `${PLUGINS_SCHEME}:/acme_ext/`
+            });
+            expect(theme.callToCSSUrl('../shared/icons/other.svg')).to.equal("url('http://localhost/hostedPlugin/acme_ext/shared/icons/other.svg')");
+        });
+
+        it('still resolves icon paths for a backend (file-scheme) icon theme', () => {
+            const theme = new TestablePluginIconTheme();
+            theme.setState({
+                uri: 'file:///plugins/acme.ext-1.0.0/extension/themes/my-icon-theme.json',
+                pluginId: 'acme_ext',
+                packageUri: 'file:///plugins/acme.ext-1.0.0/extension/'
+            });
+            expect(theme.callToCSSUrl('icons/file.svg')).to.equal("url('http://localhost/hostedPlugin/acme_ext/themes/icons/file.svg')");
+        });
+
+        it('returns undefined for an empty icon path', () => {
+            const theme = new TestablePluginIconTheme();
+            theme.setState({
+                uri: `${PLUGINS_SCHEME}:/acme_ext/themes/my-icon-theme.json`,
+                pluginId: 'acme_ext',
+                packageUri: `${PLUGINS_SCHEME}:/acme_ext/`
+            });
+            expect(theme.callToCSSUrl(undefined)).to.be.undefined;
+        });
+
+    });
+
+});