@codingame/monaco-vscode-workbench-service-override 37.6.1 → 38.0.0

package/vscode/src/vs/sessions/services/sessions/browser/sessionGridState.d.ts

@@ -0,0 +1,17 @@
+import { ISerializedGrid } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid";
+export interface ISessionGridState {
+    readonly version: 1;
+    readonly grid: ISerializedGrid;
+    readonly sessions: readonly {
+        readonly id: string;
+        readonly resource?: string;
+        readonly sticky: boolean;
+    }[];
+    readonly active: string;
+}
+export declare function isSessionGridLeafData(data: unknown): data is {
+    readonly id: string;
+};
+export declare function isSessionGridState(value: unknown): value is ISessionGridState;
+/** Remap or prune unavailable bindings without inverting branch orientation. */
+export declare function projectSessionGrid(grid: ISerializedGrid, map: (id: string) => string | undefined): ISerializedGrid | undefined;

package/vscode/src/vs/sessions/services/sessions/browser/sessionGridState.js

@@ -0,0 +1,99 @@
+
+import { Orientation } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/sash/sash';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+
+function isSessionGridLeafData(data) {
+    return !!data && typeof data === "object" && "id" in data && typeof data.id === "string";
+}
+function isSessionGridState(value) {
+    if (!value || typeof value !== "object" || !("version" in value) || value.version !== 1 || !("grid" in value) || !value.grid || typeof value.grid !== "object" || !("sessions" in value) || !Array.isArray(value.sessions) || !("active" in value) || typeof value.active !== "string") {
+        return false;
+    }
+    const ids = ( new Set());
+    const resources = ( new Set());
+    for (const session of value.sessions) {
+        if (!session || typeof session !== "object" || typeof session.id !== "string" || !session.id || typeof session.sticky !== "boolean" || (session.resource !== undefined && typeof session.resource !== "string") || ( ids.has(session.id)) || ( resources.has(session.resource))) {
+            return false;
+        }
+        ids.add(session.id);
+        resources.add(session.resource);
+        if (session.resource !== undefined) {
+            try {
+                ( URI.parse(session.resource, true));
+            } catch {
+                return false;
+            }
+        }
+    }
+    const grid = value.grid;
+    const finiteSize = size => typeof size === "number" && Number.isFinite(size) && size >= 0;
+    if (!ids.size || ids.size > 256 || !( ids.has(value.active)) || !("orientation" in grid) || (grid.orientation !== Orientation.HORIZONTAL && grid.orientation !== Orientation.VERTICAL) || !("width" in grid) || !finiteSize(grid.width) || !("height" in grid) || !finiteSize(grid.height) || !("root" in grid)) {
+        return false;
+    }
+    let count = 0;
+    let maximized = 0;
+    const leaves = ( new Set());
+    const validNode = (node, depth) => {
+        if (++count > 1024 || depth > 32 || !node || typeof node !== "object" || !("size" in node) || !finiteSize(node.size) || !("type" in node) || !("data" in node) || ("visible" in node && typeof node.visible !== "boolean")) {
+            return false;
+        }
+        if (node.type === "branch") {
+            return Array.isArray(node.data) && node.data.length > 0 && node.data.every(child => validNode(child, depth + 1));
+        }
+        if (depth === 0 || node.type !== "leaf" || !isSessionGridLeafData(node.data) || !( ids.has(node.data.id)) || ( leaves.has(node.data.id))) {
+            return false;
+        }
+        if ("maximized" in node) {
+            if (typeof node.maximized !== "boolean" || (node.maximized && ++maximized > 1)) {
+                return false;
+            }
+        }
+        leaves.add(node.data.id);
+        return true;
+    };
+    return validNode(grid.root, 0) && leaves.size === ids.size;
+}
+function projectSessionGrid(grid, map) {
+    const leaves = ( new Map());
+    const project = node => {
+        if (node.type === "leaf") {
+            if (!isSessionGridLeafData(node.data)) {
+                throw ( new Error("Invalid session grid leaf"));
+            }
+            const id = map(node.data.id);
+            if (id === undefined) {
+                return undefined;
+            }
+            const existing = leaves.get(id);
+            if (existing) {
+                if (node.maximized) {
+                    existing.maximized = true;
+                }
+                return undefined;
+            }
+            const leaf = {
+                ...node,
+                data: {
+                    id
+                }
+            };
+            delete leaf.visible;
+            leaves.set(id, leaf);
+            return leaf;
+        }
+        const data = node.data.map(project).filter(node => node !== undefined);
+        const branch = {
+            ...node,
+            data
+        };
+        delete branch.visible;
+        return data.length ? branch : undefined;
+    };
+    const root = project(grid.root);
+    return root ? {
+        ...grid,
+        root
+    } : undefined;
+}
+
+export { isSessionGridLeafData, isSessionGridState, projectSessionGrid };

