@theia/core 1.74.0-next.9 → 1.74.1

package/src/browser/perspective-service.spec.ts

@@ -0,0 +1,2270 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// 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 './test/jsdom';
+const disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { PerspectiveServiceImpl, PerspectiveDescriptor, WidgetAreaResolverImpl } from './perspective-service';
+import { ApplicationShell } from './shell/application-shell';
+import { AbstractViewContribution, ViewContributionOptions } from './shell/view-contribution';
+import { FrontendApplicationContribution } from './frontend-application-contribution';
+import { DockLayout, Panel, Widget } from '@lumino/widgets';
+import { SidePanel } from './shell/side-panel-handler';
+disableJSDOM();
+
+describe('PerspectiveService', () => {
+    let service: PerspectiveServiceImpl;
+    let addWidgetStub: sinon.SinonStub;
+    let activateWidgetStub: sinon.SinonStub;
+    let getTabBarForStub: sinon.SinonStub;
+    let getAreaForStub: sinon.SinonStub;
+    let getOrCreateWidgetStub: sinon.SinonStub;
+    let getLayoutDataStub: sinon.SinonStub;
+    let setLayoutDataStub: sinon.SinonStub;
+    let collapsePanelStub: sinon.SinonStub;
+    let widgetAreaResolver: WidgetAreaResolverImpl;
+    let tryGetWidgetStub: sinon.SinonStub;
+    let getWidgetsStub: sinon.SinonStub;
+    let mockLogger: { debug: sinon.SinonStub; warn: sinon.SinonStub };
+    let testWidget: Widget;
+    let toTearDown: () => void;
+
+    beforeEach(() => {
+        toTearDown = enableJSDOM();
+        service = new PerspectiveServiceImpl();
+        testWidget = new Widget();
+        testWidget.id = 'test-widget';
+
+        addWidgetStub = sinon.stub().resolves();
+        activateWidgetStub = sinon.stub().resolves(undefined);
+        getTabBarForStub = sinon.stub().returns(undefined);
+        getAreaForStub = sinon.stub().returns(undefined);
+        getOrCreateWidgetStub = sinon.stub().resolves(testWidget);
+        getLayoutDataStub = sinon.stub().returns({ mainPanel: {}, bottomPanel: {} });
+        setLayoutDataStub = sinon.stub().resolves();
+        collapsePanelStub = sinon.stub().resolves();
+        widgetAreaResolver = new WidgetAreaResolverImpl();
+        getWidgetsStub = sinon.stub().returns([]);
+        mockLogger = { debug: sinon.stub(), warn: sinon.stub() };
+
+        const mockShell = {
+            addWidget: addWidgetStub,
+            activateWidget: activateWidgetStub,
+            getTabBarFor: getTabBarForStub,
+            getAreaFor: getAreaForStub,
+            getLayoutData: getLayoutDataStub,
+            setLayoutData: setLayoutDataStub,
+            collapsePanel: collapsePanelStub,
+            getWidgets: getWidgetsStub
+        };
+
+        tryGetWidgetStub = sinon.stub().returns(undefined);
+
+        const mockWidgetManager = {
+            getOrCreateWidget: getOrCreateWidgetStub,
+            tryGetWidget: tryGetWidgetStub
+        };
+
+        // Assign mocks via property access since we can't use DI in tests
+        (service as unknown as Record<string, unknown>)['shell'] = mockShell;
+        (service as unknown as Record<string, unknown>)['widgetManager'] = mockWidgetManager;
+        (service as unknown as Record<string, unknown>)['logger'] = mockLogger;
+        (service as unknown as Record<string, unknown>)['widgetAreaResolver'] = widgetAreaResolver;
+        (service as unknown as Record<string, unknown>)['appContributions'] = {
+            getContributions: () => [] as FrontendApplicationContribution[]
+        };
+    });
+
+    afterEach(() => {
+        sinon.restore();
+        toTearDown();
+    });
+
+    it('should register a perspective', () => {
+        const descriptor: PerspectiveDescriptor = {
+            id: 'test',
+            label: 'Test',
+            viewPlacements: new Map([['widget-a', 'main' as ApplicationShell.Area]])
+        };
+
+        service.registerPerspective(descriptor);
+
+        const perspectives = service.getRegisteredPerspectives();
+        expect(perspectives).to.have.lengthOf(1);
+        expect(perspectives[0].id).to.equal('test');
+        expect(perspectives[0].label).to.equal('Test');
+    });
+
+    it('should register multiple perspectives', () => {
+        service.registerPerspective({
+            id: 'perspective-1',
+            label: 'Perspective 1',
+            viewPlacements: new Map()
+        });
+        service.registerPerspective({
+            id: 'perspective-2',
+            label: 'Perspective 2',
+            viewPlacements: new Map()
+        });
+
+        expect(service.getRegisteredPerspectives()).to.have.lengthOf(2);
+    });
+
+    it('should return undefined for active perspective when none is set', () => {
+        expect(service.getActivePerspective()).to.be.undefined;
+    });
+
+    it('should return undefined from getAreaForView when no perspective is active', () => {
+        service.registerPerspective({
+            id: 'test',
+            label: 'Test',
+            viewPlacements: new Map([['widget-a', 'main' as ApplicationShell.Area]])
+        });
+
+        expect(service.getAreaForView('widget-a')).to.be.undefined;
+    });
+
+    it('should return the override area when a perspective is active', async () => {
+        service.registerPerspective({
+            id: 'test',
+            label: 'Test',
+            viewPlacements: new Map([['widget-a', 'main' as ApplicationShell.Area]])
+        });
+
+        await service.switchPerspective('test');
+
+        expect(service.getAreaForView('widget-a')).to.equal('main');
+    });
+
+    it('should return undefined for views not in the perspective placement map', async () => {
+        service.registerPerspective({
+            id: 'test',
+            label: 'Test',
+            viewPlacements: new Map([['widget-a', 'main' as ApplicationShell.Area]])
+        });
+
+        await service.switchPerspective('test');
+
+        expect(service.getAreaForView('widget-b')).to.be.undefined;
+    });
+
+    it('should switch perspectives and update the active perspective', async () => {
+        service.registerPerspective({
+            id: 'first',
+            label: 'First',
+            viewPlacements: new Map()
+        });
+        service.registerPerspective({
+            id: 'second',
+            label: 'Second',
+            viewPlacements: new Map()
+        });
+
+        await service.switchPerspective('first');
+        expect(service.getActivePerspective()?.id).to.equal('first');
+
+        await service.switchPerspective('second');
+        expect(service.getActivePerspective()?.id).to.equal('second');
+    });
+
+    it('should fire onDidChangePerspective event when switching', async () => {
+        service.registerPerspective({
+            id: 'test',
+            label: 'Test',
+            viewPlacements: new Map()
+        });
+
+        const spy = sinon.spy();
+        service.onDidChangePerspective(spy);
+
+        await service.switchPerspective('test');
+
+        expect(spy.calledOnce).to.be.true;
+        expect(spy.calledWith('test')).to.be.true;
+    });
+
+    it('should not switch to a non-existent perspective', async () => {
+        const spy = sinon.spy();
+        service.onDidChangePerspective(spy);
+
+        await service.switchPerspective('nonexistent');
+
+        expect(spy.called).to.be.false;
+        expect(service.getActivePerspective()).to.be.undefined;
+    });
+
+    it('should call onDeactivate on old perspective and onActivate on new perspective', async () => {
+        const onDeactivate = sinon.spy();
+        const onActivate = sinon.spy();
+
+        service.registerPerspective({
+            id: 'old',
+            label: 'Old',
+            viewPlacements: new Map(),
+            onDeactivate
+        });
+        service.registerPerspective({
+            id: 'new',
+            label: 'New',
+            viewPlacements: new Map(),
+            onActivate
+        });
+
+        await service.switchPerspective('old');
+        await service.switchPerspective('new');
+
+        expect(onDeactivate.calledOnce).to.be.true;
+        expect(onActivate.calledOnce).to.be.true;
+        expect(onDeactivate.calledBefore(onActivate)).to.be.true;
+    });
+
+    it('should add widgets to the target area during switch', async () => {
+        service.registerPerspective({
+            id: 'test',
+            label: 'Test',
+            viewPlacements: new Map([['test-widget', 'main' as ApplicationShell.Area]])
+        });
+
+        await service.switchPerspective('test');
+
+        expect(getOrCreateWidgetStub.calledWith('test-widget')).to.be.true;
+        expect(addWidgetStub.calledOnce).to.be.true;
+        expect(addWidgetStub.calledWith(testWidget, sinon.match({ area: 'main' }))).to.be.true;
+    });
+
+    it('should skip adding widget if already in the correct area', async () => {
+        getTabBarForStub.returns({});
+        getAreaForStub.returns('main');
+
+        service.registerPerspective({
+            id: 'test',
+            label: 'Test',
+            viewPlacements: new Map([['test-widget', 'main' as ApplicationShell.Area]])
+        });
+
+        await service.switchPerspective('test');
+
+        expect(addWidgetStub.called).to.be.false;
+    });
+
+    it('should call initialize and register contributions', () => {
+        const mockContribution = {
+            registerPerspectives: sinon.spy()
+        };
+
+        (service as unknown as Record<string, unknown>)['contributions'] = {
+            getContributions: () => [mockContribution]
+        };
+
+        service.initialize();
+
+        expect(mockContribution.registerPerspectives.calledOnce).to.be.true;
+        expect(mockContribution.registerPerspectives.calledWith(service)).to.be.true;
+    });
+
+    it('should handle initialize with no contributions', () => {
+        (service as unknown as Record<string, unknown>)['contributions'] = undefined;
+
+        expect(() => service.initialize()).to.not.throw();
+    });
+
+    // --- New tests for no-op guard, layout save/restore, and default perspective ---
+
+    it('should register the default perspective on initialize', () => {
+        service.initialize();
+
+        const perspectives = service.getRegisteredPerspectives();
+        const defaultPerspective = perspectives.find(p => p.id === PerspectiveServiceImpl.DEFAULT_PERSPECTIVE_ID);
+        expect(defaultPerspective).to.not.be.undefined;
+        expect(defaultPerspective!.label).to.equal('Default');
+        expect(defaultPerspective!.viewPlacements.size).to.equal(0);
+    });
+
+    it('should set the default perspective as the initial active perspective', () => {
+        service.initialize();
+
+        const active = service.getActivePerspective();
+        expect(active).to.not.be.undefined;
+        expect(active!.id).to.equal(PerspectiveServiceImpl.DEFAULT_PERSPECTIVE_ID);
+    });
+
+    it('should not re-apply when switching to the already-active perspective', async () => {
+        service.registerPerspective({
+            id: 'test',
+            label: 'Test',
+            viewPlacements: new Map([['test-widget', 'main' as ApplicationShell.Area]]),
+            onActivate: sinon.spy(),
+            onDeactivate: sinon.spy()
+        });
+
+        await service.switchPerspective('test');
+
+        // Reset all stubs
+        addWidgetStub.resetHistory();
+        setLayoutDataStub.resetHistory();
+        getOrCreateWidgetStub.resetHistory();
+        getLayoutDataStub.resetHistory();
+        const eventSpy = sinon.spy();
+        service.onDidChangePerspective(eventSpy);
+
+        const descriptor = service.getActivePerspective()!;
+        const onActivateSpy = descriptor.onActivate as sinon.SinonSpy;
+        const onDeactivateSpy = descriptor.onDeactivate as sinon.SinonSpy;
+        onActivateSpy.resetHistory();
+        onDeactivateSpy.resetHistory();
+
+        // Switch to the same perspective again
+        await service.switchPerspective('test');
+
+        expect(addWidgetStub.called).to.be.false;
+        expect(setLayoutDataStub.called).to.be.false;
+        expect(getOrCreateWidgetStub.called).to.be.false;
+        expect(getLayoutDataStub.called).to.be.false;
+        expect(eventSpy.called).to.be.false;
+        expect(onActivateSpy.called).to.be.false;
+        expect(onDeactivateSpy.called).to.be.false;
+    });
+
+    it('should save layout when switching away from a perspective', async () => {
+        service.registerPerspective({
+            id: 'perspA',
+            label: 'A',
+            viewPlacements: new Map()
+        });
+        service.registerPerspective({
+            id: 'perspB',
+            label: 'B',
+            viewPlacements: new Map()
+        });
+
+        await service.switchPerspective('perspA');
+
+        const layoutA = { mainPanel: { widgets: ['editor1'] }, bottomPanel: {} };
+        getLayoutDataStub.returns(layoutA);
+
+        // Switch to B — should save A's layout
+        await service.switchPerspective('perspB');
+
+        expect(getLayoutDataStub.called).to.be.true;
+
+        const layoutB = { mainPanel: { widgets: ['something-else'] }, bottomPanel: {} };
+        getLayoutDataStub.returns(layoutB);
+        setLayoutDataStub.resetHistory();
+
+        // Switch back to A — should restore A's saved layout
+        await service.switchPerspective('perspA');
+
+        expect(setLayoutDataStub.calledOnce).to.be.true;
+        expect(setLayoutDataStub.calledWith(layoutA)).to.be.true;
+    });
+
+    it('should restore saved layout when switching back to a perspective', async () => {
+        service.registerPerspective({
+            id: 'perspA',
+            label: 'A',
+            viewPlacements: new Map([['test-widget', 'left' as ApplicationShell.Area]])
+        });
+        service.registerPerspective({
+            id: 'perspB',
+            label: 'B',
+            viewPlacements: new Map()
+        });
+
+        // Activate A (first time — applies viewPlacements)
+        await service.switchPerspective('perspA');
+
+        const layoutA = { mainPanel: { widgets: ['editor-customized'] }, bottomPanel: {} };
+        getLayoutDataStub.returns(layoutA);
+
+        // Switch to B (saves A's layout)
+        await service.switchPerspective('perspB');
+
+        const layoutB = { mainPanel: { widgets: ['something-else'] }, bottomPanel: {} };
+        getLayoutDataStub.returns(layoutB);
+
+        setLayoutDataStub.resetHistory();
+        getOrCreateWidgetStub.resetHistory();
+        addWidgetStub.resetHistory();
+
+        // Switch back to A — should restore saved layout, NOT apply viewPlacements
+        await service.switchPerspective('perspA');
+
+        expect(setLayoutDataStub.calledOnce).to.be.true;
+        expect(setLayoutDataStub.calledWith(layoutA)).to.be.true;
+        expect(getOrCreateWidgetStub.called).to.be.false;
+        expect(addWidgetStub.called).to.be.false;
+    });
+
+    it('should apply viewPlacements on first activation (no saved layout)', async () => {
+        service.registerPerspective({
+            id: 'fresh',
+            label: 'Fresh',
+            viewPlacements: new Map([['test-widget', 'main' as ApplicationShell.Area]])
+        });
+
+        await service.switchPerspective('fresh');
+
+        expect(getOrCreateWidgetStub.calledWith('test-widget')).to.be.true;
+        expect(addWidgetStub.calledOnce).to.be.true;
+        expect(addWidgetStub.calledWith(testWidget, sinon.match({ area: 'main' }))).to.be.true;
+        expect(setLayoutDataStub.called).to.be.false;
+    });
+
+    it('should not apply viewPlacements when a saved layout exists', async () => {
+        service.registerPerspective({
+            id: 'perspA',
+            label: 'A',
+            viewPlacements: new Map([['test-widget', 'left' as ApplicationShell.Area]])
+        });
+        service.registerPerspective({
+            id: 'perspB',
+            label: 'B',
+            viewPlacements: new Map()
+        });
+
+        // First activation of A — viewPlacements applied
+        await service.switchPerspective('perspA');
+        expect(getOrCreateWidgetStub.called).to.be.true;
+
+        // Switch to B (saves A's layout)
+        await service.switchPerspective('perspB');
+
+        getOrCreateWidgetStub.resetHistory();
+        addWidgetStub.resetHistory();
+
+        // Switch back to A — should restore layout, NOT use viewPlacements
+        await service.switchPerspective('perspA');
+
+        expect(getOrCreateWidgetStub.called).to.be.false;
+        expect(addWidgetStub.called).to.be.false;
+        expect(setLayoutDataStub.called).to.be.true;
+    });
+
+    it('should allow full round-trip: default → custom → default', async () => {
+        service.initialize();
+
+        service.registerPerspective({
+            id: 'ai-first',
+            label: 'AI First',
+            viewPlacements: new Map([['test-widget', 'left' as ApplicationShell.Area]])
+        });
+
+        // Start in default (set by initialize)
+        expect(service.getActivePerspective()?.id).to.equal(PerspectiveServiceImpl.DEFAULT_PERSPECTIVE_ID);
+
+        const defaultLayout = { mainPanel: { widgets: ['default-editor'] }, bottomPanel: {} };
+        getLayoutDataStub.returns(defaultLayout);
+
+        // Switch to ai-first (saves default layout)
+        await service.switchPerspective('ai-first');
+        expect(service.getActivePerspective()?.id).to.equal('ai-first');
+        expect(getLayoutDataStub.called).to.be.true;
+        expect(getOrCreateWidgetStub.calledWith('test-widget')).to.be.true;
+
+        const aiLayout = { mainPanel: { widgets: ['ai-stuff'] }, bottomPanel: {} };
+        getLayoutDataStub.returns(aiLayout);
+
+        setLayoutDataStub.resetHistory();
+
+        // Switch back to default (saves ai-first layout, restores default layout)
+        await service.switchPerspective(PerspectiveServiceImpl.DEFAULT_PERSPECTIVE_ID);
+        expect(service.getActivePerspective()?.id).to.equal(PerspectiveServiceImpl.DEFAULT_PERSPECTIVE_ID);
+        expect(setLayoutDataStub.calledOnce).to.be.true;
+        expect(setLayoutDataStub.calledWith(defaultLayout)).to.be.true;
+
+        setLayoutDataStub.resetHistory();
+
+        // Switch back to ai-first (saves default layout again, restores ai-first layout)
+        await service.switchPerspective('ai-first');
+        expect(service.getActivePerspective()?.id).to.equal('ai-first');
+        expect(setLayoutDataStub.calledOnce).to.be.true;
+        expect(setLayoutDataStub.calledWith(aiLayout)).to.be.true;
+    });
+
+    // --- Chrome control options tests ---
+
+    it('should collapse areas on first activation only', async () => {
+        service.registerPerspective({
+            id: 'collapse-test',
+            label: 'Collapse Test',
+            viewPlacements: new Map(),
+            chromeOptions: { collapseAreas: ['left'] }
+        });
+        service.registerPerspective({
+            id: 'other',
+            label: 'Other',
+            viewPlacements: new Map()
+        });
+
+        // First activation — should collapse
+        await service.switchPerspective('collapse-test');
+        expect(collapsePanelStub.calledOnce).to.be.true;
+        expect(collapsePanelStub.calledWith('left')).to.be.true;
+
+        collapsePanelStub.resetHistory();
+
+        // Switch away (saves layout)
+        await service.switchPerspective('other');
+
+        collapsePanelStub.resetHistory();
+
+        // Switch back — should restore saved layout, NOT collapse again
+        await service.switchPerspective('collapse-test');
+        expect(collapsePanelStub.called).to.be.false;
+    });
+
+    it('should collapse multiple areas on first activation', async () => {
+        service.registerPerspective({
+            id: 'multi-collapse',
+            label: 'Multi Collapse',
+            viewPlacements: new Map(),
+            chromeOptions: { collapseAreas: ['left', 'bottom'] }
+        });
+
+        await service.switchPerspective('multi-collapse');
+
+        expect(collapsePanelStub.calledTwice).to.be.true;
+        expect(collapsePanelStub.calledWith('left')).to.be.true;
+        expect(collapsePanelStub.calledWith('bottom')).to.be.true;
+    });
+
+    it('should not collapse areas when perspective has no collapseAreas', async () => {
+        service.registerPerspective({
+            id: 'no-collapse',
+            label: 'No Collapse',
+            viewPlacements: new Map()
+        });
+
+        await service.switchPerspective('no-collapse');
+
+        expect(collapsePanelStub.called).to.be.false;
+    });
+
+    // --- WidgetAreaResolver tests ---
+
+    it('should resolve widget area from active perspective via the WidgetAreaResolver', async () => {
+        service.initialize();
+
+        service.registerPerspective({
+            id: 'resolver-test',
+            label: 'Resolver Test',
+            viewPlacements: new Map([['my-widget', 'right' as ApplicationShell.Area]])
+        });
+
+        await service.switchPerspective('resolver-test');
+
+        expect(widgetAreaResolver.resolveArea('my-widget', 'left')).to.equal('right');
+    });
+
+    it('should return undefined from the resolver for unmapped widgets', async () => {
+        service.initialize();
+
+        service.registerPerspective({
+            id: 'resolver-test',
+            label: 'Resolver Test',
+            viewPlacements: new Map([['my-widget', 'right' as ApplicationShell.Area]])
+        });
+
+        await service.switchPerspective('resolver-test');
+
+        expect(widgetAreaResolver.resolveArea('unknown-widget', 'main')).to.be.undefined;
+    });
+
+    it('should return undefined from the resolver when default perspective is active', () => {
+        service.initialize();
+
+        // Default perspective has empty viewPlacements
+        expect(widgetAreaResolver.resolveArea('any-widget', 'main')).to.be.undefined;
+    });
+
+    // --- Logger tests ---
+
+    it('should log warning when widget creation fails during switchPerspective', async () => {
+        const widgetError = new Error('No factory registered');
+        getOrCreateWidgetStub.rejects(widgetError);
+
+        service.registerPerspective({
+            id: 'fail-test',
+            label: 'Fail Test',
+            viewPlacements: new Map([['missing-widget', 'main' as ApplicationShell.Area]])
+        });
+
+        await service.switchPerspective('fail-test');
+
+        expect(mockLogger.warn.calledOnce).to.be.true;
+        expect(mockLogger.warn.firstCall.args[0]).to.equal('Failed to create or place widget for perspective');
+        expect(mockLogger.warn.firstCall.args[1]).to.equal(widgetError);
+    });
+
+    it('should log warning when widget activation fails during switchPerspective', async () => {
+        const activationError = new Error('Activation failed');
+        activateWidgetStub.rejects(activationError);
+
+        service.registerPerspective({
+            id: 'activate-fail',
+            label: 'Activate Fail',
+            viewPlacements: new Map([['test-widget', 'main' as ApplicationShell.Area]])
+        });
+
+        await service.switchPerspective('activate-fail');
+
+        expect(mockLogger.warn.called).to.be.true;
+        const activateCall = mockLogger.warn.getCalls().find(
+            (c: sinon.SinonSpyCall) => c.args[0] === 'Failed to activate widget for perspective'
+        );
+        expect(activateCall).to.not.be.undefined;
+        expect(activateCall!.args[1]).to.equal(activationError);
+    });
+
+    // --- Reentrancy guard tests ---
+
+    it('should handle two rapid switchPerspective calls without interleaving', async () => {
+        service.registerPerspective({
+            id: 'first',
+            label: 'First',
+            viewPlacements: new Map()
+        });
+        service.registerPerspective({
+            id: 'second',
+            label: 'Second',
+            viewPlacements: new Map()
+        });
+
+        const promise1 = service.switchPerspective('first');
+        const promise2 = service.switchPerspective('second');
+
+        await Promise.all([promise1, promise2]);
+
+        expect(service.getActivePerspective()?.id).to.equal('second');
+    });
+
+    it('should serialize perspective switches with reentrancy guard', async () => {
+        const callOrder: string[] = [];
+
+        service.registerPerspective({
+            id: 'perspA',
+            label: 'A',
+            viewPlacements: new Map(),
+            onActivate: () => callOrder.push('activate-A')
+        });
+        service.registerPerspective({
+            id: 'perspB',
+            label: 'B',
+            viewPlacements: new Map(),
+            onActivate: () => callOrder.push('activate-B')
+        });
+
+        const p1 = service.switchPerspective('perspA');
+        const p2 = service.switchPerspective('perspB');
+
+        await Promise.all([p1, p2]);
+
+        expect(callOrder).to.deep.equal(['activate-A', 'activate-B']);
+        expect(service.getActivePerspective()?.id).to.equal('perspB');
+    });
+
+    it('should serialize three or more concurrent perspective switches', async () => {
+        const callOrder: string[] = [];
+
+        service.registerPerspective({
+            id: 'perspA',
+            label: 'A',
+            viewPlacements: new Map(),
+            onActivate: () => callOrder.push('activate-A')
+        });
+        service.registerPerspective({
+            id: 'perspB',
+            label: 'B',
+            viewPlacements: new Map(),
+            onActivate: () => callOrder.push('activate-B')
+        });
+        service.registerPerspective({
+            id: 'perspC',
+            label: 'C',
+            viewPlacements: new Map(),
+            onActivate: () => callOrder.push('activate-C')
+        });
+
+        const p1 = service.switchPerspective('perspA');
+        const p2 = service.switchPerspective('perspB');
+        const p3 = service.switchPerspective('perspC');
+
+        await Promise.all([p1, p2, p3]);
+
+        expect(callOrder).to.deep.equal(['activate-A', 'activate-B', 'activate-C']);
+        expect(service.getActivePerspective()?.id).to.equal('perspC');
+    });
+
+    // --- onLayoutRestored() tests ---
+
+    it('should not throw when onLayoutRestored is called with an unregistered perspective', () => {
+        service.initialize();
+
+        expect(() => service.onLayoutRestored('non-existent')).to.not.throw();
+    });
+
+    // --- Rejection resilience tests ---
+
+    it('should warn and continue when setLayoutData rejects during saved layout restore', async () => {
+        service.registerPerspective({
+            id: 'perspA',
+            label: 'A',
+            viewPlacements: new Map()
+        });
+        service.registerPerspective({
+            id: 'perspB',
+            label: 'B',
+            viewPlacements: new Map()
+        });
+
+        // Switch to A, then to B (saves A's layout)
+        await service.switchPerspective('perspA');
+        await service.switchPerspective('perspB');
+
+        // Make setLayoutData reject
+        setLayoutDataStub.rejects(new Error('layout error'));
+
+        const eventSpy = sinon.spy();
+        service.onDidChangePerspective(eventSpy);
+
+        // Switch back to A — should not throw
+        await service.switchPerspective('perspA');
+
+        expect(service.getActivePerspective()?.id).to.equal('perspA');
+        expect(eventSpy.calledOnce).to.be.true;
+        expect(eventSpy.calledWith('perspA')).to.be.true;
+        expect(mockLogger.warn.calledOnce).to.be.true;
+        expect(mockLogger.warn.firstCall.args[0]).to.equal('Failed to apply layout for perspective');
+    });
+
+    it('should warn and continue when collapsePanel rejects on first activation', async () => {
+        service.registerPerspective({
+            id: 'collapse-fail',
+            label: 'Collapse Fail',
+            viewPlacements: new Map(),
+            chromeOptions: { collapseAreas: ['left'] }
+        });
+
+        collapsePanelStub.rejects(new Error('collapse error'));
+
+        const eventSpy = sinon.spy();
+        service.onDidChangePerspective(eventSpy);
+
+        // Switch — should not throw
+        await service.switchPerspective('collapse-fail');
+
+        expect(service.getActivePerspective()?.id).to.equal('collapse-fail');
+        expect(eventSpy.calledOnce).to.be.true;
+        expect(mockLogger.warn.calledOnce).to.be.true;
+        expect(mockLogger.warn.firstCall.args[0]).to.equal('Failed to apply layout for perspective');
+    });
+
+    it('should not drop queued switches when layout application fails', async () => {
+        service.registerPerspective({
+            id: 'perspA',
+            label: 'A',
+            viewPlacements: new Map()
+        });
+        service.registerPerspective({
+            id: 'perspB',
+            label: 'B',
+            viewPlacements: new Map()
+        });
+        service.registerPerspective({
+            id: 'perspC',
+            label: 'C',
+            viewPlacements: new Map()
+        });
+
+        // Switch to A, then to B (saves A's layout)
+        await service.switchPerspective('perspA');
+        await service.switchPerspective('perspB');
+
+        // Make setLayoutData reject only on first call, then resolve
+        setLayoutDataStub.resetBehavior();
+        setLayoutDataStub.onFirstCall().rejects(new Error('layout error'));
+        setLayoutDataStub.onSecondCall().resolves();
+
+        // Queue: switch to A (will fail layout restore), then switch to C
+        const p1 = service.switchPerspective('perspA');
+        const p2 = service.switchPerspective('perspC');
+
+        await Promise.all([p1, p2]);
+
+        expect(service.getActivePerspective()?.id).to.equal('perspC');
+    });
+
+    // --- resetCurrentPerspective tests ---
+
+    describe('resetCurrentPerspective', () => {
+        it('should clear saved layout and re-apply viewPlacements on reset for non-default perspective', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map([['test-widget', 'left' as ApplicationShell.Area]])
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            await service.switchPerspective('perspA');
+
+            const layoutA = { mainPanel: { widgets: ['customized'] }, bottomPanel: {} };
+            getLayoutDataStub.returns(layoutA);
+
+            // Switch to B (saves A's layout)
+            await service.switchPerspective('perspB');
+
+            // Switch back to A (restores saved layout)
+            await service.switchPerspective('perspA');
+
+            // Verify saved layout exists
+            expect(service.getSavedLayout('perspA')).to.not.be.undefined;
+
+            // Reset stubs to track reset behavior
+            setLayoutDataStub.resetHistory();
+            getOrCreateWidgetStub.resetHistory();
+            addWidgetStub.resetHistory();
+            activateWidgetStub.resetHistory();
+
+            await service.resetCurrentPerspective();
+
+            // Saved layout should be cleared
+            expect(service.getSavedLayout('perspA')).to.be.undefined;
+
+            // Should re-apply viewPlacements
+            expect(getOrCreateWidgetStub.calledWith('test-widget')).to.be.true;
+            expect(addWidgetStub.called).to.be.true;
+        });
+
+        it('should call onActivate callback', async () => {
+            const onActivate = sinon.spy();
+            service.registerPerspective({
+                id: 'activate-reset',
+                label: 'Activate Reset',
+                viewPlacements: new Map(),
+                onActivate
+            });
+
+            await service.switchPerspective('activate-reset');
+            onActivate.resetHistory();
+
+            await service.resetCurrentPerspective();
+
+            expect(onActivate.calledOnce).to.be.true;
+        });
+
+        it('should fire onDidChangePerspective event', async () => {
+            service.registerPerspective({
+                id: 'event-reset',
+                label: 'Event Reset',
+                viewPlacements: new Map()
+            });
+
+            await service.switchPerspective('event-reset');
+
+            const spy = sinon.spy();
+            service.onDidChangePerspective(spy);
+
+            await service.resetCurrentPerspective();
+
+            expect(spy.calledOnce).to.be.true;
+            expect(spy.calledWith('event-reset')).to.be.true;
+        });
+
+        it('should not affect other perspectives\' saved layouts', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            // Activate A, then B, to create saved layouts for both
+            await service.switchPerspective('perspA');
+
+            const layoutA = { mainPanel: { widgets: ['a-stuff'] }, bottomPanel: {} };
+            getLayoutDataStub.returns(layoutA);
+
+            await service.switchPerspective('perspB');
+
+            const layoutB = { mainPanel: { widgets: ['b-stuff'] }, bottomPanel: {} };
+            getLayoutDataStub.returns(layoutB);
+
+            // Switch back to A (saves B's layout)
+            await service.switchPerspective('perspA');
+
+            // Reset A
+            await service.resetCurrentPerspective();
+
+            // A's saved layout should be cleared
+            expect(service.getSavedLayout('perspA')).to.be.undefined;
+            // B's saved layout should be preserved
+            expect(service.getSavedLayout('perspB')).to.equal(layoutB);
+        });
+
+        it('should serialize with other switchPerspective calls', async () => {
+            const callOrder: string[] = [];
+
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map(),
+                onActivate: () => callOrder.push('activate-A')
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map(),
+                onActivate: () => callOrder.push('activate-B')
+            });
+
+            await service.switchPerspective('perspA');
+            callOrder.length = 0;
+
+            // Queue a reset and a switch concurrently
+            const p1 = service.resetCurrentPerspective();
+            const p2 = service.switchPerspective('perspB');
+
+            await Promise.all([p1, p2]);
+
+            expect(callOrder).to.deep.equal(['activate-A', 'activate-B']);
+            expect(service.getActivePerspective()?.id).to.equal('perspB');
+        });
+
+        it('should do nothing when no active perspective is set', async () => {
+            // No perspective active (activePerspectiveId is undefined)
+            const spy = sinon.spy();
+            service.onDidChangePerspective(spy);
+
+            await service.resetCurrentPerspective();
+
+            expect(spy.called).to.be.false;
+            expect(getOrCreateWidgetStub.called).to.be.false;
+        });
+    });
+
+    describe('resetDefaultPerspective', () => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function createMockViewContribution(
+            options: ViewContributionOptions
+        ): AbstractViewContribution<Widget> & FrontendApplicationContribution {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const contribution = Object.create(AbstractViewContribution.prototype) as any;
+            contribution.options = options;
+            contribution.widgetManager = {
+                getOrCreateWidget: getOrCreateWidgetStub,
+                tryGetWidget: tryGetWidgetStub
+            };
+            contribution.shell = (service as unknown as Record<string, unknown>)['shell'];
+            contribution.openView = sinon.stub().resolves(testWidget);
+            return contribution;
+        }
+
+        function createMockNonViewContribution(): FrontendApplicationContribution {
+            const contrib: FrontendApplicationContribution = {};
+            return contrib;
+        }
+
+        it('should relocate open view from wrong area to defaultViewOptions.area', async () => {
+            service.initialize();
+
+            const explorerWidget = new Widget();
+            explorerWidget.id = 'explorer';
+            const explorerPanel = new Panel();
+            Widget.attach(explorerPanel, document.body);
+            explorerPanel.addWidget(explorerWidget);
+
+            tryGetWidgetStub.withArgs('explorer').returns(explorerWidget);
+            getAreaForStub.withArgs(explorerWidget).returns('right');
+
+            const contribution = createMockViewContribution({
+                widgetId: 'explorer',
+                widgetName: 'Explorer',
+                defaultWidgetOptions: { area: 'left' }
+            });
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [contribution]
+            };
+
+            await service.resetCurrentPerspective();
+
+            expect(addWidgetStub.calledWith(explorerWidget, sinon.match({ area: 'left' }))).to.be.true;
+
+            explorerPanel.dispose();
+        });
+
+        it('should skip views already in correct area', async () => {
+            service.initialize();
+
+            const explorerWidget = new Widget();
+            explorerWidget.id = 'explorer';
+            const explorerPanel = new Panel();
+            Widget.attach(explorerPanel, document.body);
+            explorerPanel.addWidget(explorerWidget);
+
+            tryGetWidgetStub.withArgs('explorer').returns(explorerWidget);
+            getAreaForStub.withArgs(explorerWidget).returns('left');
+
+            const contribution = createMockViewContribution({
+                widgetId: 'explorer',
+                widgetName: 'Explorer',
+                defaultWidgetOptions: { area: 'left' }
+            });
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [contribution]
+            };
+
+            addWidgetStub.resetHistory();
+
+            await service.resetCurrentPerspective();
+
+            expect(addWidgetStub.called).to.be.false;
+
+            explorerPanel.dispose();
+        });
+
+        it('should skip views not attached', async () => {
+            service.initialize();
+
+            const explorerWidget = new Widget();
+            explorerWidget.id = 'explorer';
+            // Not attached to any parent
+
+            tryGetWidgetStub.withArgs('explorer').returns(explorerWidget);
+
+            const contribution = createMockViewContribution({
+                widgetId: 'explorer',
+                widgetName: 'Explorer',
+                defaultWidgetOptions: { area: 'left' }
+            });
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [contribution]
+            };
+
+            addWidgetStub.resetHistory();
+
+            await service.resetCurrentPerspective();
+
+            // Phase 1 should not try to relocate (not attached)
+            // Phase 2 will call initializeLayout
+            expect(addWidgetStub.called).to.be.false;
+        });
+
+        it('should call openView on AbstractViewContribution instances', async () => {
+            service.initialize();
+
+            const contribution = createMockViewContribution({
+                widgetId: 'explorer',
+                widgetName: 'Explorer',
+                defaultWidgetOptions: { area: 'left' }
+            });
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [contribution]
+            };
+
+            await service.resetCurrentPerspective();
+
+            expect((contribution.openView as sinon.SinonStub).calledOnce).to.be.true;
+            expect((contribution.openView as sinon.SinonStub).calledWith({ activate: false })).to.be.true;
+        });
+
+        it('should NOT call openView on non-AbstractViewContribution contributions', async () => {
+            service.initialize();
+
+            const nonViewContrib = createMockNonViewContribution();
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [nonViewContrib]
+            };
+
+            // Should not throw
+            await service.resetCurrentPerspective();
+        });
+
+        it('should handle combined scenario: open view in wrong area + closed view', async () => {
+            service.initialize();
+
+            // Explorer is open but in the wrong area
+            const explorerWidget = new Widget();
+            explorerWidget.id = 'explorer';
+            const panel = new Panel();
+            Widget.attach(panel, document.body);
+            panel.addWidget(explorerWidget);
+
+            tryGetWidgetStub.withArgs('explorer').returns(explorerWidget);
+            getAreaForStub.withArgs(explorerWidget).returns('right');
+
+            const explorerContrib = createMockViewContribution({
+                widgetId: 'explorer',
+                widgetName: 'Explorer',
+                defaultWidgetOptions: { area: 'left' }
+            });
+
+            // SCM is closed (tryGetWidget returns undefined)
+            tryGetWidgetStub.withArgs('scm').returns(undefined);
+
+            const scmContrib = createMockViewContribution({
+                widgetId: 'scm',
+                widgetName: 'SCM',
+                defaultWidgetOptions: { area: 'left' }
+            });
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [explorerContrib, scmContrib]
+            };
+
+            addWidgetStub.resetHistory();
+
+            await service.resetCurrentPerspective();
+
+            // Phase 1: Explorer should be relocated
+            expect(addWidgetStub.calledWith(explorerWidget, sinon.match({ area: 'left' }))).to.be.true;
+            // Phase 2: Both should have openView called
+            expect((explorerContrib.openView as sinon.SinonStub).calledOnce).to.be.true;
+            expect((scmContrib.openView as sinon.SinonStub).calledOnce).to.be.true;
+
+            panel.dispose();
+        });
+
+        it('should use viewContainerId as effectiveWidgetId when set', async () => {
+            service.initialize();
+
+            const containerWidget = new Widget();
+            containerWidget.id = 'explorer-container';
+            const panel = new Panel();
+            Widget.attach(panel, document.body);
+            panel.addWidget(containerWidget);
+
+            tryGetWidgetStub.withArgs('explorer-container').returns(containerWidget);
+            getAreaForStub.withArgs(containerWidget).returns('right');
+
+            const contribution = createMockViewContribution({
+                widgetId: 'explorer',
+                viewContainerId: 'explorer-container',
+                widgetName: 'Explorer',
+                defaultWidgetOptions: { area: 'left' }
+            });
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [contribution]
+            };
+
+            addWidgetStub.resetHistory();
+
+            await service.resetCurrentPerspective();
+
+            expect(tryGetWidgetStub.calledWith('explorer-container')).to.be.true;
+            expect(addWidgetStub.calledWith(containerWidget, sinon.match({ area: 'left' }))).to.be.true;
+
+            panel.dispose();
+        });
+
+        it('should handle openView errors gracefully', async () => {
+            service.initialize();
+
+            const contribution = createMockViewContribution({
+                widgetId: 'broken',
+                widgetName: 'Broken',
+                defaultWidgetOptions: { area: 'left' }
+            });
+            (contribution.openView as sinon.SinonStub).rejects(new Error('openView failed'));
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [contribution]
+            };
+
+            // Should not throw
+            await service.resetCurrentPerspective();
+
+            expect(mockLogger.warn.called).to.be.true;
+        });
+
+        it('should handle widget relocation errors gracefully', async () => {
+            service.initialize();
+
+            const explorerWidget = new Widget();
+            explorerWidget.id = 'explorer';
+            const panel = new Panel();
+            Widget.attach(panel, document.body);
+            panel.addWidget(explorerWidget);
+
+            tryGetWidgetStub.withArgs('explorer').returns(explorerWidget);
+            getAreaForStub.withArgs(explorerWidget).returns('right');
+            addWidgetStub.rejects(new Error('relocation failed'));
+
+            const contribution = createMockViewContribution({
+                widgetId: 'explorer',
+                widgetName: 'Explorer',
+                defaultWidgetOptions: { area: 'left' }
+            });
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [contribution]
+            };
+
+            // Should not throw
+            await service.resetCurrentPerspective();
+
+            expect(mockLogger.warn.called).to.be.true;
+
+            panel.dispose();
+        });
+
+        it('should fire onDidChangePerspective event on default perspective reset', async () => {
+            service.initialize();
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => []
+            };
+
+            const spy = sinon.spy();
+            service.onDidChangePerspective(spy);
+
+            await service.resetCurrentPerspective();
+
+            expect(spy.calledOnce).to.be.true;
+            expect(spy.calledWith(PerspectiveServiceImpl.DEFAULT_PERSPECTIVE_ID)).to.be.true;
+        });
+
+        it('should skip contributions without defaultViewOptions.area in Phase 1', async () => {
+            service.initialize();
+
+            const contribution = createMockViewContribution({
+                widgetId: 'no-area',
+                widgetName: 'No Area',
+                defaultWidgetOptions: {}
+            });
+
+            (service as unknown as Record<string, unknown>)['appContributions'] = {
+                getContributions: () => [contribution]
+            };
+
+            addWidgetStub.resetHistory();
+
+            await service.resetCurrentPerspective();
+
+            // Phase 1 should skip (no target area)
+            // Phase 2 should still call openView
+            expect((contribution.openView as sinon.SinonStub).calledOnce).to.be.true;
+        });
+    });
+
+    describe('layout healing on perspective switch', () => {
+        it('should replace disposed side panel widget when switching back to a perspective', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            // Create a widget and then dispose it to simulate cross-perspective closure
+            const disposedWidget = new Widget();
+            disposedWidget.id = 'explorer-widget';
+            disposedWidget.dispose();
+            expect(disposedWidget.isDisposed).to.be.true;
+
+            const freshWidget = new Widget();
+            freshWidget.id = 'explorer-widget';
+            getOrCreateWidgetStub.withArgs('explorer-widget').resolves(freshWidget);
+
+            const savedLayout: ApplicationShell.LayoutData = {
+                leftPanel: {
+                    type: 'sidepanel',
+                    items: [{ widget: disposedWidget, rank: 0, expanded: true }]
+                } as SidePanel.LayoutData,
+                mainPanel: undefined,
+                bottomPanel: undefined
+            };
+
+            // Switch to A, then to B
+            await service.switchPerspective('perspA');
+            await service.switchPerspective('perspB');
+
+            // Manually set the saved layout for A with the disposed widget
+            service.setSavedLayout('perspA', savedLayout);
+
+            setLayoutDataStub.resetHistory();
+            getOrCreateWidgetStub.resetHistory();
+
+            // Switch back to A
+            await service.switchPerspective('perspA');
+
+            expect(getOrCreateWidgetStub.calledWith('explorer-widget')).to.be.true;
+            expect(setLayoutDataStub.calledOnce).to.be.true;
+            // The layout should now contain the fresh widget
+            const restoredLayout = setLayoutDataStub.firstCall.args[0] as ApplicationShell.LayoutData;
+            expect(restoredLayout.leftPanel!.items![0].widget).to.equal(freshWidget);
+        });
+
+        it('should replace disposed dock panel widget (main area)', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            const disposedWidget = new Widget();
+            disposedWidget.id = 'editor-widget';
+            disposedWidget.dispose();
+
+            const freshWidget = new Widget();
+            freshWidget.id = 'editor-widget';
+            getOrCreateWidgetStub.withArgs('editor-widget').resolves(freshWidget);
+
+            const savedLayout: ApplicationShell.LayoutData = {
+                mainPanel: {
+                    main: {
+                        type: 'tab-area',
+                        widgets: [disposedWidget],
+                        currentIndex: 0
+                    } as DockLayout.ITabAreaConfig
+                },
+                bottomPanel: undefined
+            };
+
+            await service.switchPerspective('perspA');
+            await service.switchPerspective('perspB');
+            service.setSavedLayout('perspA', savedLayout);
+
+            setLayoutDataStub.resetHistory();
+            getOrCreateWidgetStub.resetHistory();
+
+            await service.switchPerspective('perspA');
+
+            expect(getOrCreateWidgetStub.calledWith('editor-widget')).to.be.true;
+            const restoredLayout = setLayoutDataStub.firstCall.args[0] as ApplicationShell.LayoutData;
+            expect((restoredLayout.mainPanel!.main as DockLayout.ITabAreaConfig).widgets[0]).to.equal(freshWidget);
+        });
+
+        it('should handle recreation failure gracefully', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            const disposedWidget = new Widget();
+            disposedWidget.id = 'broken-widget';
+            disposedWidget.dispose();
+
+            getOrCreateWidgetStub.withArgs('broken-widget').rejects(new Error('No factory'));
+
+            const savedLayout: ApplicationShell.LayoutData = {
+                leftPanel: {
+                    type: 'sidepanel',
+                    items: [{ widget: disposedWidget, rank: 0, expanded: true }]
+                } as SidePanel.LayoutData,
+                mainPanel: undefined,
+                bottomPanel: undefined
+            };
+
+            await service.switchPerspective('perspA');
+            await service.switchPerspective('perspB');
+            service.setSavedLayout('perspA', savedLayout);
+
+            mockLogger.warn.resetHistory();
+            setLayoutDataStub.resetHistory();
+
+            await service.switchPerspective('perspA');
+
+            // Widget should be set to undefined in the layout
+            const restoredLayout = setLayoutDataStub.firstCall.args[0] as ApplicationShell.LayoutData;
+            expect(restoredLayout.leftPanel!.items![0].widget).to.be.undefined;
+            // Warn log should have been called
+            expect(mockLogger.warn.called).to.be.true;
+            const healCall = mockLogger.warn.getCalls().find(
+                (c: sinon.SinonSpyCall) => c.args[0] === 'Failed to recreate disposed widget for perspective layout'
+            );
+            expect(healCall).to.not.be.undefined;
+            // setLayoutData should still be called
+            expect(setLayoutDataStub.calledOnce).to.be.true;
+        });
+
+        it('should handle recreation failure in dock panel by splicing widget', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            const disposedWidget = new Widget();
+            disposedWidget.id = 'broken-widget';
+            disposedWidget.dispose();
+
+            const goodWidget = new Widget();
+            goodWidget.id = 'good-widget';
+
+            getOrCreateWidgetStub.withArgs('broken-widget').rejects(new Error('No factory'));
+
+            const savedLayout: ApplicationShell.LayoutData = {
+                mainPanel: {
+                    main: {
+                        type: 'tab-area',
+                        widgets: [goodWidget, disposedWidget],
+                        currentIndex: 0
+                    } as DockLayout.ITabAreaConfig
+                },
+                bottomPanel: undefined
+            };
+
+            await service.switchPerspective('perspA');
+            await service.switchPerspective('perspB');
+            service.setSavedLayout('perspA', savedLayout);
+
+            setLayoutDataStub.resetHistory();
+
+            await service.switchPerspective('perspA');
+
+            const restoredLayout = setLayoutDataStub.firstCall.args[0] as ApplicationShell.LayoutData;
+            const tabArea = restoredLayout.mainPanel!.main as DockLayout.ITabAreaConfig;
+            // The broken widget should have been spliced out
+            expect(tabArea.widgets).to.have.lengthOf(1);
+            expect(tabArea.widgets[0]).to.equal(goodWidget);
+        });
+
+        it('should not touch non-disposed widgets', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            const liveWidget = new Widget();
+            liveWidget.id = 'live-widget';
+
+            const disposedWidget = new Widget();
+            disposedWidget.id = 'dead-widget';
+            disposedWidget.dispose();
+
+            const freshWidget = new Widget();
+            freshWidget.id = 'dead-widget';
+            getOrCreateWidgetStub.withArgs('dead-widget').resolves(freshWidget);
+
+            const savedLayout: ApplicationShell.LayoutData = {
+                leftPanel: {
+                    type: 'sidepanel',
+                    items: [
+                        { widget: liveWidget, rank: 0, expanded: true },
+                        { widget: disposedWidget, rank: 1, expanded: false }
+                    ]
+                } as SidePanel.LayoutData,
+                mainPanel: undefined,
+                bottomPanel: undefined
+            };
+
+            await service.switchPerspective('perspA');
+            await service.switchPerspective('perspB');
+            service.setSavedLayout('perspA', savedLayout);
+
+            getOrCreateWidgetStub.resetHistory();
+            setLayoutDataStub.resetHistory();
+
+            await service.switchPerspective('perspA');
+
+            // Only the disposed widget should trigger getOrCreateWidget
+            expect(getOrCreateWidgetStub.calledOnce).to.be.true;
+            expect(getOrCreateWidgetStub.calledWith('dead-widget')).to.be.true;
+            // The live widget should remain unchanged
+            const restoredLayout = setLayoutDataStub.firstCall.args[0] as ApplicationShell.LayoutData;
+            expect(restoredLayout.leftPanel!.items![0].widget).to.equal(liveWidget);
+            expect(restoredLayout.leftPanel!.items![1].widget).to.equal(freshWidget);
+        });
+
+        it('should handle nested split-area configs', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            const disposedWidget = new Widget();
+            disposedWidget.id = 'nested-widget';
+            disposedWidget.dispose();
+
+            const freshWidget = new Widget();
+            freshWidget.id = 'nested-widget';
+            getOrCreateWidgetStub.withArgs('nested-widget').resolves(freshWidget);
+
+            const liveWidget = new Widget();
+            liveWidget.id = 'other-widget';
+
+            const savedLayout: ApplicationShell.LayoutData = {
+                mainPanel: {
+                    main: {
+                        type: 'split-area',
+                        orientation: 'horizontal',
+                        sizes: [0.5, 0.5],
+                        children: [
+                            {
+                                type: 'tab-area',
+                                widgets: [liveWidget],
+                                currentIndex: 0
+                            } as DockLayout.ITabAreaConfig,
+                            {
+                                type: 'tab-area',
+                                widgets: [disposedWidget],
+                                currentIndex: 0
+                            } as DockLayout.ITabAreaConfig
+                        ]
+                    } as DockLayout.ISplitAreaConfig
+                },
+                bottomPanel: undefined
+            };
+
+            await service.switchPerspective('perspA');
+            await service.switchPerspective('perspB');
+            service.setSavedLayout('perspA', savedLayout);
+
+            getOrCreateWidgetStub.resetHistory();
+            setLayoutDataStub.resetHistory();
+
+            await service.switchPerspective('perspA');
+
+            expect(getOrCreateWidgetStub.calledWith('nested-widget')).to.be.true;
+            const restoredLayout = setLayoutDataStub.firstCall.args[0] as ApplicationShell.LayoutData;
+            const splitArea = restoredLayout.mainPanel!.main as DockLayout.ISplitAreaConfig;
+            expect((splitArea.children[0] as DockLayout.ITabAreaConfig).widgets[0]).to.equal(liveWidget);
+            expect((splitArea.children[1] as DockLayout.ITabAreaConfig).widgets[0]).to.equal(freshWidget);
+        });
+
+        it('should handle empty/missing panel sections', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            const savedLayout: ApplicationShell.LayoutData = {
+                mainPanel: undefined,
+                bottomPanel: undefined,
+                leftPanel: undefined,
+                rightPanel: undefined
+            };
+
+            await service.switchPerspective('perspA');
+            await service.switchPerspective('perspB');
+            service.setSavedLayout('perspA', savedLayout);
+
+            setLayoutDataStub.resetHistory();
+
+            // Should not throw
+            await service.switchPerspective('perspA');
+
+            expect(setLayoutDataStub.calledOnce).to.be.true;
+        });
+
+        it('should heal bottom panel disposed widgets', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            const disposedWidget = new Widget();
+            disposedWidget.id = 'bottom-widget';
+            disposedWidget.dispose();
+
+            const freshWidget = new Widget();
+            freshWidget.id = 'bottom-widget';
+            getOrCreateWidgetStub.withArgs('bottom-widget').resolves(freshWidget);
+
+            const savedLayout: ApplicationShell.LayoutData = {
+                mainPanel: undefined,
+                bottomPanel: {
+                    config: {
+                        main: {
+                            type: 'tab-area',
+                            widgets: [disposedWidget],
+                            currentIndex: 0
+                        } as DockLayout.ITabAreaConfig
+                    }
+                }
+            };
+
+            await service.switchPerspective('perspA');
+            await service.switchPerspective('perspB');
+            service.setSavedLayout('perspA', savedLayout);
+
+            getOrCreateWidgetStub.resetHistory();
+            setLayoutDataStub.resetHistory();
+
+            await service.switchPerspective('perspA');
+
+            expect(getOrCreateWidgetStub.calledWith('bottom-widget')).to.be.true;
+            const restoredLayout = setLayoutDataStub.firstCall.args[0] as ApplicationShell.LayoutData;
+            expect((restoredLayout.bottomPanel!.config!.main as DockLayout.ITabAreaConfig).widgets[0]).to.equal(freshWidget);
+        });
+
+        it('should heal right panel disposed widgets', async () => {
+            service.registerPerspective({
+                id: 'perspA',
+                label: 'A',
+                viewPlacements: new Map()
+            });
+            service.registerPerspective({
+                id: 'perspB',
+                label: 'B',
+                viewPlacements: new Map()
+            });
+
+            const disposedWidget = new Widget();
+            disposedWidget.id = 'right-widget';
+            disposedWidget.dispose();
+
+            const freshWidget = new Widget();
+            freshWidget.id = 'right-widget';
+            getOrCreateWidgetStub.withArgs('right-widget').resolves(freshWidget);
+
+            const savedLayout: ApplicationShell.LayoutData = {
+                mainPanel: undefined,
+                bottomPanel: undefined,
+                rightPanel: {
+                    type: 'sidepanel',
+                    items: [{ widget: disposedWidget, rank: 0, expanded: true }]
+                } as SidePanel.LayoutData
+            };
+
+            await service.switchPerspective('perspA');
+            await service.switchPerspective('perspB');
+            service.setSavedLayout('perspA', savedLayout);
+
+            getOrCreateWidgetStub.resetHistory();
+            setLayoutDataStub.resetHistory();
+
+            await service.switchPerspective('perspA');
+
+            expect(getOrCreateWidgetStub.calledWith('right-widget')).to.be.true;
+            const restoredLayout = setLayoutDataStub.firstCall.args[0] as ApplicationShell.LayoutData;
+            expect(restoredLayout.rightPanel!.items![0].widget).to.equal(freshWidget);
+        });
+    });
+
+    describe('Plumbing API (layout persistence)', () => {
+        it('should expose defaultPerspectiveId matching the static constant', () => {
+            expect(service.defaultPerspectiveId).to.equal(PerspectiveServiceImpl.DEFAULT_PERSPECTIVE_ID);
+        });
+
+        it('should return default perspective ID when none is set', () => {
+            expect(service.getActivePerspectiveId()).to.equal(PerspectiveServiceImpl.DEFAULT_PERSPECTIVE_ID);
+        });
+
+        it('should return active perspective ID after switching', async () => {
+            service.registerPerspective({
+                id: 'test-persp',
+                label: 'Test',
+                viewPlacements: new Map()
+            });
+            await service.switchPerspective('test-persp');
+            expect(service.getActivePerspectiveId()).to.equal('test-persp');
+        });
+
+        it('should round-trip getSavedLayout/setSavedLayout', () => {
+            const layout = { mainPanel: { widgets: ['w1'] }, bottomPanel: {} } as unknown as ApplicationShell.LayoutData;
+            service.setSavedLayout('persp-x', layout);
+
+            expect(service.getSavedLayout('persp-x')).to.equal(layout);
+        });
+
+        it('should return undefined for non-existent saved layout', () => {
+            expect(service.getSavedLayout('no-such-persp')).to.be.undefined;
+        });
+
+        it('should return correct saved perspective IDs', () => {
+            const layout1 = { mainPanel: {} } as unknown as ApplicationShell.LayoutData;
+            const layout2 = { mainPanel: {} } as unknown as ApplicationShell.LayoutData;
+            service.setSavedLayout('a', layout1);
+            service.setSavedLayout('b', layout2);
+
+            const ids = service.getSavedPerspectiveIds();
+            expect(ids).to.include('a');
+            expect(ids).to.include('b');
+            expect(ids).to.have.lengthOf(2);
+        });
+
+        it('should set active perspective ID only for registered perspectives', () => {
+            service.registerPerspective({
+                id: 'registered',
+                label: 'Registered',
+                viewPlacements: new Map()
+            });
+
+            expect(service.setActivePerspectiveId('registered')).to.be.true;
+            expect(service.getActivePerspectiveId()).to.equal('registered');
+
+            expect(service.setActivePerspectiveId('unregistered')).to.be.false;
+            expect(service.getActivePerspectiveId()).to.equal('registered');
+        });
+
+        it('should clear all saved layouts', () => {
+            const layout = { mainPanel: {} } as unknown as ApplicationShell.LayoutData;
+            service.setSavedLayout('a', layout);
+            service.setSavedLayout('b', layout);
+
+            service.clearSavedLayouts();
+
+            expect(service.getSavedPerspectiveIds()).to.have.lengthOf(0);
+            expect(service.getSavedLayout('a')).to.be.undefined;
+            expect(service.getSavedLayout('b')).to.be.undefined;
+        });
+    });
+
+    describe('collectWidgetIds', () => {
+        it('should collect IDs from side panel items', () => {
+            const widgetA = new Widget();
+            widgetA.id = 'widget-a';
+            const widgetB = new Widget();
+            widgetB.id = 'widget-b';
+
+            const layout: ApplicationShell.LayoutData = {
+                leftPanel: {
+                    type: 'sidepanel',
+                    items: [
+                        { widget: widgetA, rank: 0, expanded: true },
+                        { widget: widgetB, rank: 1, expanded: false }
+                    ]
+                } as SidePanel.LayoutData,
+                mainPanel: undefined,
+                bottomPanel: undefined
+            };
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ids = (service as any).collectWidgetIds(layout);
+            expect(ids.has('widget-a')).to.be.true;
+            expect(ids.has('widget-b')).to.be.true;
+            expect(ids.size).to.equal(2);
+        });
+
+        it('should collect IDs from dock panel tab-areas', () => {
+            const widgetA = new Widget();
+            widgetA.id = 'tab-widget-a';
+            const widgetB = new Widget();
+            widgetB.id = 'tab-widget-b';
+
+            const layout: ApplicationShell.LayoutData = {
+                mainPanel: {
+                    main: {
+                        type: 'tab-area',
+                        widgets: [widgetA, widgetB],
+                        currentIndex: 0
+                    } as DockLayout.ITabAreaConfig
+                },
+                bottomPanel: undefined
+            };
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ids = (service as any).collectWidgetIds(layout);
+            expect(ids.has('tab-widget-a')).to.be.true;
+            expect(ids.has('tab-widget-b')).to.be.true;
+            expect(ids.size).to.equal(2);
+        });
+
+        it('should collect IDs from nested split-areas', () => {
+            const widgetA = new Widget();
+            widgetA.id = 'split-a';
+            const widgetB = new Widget();
+            widgetB.id = 'split-b';
+
+            const layout: ApplicationShell.LayoutData = {
+                mainPanel: {
+                    main: {
+                        type: 'split-area',
+                        orientation: 'horizontal',
+                        sizes: [0.5, 0.5],
+                        children: [
+                            {
+                                type: 'tab-area',
+                                widgets: [widgetA],
+                                currentIndex: 0
+                            } as DockLayout.ITabAreaConfig,
+                            {
+                                type: 'tab-area',
+                                widgets: [widgetB],
+                                currentIndex: 0
+                            } as DockLayout.ITabAreaConfig
+                        ]
+                    } as DockLayout.ISplitAreaConfig
+                },
+                bottomPanel: undefined
+            };
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ids = (service as any).collectWidgetIds(layout);
+            expect(ids.has('split-a')).to.be.true;
+            expect(ids.has('split-b')).to.be.true;
+            expect(ids.size).to.equal(2);
+        });
+
+        it('should return empty set for empty/missing layout sections', () => {
+            const layout: ApplicationShell.LayoutData = {
+                mainPanel: undefined,
+                bottomPanel: undefined,
+                leftPanel: undefined,
+                rightPanel: undefined
+            };
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ids = (service as any).collectWidgetIds(layout);
+            expect(ids.size).to.equal(0);
+        });
+
+        it('should skip undefined widget entries in tab-areas', () => {
+            const widgetA = new Widget();
+            widgetA.id = 'valid-widget';
+
+            const layout: ApplicationShell.LayoutData = {
+                mainPanel: {
+                    main: {
+                        type: 'tab-area',
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        widgets: [widgetA, undefined as any],
+                        currentIndex: 0
+                    } as DockLayout.ITabAreaConfig
+                },
+                bottomPanel: undefined
+            };
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ids = (service as any).collectWidgetIds(layout);
+            expect(ids.has('valid-widget')).to.be.true;
+            expect(ids.size).to.equal(1);
+        });
+
+        it('should skip undefined widget entries in side panel items', () => {
+            const widgetA = new Widget();
+            widgetA.id = 'valid-side-widget';
+
+            const layout: ApplicationShell.LayoutData = {
+                leftPanel: {
+                    type: 'sidepanel',
+                    items: [
+                        { widget: widgetA, rank: 0, expanded: true },
+                        { widget: undefined, rank: 1, expanded: false }
+                    ]
+                } as SidePanel.LayoutData,
+                mainPanel: undefined,
+                bottomPanel: undefined
+            };
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ids = (service as any).collectWidgetIds(layout);
+            expect(ids.has('valid-side-widget')).to.be.true;
+            expect(ids.size).to.equal(1);
+        });
+
+        it('should collect IDs from bottom panel', () => {
+            const widgetA = new Widget();
+            widgetA.id = 'bottom-widget';
+
+            const layout: ApplicationShell.LayoutData = {
+                mainPanel: undefined,
+                bottomPanel: {
+                    config: {
+                        main: {
+                            type: 'tab-area',
+                            widgets: [widgetA],
+                            currentIndex: 0
+                        } as DockLayout.ITabAreaConfig
+                    }
+                }
+            };
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ids = (service as any).collectWidgetIds(layout);
+            expect(ids.has('bottom-widget')).to.be.true;
+            expect(ids.size).to.equal(1);
+        });
+
+        it('should collect IDs from all panels', () => {
+            const leftWidget = new Widget();
+            leftWidget.id = 'left-w';
+            const rightWidget = new Widget();
+            rightWidget.id = 'right-w';
+            const mainWidget = new Widget();
+            mainWidget.id = 'main-w';
+            const bottomWidget = new Widget();
+            bottomWidget.id = 'bottom-w';
+
+            const layout: ApplicationShell.LayoutData = {
+                leftPanel: {
+                    type: 'sidepanel',
+                    items: [{ widget: leftWidget, rank: 0, expanded: true }]
+                } as SidePanel.LayoutData,
+                rightPanel: {
+                    type: 'sidepanel',
+                    items: [{ widget: rightWidget, rank: 0, expanded: true }]
+                } as SidePanel.LayoutData,
+                mainPanel: {
+                    main: {
+                        type: 'tab-area',
+                        widgets: [mainWidget],
+                        currentIndex: 0
+                    } as DockLayout.ITabAreaConfig
+                },
+                bottomPanel: {
+                    config: {
+                        main: {
+                            type: 'tab-area',
+                            widgets: [bottomWidget],
+                            currentIndex: 0
+                        } as DockLayout.ITabAreaConfig
+                    }
+                }
+            };
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ids = (service as any).collectWidgetIds(layout);
+            expect(ids.has('left-w')).to.be.true;
+            expect(ids.has('right-w')).to.be.true;
+            expect(ids.has('main-w')).to.be.true;
+            expect(ids.has('bottom-w')).to.be.true;
+            expect(ids.size).to.equal(4);
+        });
+    });
+
+    describe('detachStrayWidgets', () => {
+        it('should detach a left-panel widget whose ID is not in the layout ID set', () => {
+            const strayWidget = new Widget();
+            strayWidget.id = 'stray-left';
+            const panel = new Panel();
+            Widget.attach(panel, document.body);
+            panel.addWidget(strayWidget);
+            expect(strayWidget.isAttached).to.be.true;
+
+            getWidgetsStub.withArgs('left').returns([strayWidget]);
+            getWidgetsStub.withArgs('right').returns([]);
+
+            const widgetIds = new Set<string>();
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (service as any).detachStrayWidgets(widgetIds);
+
+            expect(strayWidget.isAttached).to.be.false;
+
+            panel.dispose();
+        });
+
+        it('should detach a right-panel widget whose ID is not in the layout ID set', () => {
+            const strayWidget = new Widget();
+            strayWidget.id = 'stray-right';
+            const panel = new Panel();
+            Widget.attach(panel, document.body);
+            panel.addWidget(strayWidget);
+            expect(strayWidget.isAttached).to.be.true;
+
+            getWidgetsStub.withArgs('left').returns([]);
+            getWidgetsStub.withArgs('right').returns([strayWidget]);
+
+            const widgetIds = new Set<string>();
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (service as any).detachStrayWidgets(widgetIds);
+
+            expect(strayWidget.isAttached).to.be.false;
+
+            panel.dispose();
+        });
+
+        it('should NOT detach a widget whose ID IS in the layout ID set', () => {
+            const keptWidget = new Widget();
+            keptWidget.id = 'kept-widget';
+            const panel = new Panel();
+            Widget.attach(panel, document.body);
+            panel.addWidget(keptWidget);
+            expect(keptWidget.isAttached).to.be.true;
+
+            getWidgetsStub.withArgs('left').returns([keptWidget]);
+            getWidgetsStub.withArgs('right').returns([]);
+
+            const widgetIds = new Set<string>(['kept-widget']);
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (service as any).detachStrayWidgets(widgetIds);
+
+            expect(keptWidget.isAttached).to.be.true;
+
+            panel.dispose();
+        });
+
+        it('should handle empty side panels gracefully', () => {
+            getWidgetsStub.withArgs('left').returns([]);
+            getWidgetsStub.withArgs('right').returns([]);
+
+            const widgetIds = new Set<string>();
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            expect(() => (service as any).detachStrayWidgets(widgetIds)).to.not.throw();
+        });
+
+        it('should detach non-viewPlacements widget that leaked from another perspective', () => {
+            // Simulate: Outline widget is in the left panel but not in the target layout
+            const outlineWidget = new Widget();
+            outlineWidget.id = 'outline-view';
+            const panel = new Panel();
+            Widget.attach(panel, document.body);
+            panel.addWidget(outlineWidget);
+
+            getWidgetsStub.withArgs('left').returns([outlineWidget]);
+            getWidgetsStub.withArgs('right').returns([]);
+
+            // Target layout has no widgets — outline should be detached
+            const widgetIds = new Set<string>();
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (service as any).detachStrayWidgets(widgetIds);
+
+            expect(outlineWidget.isAttached).to.be.false;
+
+            panel.dispose();
+        });
+
+        it('should detach multiple stray widgets from both panels', () => {
+            const leftStray = new Widget();
+            leftStray.id = 'left-stray';
+            const rightStray = new Widget();
+            rightStray.id = 'right-stray';
+            const leftPanel = new Panel();
+            const rightPanel = new Panel();
+            Widget.attach(leftPanel, document.body);
+            Widget.attach(rightPanel, document.body);
+            leftPanel.addWidget(leftStray);
+            rightPanel.addWidget(rightStray);
+
+            getWidgetsStub.withArgs('left').returns([leftStray]);
+            getWidgetsStub.withArgs('right').returns([rightStray]);
+
+            const widgetIds = new Set<string>();
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (service as any).detachStrayWidgets(widgetIds);
+
+            expect(leftStray.isAttached).to.be.false;
+            expect(rightStray.isAttached).to.be.false;
+
+            leftPanel.dispose();
+            rightPanel.dispose();
+        });
+
+        describe('stray widget cleanup during perspective switch', () => {
+            let parentPanel: Panel;
+
+            beforeEach(() => {
+                parentPanel = new Panel();
+                Widget.attach(parentPanel, document.body);
+            });
+
+            afterEach(() => {
+                parentPanel.dispose();
+            });
+
+            it('should detach stray widgets when restoring a saved layout', async () => {
+                const chatWidget = new Widget();
+                chatWidget.id = 'chat-view';
+                parentPanel.addWidget(chatWidget);
+
+                getOrCreateWidgetStub.withArgs('chat-view').resolves(chatWidget);
+
+                service.registerPerspective({
+                    id: 'perspA',
+                    label: 'A',
+                    viewPlacements: new Map([['chat-view', 'main' as ApplicationShell.Area]])
+                });
+                service.registerPerspective({
+                    id: 'perspB',
+                    label: 'B',
+                    viewPlacements: new Map()
+                });
+
+                // Activate A (first time — viewPlacements applied)
+                await service.switchPerspective('perspA');
+
+                // Simulate saving A's layout WITHOUT chat-view (user closed it)
+                const layoutAWithoutChat: ApplicationShell.LayoutData = {
+                    mainPanel: {
+                        main: {
+                            type: 'tab-area',
+                            widgets: [],
+                            currentIndex: -1
+                        } as DockLayout.ITabAreaConfig
+                    },
+                    bottomPanel: undefined
+                };
+                getLayoutDataStub.returns(layoutAWithoutChat);
+
+                // Switch to B (saves A's layout without chat)
+                await service.switchPerspective('perspB');
+
+                // chat-view is still attached (simulating the stray scenario)
+                expect(chatWidget.isAttached).to.be.true;
+
+                // When switching back to A, shell.getWidgets returns the stray
+                getWidgetsStub.withArgs('left').returns([chatWidget]);
+                getWidgetsStub.withArgs('right').returns([]);
+
+                // Switch back to A — should restore layout and detach stray chat-view
+                await service.switchPerspective('perspA');
+
+                expect(chatWidget.isAttached).to.be.false;
+            });
+
+            it('should NOT detach a widget that IS in the saved layout (user customization preserved)', async () => {
+                const chatWidget = new Widget();
+                chatWidget.id = 'chat-view';
+                parentPanel.addWidget(chatWidget);
+
+                getOrCreateWidgetStub.withArgs('chat-view').resolves(chatWidget);
+
+                service.registerPerspective({
+                    id: 'perspA',
+                    label: 'A',
+                    viewPlacements: new Map([['chat-view', 'main' as ApplicationShell.Area]])
+                });
+                service.registerPerspective({
+                    id: 'perspB',
+                    label: 'B',
+                    viewPlacements: new Map()
+                });
+
+                // Activate A
+                await service.switchPerspective('perspA');
+
+                // Simulate saving A's layout WITH chat-view in right panel
+                const layoutAWithChat: ApplicationShell.LayoutData = {
+                    rightPanel: {
+                        type: 'sidepanel',
+                        items: [{ widget: chatWidget, rank: 0, expanded: true }]
+                    } as SidePanel.LayoutData,
+                    mainPanel: undefined,
+                    bottomPanel: undefined
+                };
+                getLayoutDataStub.returns(layoutAWithChat);
+
+                // Switch to B (saves A's layout with chat)
+                await service.switchPerspective('perspB');
+
+                // When switching back, chat is in the right panel
+                getWidgetsStub.withArgs('left').returns([]);
+                getWidgetsStub.withArgs('right').returns([chatWidget]);
+
+                // Switch back to A — chat IS in layout, should NOT be detached
+                await service.switchPerspective('perspA');
+
+                expect(chatWidget.isAttached).to.be.true;
+            });
+
+            it('should detach non-viewPlacements widget leaking from another perspective', async () => {
+                // Outline is not in AI First's viewPlacements
+                const outlineWidget = new Widget();
+                outlineWidget.id = 'outline-view';
+                parentPanel.addWidget(outlineWidget);
+
+                service.registerPerspective({
+                    id: 'ai-first',
+                    label: 'AI First',
+                    viewPlacements: new Map([['chat-view', 'main' as ApplicationShell.Area]])
+                });
+                service.registerPerspective({
+                    id: 'default-persp',
+                    label: 'Default',
+                    viewPlacements: new Map()
+                });
+
+                // Activate AI First
+                await service.switchPerspective('ai-first');
+
+                // Save AI First layout without outline
+                const aiLayout: ApplicationShell.LayoutData = {
+                    mainPanel: {
+                        main: {
+                            type: 'tab-area',
+                            widgets: [],
+                            currentIndex: -1
+                        } as DockLayout.ITabAreaConfig
+                    },
+                    bottomPanel: undefined
+                };
+                getLayoutDataStub.returns(aiLayout);
+
+                // Switch to default (saves AI First layout)
+                await service.switchPerspective('default-persp');
+
+                // Outline is open in default's left panel
+                expect(outlineWidget.isAttached).to.be.true;
+
+                // Switch back to AI First — outline is a stray
+                getWidgetsStub.withArgs('left').returns([outlineWidget]);
+                getWidgetsStub.withArgs('right').returns([]);
+
+                await service.switchPerspective('ai-first');
+
+                // Outline should be detached (not in AI First's saved layout)
+                expect(outlineWidget.isAttached).to.be.false;
+            });
+        });
+    });
+});