package/vscode/src/vs/sessions/services/sessions/browser/sessionGroupsService.d.ts

@@ -61,8 +61,12 @@ export declare class SessionGroupsService extends Disposable implements ISession
     addToGroup(sessionIdOrIds: string | Iterable<string>, groupId: string): void;
     removeFromGroup(sessionId: string): void;
     getGroupOfSession(sessionId: string): string | undefined;
+    isExplicitlyUngrouped(sessionId: string): boolean;
     getSessionIdsInGroup(groupId: string): string[];
     setPendingNewSessionGroup(groupId: string): void;
+    private capturePendingNewSessionGroup;
+    private replaceInFlightSession;
+    private setCurrentMembership;
     private setMembership;
     private markExplicitlyUngrouped;
     private removeArchivedMembership;

package/vscode/src/vs/sessions/services/sessions/browser/sessionGroupsService.js

@@ -36,8 +36,28 @@ let SessionGroupsService = class SessionGroupsService extends Disposable {
             this.save();
         }
         this._register(this.sessionsManagementService.onDidChangeSessions(e => {
+            const transientMembershipChanged = ( new Set());
+            const inFlightSessionIds = ( new Set(
+                this.sessionsManagementService.getInFlightNewSessionRequests().map(session => session.sessionId)
+            ));
+            for (const session of e.added) {
+                if (( inFlightSessionIds.has(session.sessionId)) && this.capturePendingNewSessionGroup(session.sessionId)) {
+                    transientMembershipChanged.add(session.sessionId);
+                }
+            }
             for (const session of e.removed) {
-                this._inFlightSessionGroups.delete(session.sessionId);
+                if (this._inFlightSessionGroups.delete(session.sessionId)) {
+                    transientMembershipChanged.add(session.sessionId);
+                }
+            }
+            const visibleSessionIds = ( new Set(
+                this.sessionsManagementService.getSessions().map(session => session.sessionId)
+            ));
+            for (const sessionId of ( this._inFlightSessionGroups.keys())) {
+                if (!( visibleSessionIds.has(sessionId))) {
+                    this._inFlightSessionGroups.delete(sessionId);
+                    transientMembershipChanged.add(sessionId);
+                }
             }
             const changed = ( new Set());
             const archivedStateChanged = this.removeArchivedMembership([...e.added, ...e.changed], changed);
@@ -45,6 +65,9 @@ let SessionGroupsService = class SessionGroupsService extends Disposable {
             if (archivedStateChanged || changed.size > 0) {
                 this.save();
             }
+            for (const sessionId of transientMembershipChanged) {
+                changed.add(sessionId);
+            }
             if (changed.size > 0) {
                 this._onDidChange.fire({
                     groupsChanged: false,
@@ -79,27 +102,25 @@ let SessionGroupsService = class SessionGroupsService extends Disposable {
             }
         }));
         this._register(this.sessionsManagementService.onWillSendRequest(session => {
-            if (this._pendingNewSessionGroupId === undefined) {
-                return;
+            if (this.capturePendingNewSessionGroup(session.sessionId)) {
+                this._onDidChange.fire({
+                    groupsChanged: false,
+                    membershipChanged: ( new Set([session.sessionId]))
+                });
             }
-            this._inFlightSessionGroups.set(session.sessionId, this._pendingNewSessionGroupId);
-            this._pendingNewSessionGroupId = undefined;
         }));
-        this._register(this.sessionsManagementService.onDidReplaceSession((
+        this._register(this.sessionsManagementService.onDidReplaceNewDraftSession((
             {
                 from,
                 to
             }
-        ) => {
-            if (from.sessionId === to.sessionId) {
-                return;
-            }
-            const groupId = this._inFlightSessionGroups.get(from.sessionId);
-            if (groupId !== undefined) {
-                this._inFlightSessionGroups.delete(from.sessionId);
-                this._inFlightSessionGroups.set(to.sessionId, groupId);
+        ) => this.replaceInFlightSession(from, to)));
+        this._register(this.sessionsManagementService.onDidReplaceSession((
+            {
+                from,
+                to
             }
-        }));
+        ) => this.replaceInFlightSession(from, to)));
         this._register(this.sessionsManagementService.onDidStartSession(session => {
             const groupId = this._inFlightSessionGroups.get(session.sessionId);
             if (groupId === undefined) {
@@ -119,7 +140,7 @@ let SessionGroupsService = class SessionGroupsService extends Disposable {
         do {
             placed = false;
             for (const session of sessions) {
-                if (session.isArchived.get() || ( this._membership.has(session.sessionId)) || ( this._explicitlyUngroupedSessionIds.has(session.sessionId))) {
+                if (session.isArchived.get() || ( this._membership.has(session.sessionId)) || ( this._inFlightSessionGroups.has(session.sessionId)) || ( this._explicitlyUngroupedSessionIds.has(session.sessionId))) {
                     continue;
                 }
                 const creatorResource = session.createdBySession?.get()?.session;
@@ -148,7 +169,7 @@ let SessionGroupsService = class SessionGroupsService extends Disposable {
         const membershipChanged = ( new Set());
         if (memberSessionIds) {
             for (const sessionId of memberSessionIds) {
-                this.setMembership(sessionId, group.id, membershipChanged);
+                this.setCurrentMembership(sessionId, group.id, membershipChanged);
             }
         }
         this.updateDefaultPlacement(this.sessionsManagementService.getSessions(), membershipChanged);
@@ -207,7 +228,7 @@ let SessionGroupsService = class SessionGroupsService extends Disposable {
         const sessionIds = typeof sessionIdOrIds === "string" ? [sessionIdOrIds] : sessionIdOrIds;
         const membershipChanged = ( new Set());
         for (const sessionId of sessionIds) {
-            this.setMembership(sessionId, groupId, membershipChanged);
+            this.setCurrentMembership(sessionId, groupId, membershipChanged);
         }
         this.updateDefaultPlacement(this.sessionsManagementService.getSessions(), membershipChanged);
         if (membershipChanged.size === 0) {
@@ -220,7 +241,9 @@ let SessionGroupsService = class SessionGroupsService extends Disposable {
         });
     }
     removeFromGroup(sessionId) {
-        if (!this._membership.delete(sessionId)) {
+        const membershipDeleted = this._membership.delete(sessionId);
+        const transientMembershipDeleted = this._inFlightSessionGroups.delete(sessionId);
+        if (!membershipDeleted && !transientMembershipDeleted) {
             return;
         }
         this.markExplicitlyUngrouped(sessionId);
@@ -231,20 +254,62 @@ let SessionGroupsService = class SessionGroupsService extends Disposable {
         });
     }
     getGroupOfSession(sessionId) {
-        return this._membership.get(sessionId);
+        return this._membership.get(sessionId) ?? this._inFlightSessionGroups.get(sessionId);
+    }
+    isExplicitlyUngrouped(sessionId) {
+        return ( this._explicitlyUngroupedSessionIds.has(sessionId));
     }
     getSessionIdsInGroup(groupId) {
-        const result = [];
+        const result = ( new Set());
         for (const [sessionId, gid] of this._membership) {
             if (gid === groupId) {
-                result.push(sessionId);
+                result.add(sessionId);
+            }
+        }
+        for (const [sessionId, gid] of this._inFlightSessionGroups) {
+            if (gid === groupId) {
+                result.add(sessionId);
             }
         }
-        return result;
+        return [...result];
     }
     setPendingNewSessionGroup(groupId) {
         this._pendingNewSessionGroupId = ( this._groups.has(groupId)) ? groupId : undefined;
     }
+    capturePendingNewSessionGroup(sessionId) {
+        if (this._pendingNewSessionGroupId === undefined) {
+            return false;
+        }
+        this._inFlightSessionGroups.set(sessionId, this._pendingNewSessionGroupId);
+        this._pendingNewSessionGroupId = undefined;
+        return true;
+    }
+    replaceInFlightSession(from, to) {
+        if (from.sessionId === to.sessionId) {
+            return;
+        }
+        const groupId = this._inFlightSessionGroups.get(from.sessionId);
+        if (groupId === undefined) {
+            return;
+        }
+        this._inFlightSessionGroups.delete(from.sessionId);
+        this._inFlightSessionGroups.set(to.sessionId, groupId);
+        this._onDidChange.fire({
+            groupsChanged: false,
+            membershipChanged: ( new Set([from.sessionId, to.sessionId]))
+        });
+    }
+    setCurrentMembership(sessionId, groupId, changed) {
+        const inFlightGroupId = this._inFlightSessionGroups.get(sessionId);
+        if (inFlightGroupId !== undefined) {
+            if (inFlightGroupId !== groupId) {
+                this._inFlightSessionGroups.set(sessionId, groupId);
+                changed.add(sessionId);
+            }
+            return;
+        }
+        this.setMembership(sessionId, groupId, changed);
+    }
     setMembership(sessionId, groupId, changed) {
         if (this._explicitlyUngroupedSessionIds.delete(sessionId) || this._membership.get(sessionId) !== groupId) {
             this._membership.set(sessionId, groupId);

package/vscode/src/vs/sessions/services/sessions/browser/sessionNavigation.d.ts

@@ -1,12 +1,15 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ICustomViewService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/customView/browser/customViewService.service";
 import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
 import { ISessionsChangeEvent, IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
 import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
-import { SessionsRecencyHistory } from "./sessionsRecencyHistory.js";
+import { SessionRecencyEntry, SessionsRecencyHistory } from "./sessionsRecencyHistory.js";
+export type SessionNavigationIntent = "explicit" | "history" | "automatic";
 /**
  * The subset of opening behaviour {@link SessionsNavigation} drives. Implemented
  * by the view service, passed in to avoid the navigation (a `services` module)
@@ -18,50 +21,40 @@ export interface ISessionOpener {
         source?: "navigation";
     }): Promise<void>;
     openChat(session: ISession, chatResource: URI): Promise<void>;
+    openNewSession(): Promise<void>;
 }
 /**
- * Provides Back/Forward navigation over the shared session recency history
- * ({@link SessionsRecencyHistory}). Created and owned by
- * the `SessionsService` (view).
- *
- * The recency history is the single source of truth for ordering. Navigation
- * keeps only a cursor (the currently-navigated entry) and walks the history:
- * - Going Back/Forward moves the cursor over the existing order; it never
- *   re-promotes entries (that would break Forward).
- * - Only explicit opens (recorded by the feeder autorun via
- *   {@link SessionsRecencyHistory.markOpened}) re-promote an entry to the front
- *   and reset the cursor to it.
- *
- * Because the history is MRU-ordered and not truncated, going somewhere new
- * after a Back does not discard the previously-newer entries; they remain
- * reachable as older entries (Alt+Tab-style rather than browser-style).
+ * Walks the shared MRU history without promoting entries during Back/Forward.
+ * Explicit destination changes promote their entry without truncating the history.
  */
 export declare class SessionsNavigation extends Disposable {
     private readonly _opener;
     private readonly _activeSession;
+    private readonly _customViewService;
     private readonly _sessionsManagementService;
     private readonly _recency;
     private readonly _logService;
     /** Identity of the entry the cursor currently points at. */
     private readonly _currentKey;
-    /** Guard: true while we are performing a back/forward navigation. */
-    private _navigating;
-    /**
-     * True when the user has explicitly navigated to the new-session view after
-     * having been on a real session. Enables going back to the last real session
-     * without storing a new-session view entry in the history.
-     */
-    private readonly _beyondHistory;
+    private _pendingOpen;
     private readonly _canGoBackCtx;
     private readonly _canGoForwardCtx;
     private readonly _canGoBack;
     private readonly _canGoForward;
-    constructor(_opener: ISessionOpener, _activeSession: IObservable<IActiveSession | undefined>, _sessionsManagementService: ISessionsManagementService, _recency: SessionsRecencyHistory, contextKeyService: IContextKeyService, _logService: ILogService);
+    constructor(_opener: ISessionOpener, _activeSession: IObservable<IActiveSession | undefined>, _customViewService: ICustomViewService, _sessionsManagementService: ISessionsManagementService, _recency: SessionsRecencyHistory, contextKeyService: IContextKeyService, _logService: ILogService);
+    /** Records an explicit opening even when the displayed destination has not changed. */
+    recordOpened(entry: SessionRecencyEntry): void;
+    /** Defers recording intermediate session/chat selections until the destination is ready. */
+    beginSessionOpen(intent: SessionNavigationIntent, token: CancellationToken): {
+        complete(): void;
+        cancel(): void;
+    };
     onDidRemoveSessions(e: ISessionsChangeEvent): void;
     goBack(): Promise<void>;
     goForward(): Promise<void>;
+    private _getActiveEntry;
     /** Index of the current cursor entry in the recency history, or -1. */
     private _indexOfCurrent;
     private _indexOf;
-    private _navigateTo;
+    private _navigate;
 }

package/vscode/src/vs/sessions/services/sessions/browser/sessionNavigation.js

@@ -1,19 +1,21 @@
 
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { getComparisonKey, isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { CanGoBackContext, CanGoForwardContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
 import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { getRecencyEntryKey } from './sessionsRecencyHistory.js';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
 
-function entryKey(sessionResource, chatResource) {
-    return `${( sessionResource.toString())}::${chatResource?.toString() ?? ""}`;
-}
 class SessionsNavigation extends Disposable {
     constructor(
         _opener,
         _activeSession,
+        _customViewService,
         _sessionsManagementService,
         _recency,
         contextKeyService,
@@ -22,54 +24,42 @@ class SessionsNavigation extends Disposable {
         super();
         this._opener = _opener;
         this._activeSession = _activeSession;
+        this._customViewService = _customViewService;
         this._sessionsManagementService = _sessionsManagementService;
         this._recency = _recency;
         this._logService = _logService;
         this._currentKey = observableValue(this, undefined);
-        this._navigating = false;
-        this._beyondHistory = observableValue(this, false);
         this._canGoBack = derived(this, reader => {
             const idx = this._indexOfCurrent(reader);
-            const entries = this._recency.entries;
-            const beyond = this._beyondHistory.read(reader);
-            return (idx >= 0 && idx < entries.length - 1) || (beyond && entries.length > 0);
-        });
-        this._canGoForward = derived(this, reader => {
-            if (this._beyondHistory.read(reader)) {
-                return false;
-            }
-            return this._indexOfCurrent(reader) > 0;
+            return idx >= 0 && idx < this._recency.entries.length - 1;
         });
+        this._canGoForward = derived(this, reader => this._indexOfCurrent(reader) > 0);
         this._canGoBackCtx = CanGoBackContext.bindTo(contextKeyService);
         this._canGoForwardCtx = CanGoForwardContext.bindTo(contextKeyService);
         this._register(autorun(reader => {
-            const activeSession = this._activeSession.read(reader);
-            const activeChat = activeSession?.activeChat.read(reader);
-            const sessionStatus = activeSession?.status.read(reader);
-            const chatStatus = activeChat?.status.read(reader);
-            if (this._navigating) {
+            const customViewOpen = this._customViewService.activeCustomViewOpen.read(reader);
+            if (customViewOpen) {
+                if (customViewOpen.source !== "history") {
+                    this.recordOpened({
+                        kind: "customView",
+                        id: customViewOpen.descriptor.id
+                    });
+                }
                 return;
             }
-            if (!activeSession || sessionStatus === SessionStatus.Untitled) {
-                if (this._recency.entries.length > 0) {
-                    this._beyondHistory.set(true, undefined);
-                }
+            const entry = this._getActiveEntry(reader);
+            const key = getRecencyEntryKey(entry);
+            if (key === this._currentKey.read(undefined) || (this._pendingOpen && !this._pendingOpen.token.isCancellationRequested)) {
                 return;
             }
-            const chatResource = activeChat && chatStatus !== SessionStatus.Untitled ? activeChat.resource : undefined;
-            this._beyondHistory.set(false, undefined);
-            this._recency.markOpened(activeSession.resource, chatResource);
-            this._currentKey.set(entryKey(activeSession.resource, chatResource), undefined);
+            this.recordOpened(entry);
         }));
         this._register(autorun(reader => {
             this._recency.version.read(reader);
             const key = this._currentKey.read(undefined);
             if (key !== undefined && this._indexOf(key) < 0) {
                 const front = this._recency.entries[0];
-                this._currentKey.set(
-                    front ? entryKey(front.sessionResource, front.chatResource) : undefined,
-                    undefined
-                );
+                this._currentKey.set(front ? getRecencyEntryKey(front) : undefined, undefined);
             }
         }));
         this._register(autorun(reader => {
@@ -77,32 +67,70 @@ class SessionsNavigation extends Disposable {
             this._canGoForwardCtx.set(this._canGoForward.read(reader));
         }));
     }
+    recordOpened(entry) {
+        this._pendingOpen = undefined;
+        transaction(tx => {
+            this._recency.markOpened(entry, tx);
+            this._currentKey.set(getRecencyEntryKey(entry), tx);
+        });
+    }
+    beginSessionOpen(intent, token) {
+        const navigationIntent = intent === "automatic" ? this._pendingOpen?.intent ?? intent : intent;
+        const opening = {
+            intent: navigationIntent,
+            token
+        };
+        this._pendingOpen = opening;
+        return {
+            complete: () => {
+                if (this._pendingOpen !== opening) {
+                    return;
+                }
+                this._pendingOpen = undefined;
+                if (!token.isCancellationRequested && navigationIntent !== "history" && !this._customViewService.activeCustomView.get()) {
+                    this.recordOpened(this._getActiveEntry());
+                }
+            },
+            cancel: () => {
+                if (this._pendingOpen === opening) {
+                    this._pendingOpen = undefined;
+                }
+            }
+        };
+    }
     onDidRemoveSessions(e) {
         if (e.removed.length === 0) {
             return;
         }
-        const removedUris = ( new Set(e.removed.map(s => ( s.resource.toString()))));
-        this._recency.remove(entry => ( removedUris.has(( entry.sessionResource.toString()))));
+        const removedUris = ( new Set(e.removed.map(s => getComparisonKey(s.resource))));
+        this._recency.remove(entry => entry.kind === "session" && ( removedUris.has(getComparisonKey(entry.sessionResource))));
     }
     async goBack() {
-        if (this._beyondHistory.get()) {
-            this._beyondHistory.set(false, undefined);
-            const idx = this._indexOfCurrent();
-            await this._navigateTo(idx < 0 ? 0 : idx);
-            return;
-        }
-        const idx = this._indexOfCurrent();
-        if (idx < 0 || idx >= this._recency.entries.length - 1) {
-            return;
-        }
-        await this._navigateTo(idx + 1);
+        await this._navigate(1);
     }
     async goForward() {
-        const idx = this._indexOfCurrent();
-        if (idx <= 0) {
-            return;
+        await this._navigate(-1);
+    }
+    _getActiveEntry(reader) {
+        const customView = this._customViewService.activeCustomView.read(reader);
+        if (customView) {
+            return {
+                kind: "customView",
+                id: customView.id
+            };
         }
-        await this._navigateTo(idx - 1);
+        const session = this._activeSession.read(reader);
+        if (!session || session.status.read(reader) === SessionStatus.Untitled) {
+            return {
+                kind: "newSession"
+            };
+        }
+        const chat = session.activeChat.read(reader);
+        return {
+            kind: "session",
+            sessionResource: session.resource,
+            chatResource: chat && chat.status.read(reader) !== SessionStatus.Untitled ? chat.resource : undefined
+        };
     }
     _indexOfCurrent(reader) {
         const key = reader ? this._currentKey.read(reader) : this._currentKey.get();
@@ -115,41 +143,54 @@ class SessionsNavigation extends Disposable {
         return this._indexOf(key);
     }
     _indexOf(key) {
-        return this._recency.entries.findIndex(e => entryKey(e.sessionResource, e.chatResource) === key);
+        return this._recency.entries.findIndex(e => getRecencyEntryKey(e) === key);
     }
-    async _navigateTo(targetIdx) {
-        const entry = this._recency.entries[targetIdx];
-        if (!entry) {
-            return;
-        }
-        this._logService.trace(
-            `[SessionNavigation] navigating to idx=${targetIdx} session=${( entry.sessionResource.toString())} chat=${entry.chatResource?.toString()}`
-        );
-        this._navigating = true;
-        try {
-            this._currentKey.set(entryKey(entry.sessionResource, entry.chatResource), undefined);
-            const session = this._sessionsManagementService.getSession(entry.sessionResource);
-            if (session) {
-                if (entry.chatResource) {
-                    const chatExists = ( session.chats.get().some(c => ( c.resource.toString()) === ( entry.chatResource.toString())));
-                    if (chatExists) {
+    async _navigate(direction) {
+        while (true) {
+            const idx = this._indexOfCurrent();
+            const entry = idx >= 0 ? this._recency.entries[idx + direction] : undefined;
+            if (!entry) {
+                return;
+            }
+            const key = getRecencyEntryKey(entry);
+            this._logService.trace(`[SessionNavigation] navigating to ${key}`);
+            if (entry.kind === "customView") {
+                const previousKey = this._currentKey.get();
+                this._currentKey.set(key, undefined);
+                this._customViewService.showCustomView(entry.id, {
+                    source: "history"
+                });
+                if (this._customViewService.activeCustomView.get()?.id !== entry.id) {
+                    this._currentKey.set(previousKey, undefined);
+                    this._recency.remove(e => getRecencyEntryKey(e) === key);
+                    continue;
+                }
+            } else if (entry.kind === "newSession") {
+                this._currentKey.set(key, undefined);
+                await this._opener.openNewSession();
+            } else {
+                const session = this._sessionsManagementService.getSession(entry.sessionResource);
+                if (!session) {
+                    this._recency.remove(
+                        e => e.kind === "session" && isEqual(e.sessionResource, entry.sessionResource)
+                    );
+                    continue;
+                }
+                const navigation = this.beginSessionOpen("history", CancellationToken.None);
+                this._currentKey.set(key, undefined);
+                try {
+                    if (entry.chatResource && ( session.chats.get().some(chat => isEqual(chat.resource, entry.chatResource)))) {
                         await this._opener.openChat(session, entry.chatResource);
                     } else {
                         await this._opener.openSession(entry.sessionResource, {
                             source: "navigation"
                         });
                     }
-                } else {
-                    await this._opener.openSession(entry.sessionResource, {
-                        source: "navigation"
-                    });
+                } finally {
+                    navigation.cancel();
                 }
-            } else {
-                const sessionUri = ( entry.sessionResource.toString());
-                this._recency.remove(e => ( e.sessionResource.toString()) === sessionUri);
             }
-        } finally {
-            this._navigating = false;
+            return;
         }
     }
 }