@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.0

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

@@ -0,0 +1,72 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionsPartService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service";
+import { VisibleSessions } from "./visibleSessions.js";
+export declare enum ClosedItemKind {
+    Chat = "chat",
+    Session = "session"
+}
+/** A chat tab that was closed (hidden) within a session. */
+export interface IClosedChatItem {
+    readonly kind: ClosedItemKind.Chat;
+    readonly session: ISession;
+    readonly chatResource: URI;
+}
+/** A session slot that left the sessions grid. */
+export interface IClosedSessionItem {
+    readonly kind: ClosedItemKind.Session;
+    readonly session: ISession;
+    /** Grid index the slot occupied when the session left the grid. */
+    readonly index: number;
+    readonly sticky: boolean;
+    /**
+     * Set when the session left the grid because a newly opened slot took its
+     * place, holding the id of that slot (`undefined` for the empty
+     * new-session slot). Absent when the user closed the slot explicitly.
+     */
+    readonly replacedBy?: {
+        readonly sessionId: string | undefined;
+    };
+}
+export type ClosedItem = IClosedChatItem | IClosedSessionItem;
+/**
+ * Remembers the single most recently closed chat or session and reopens it
+ * (`Ctrl/Cmd+Shift+T`). Deliberately holds one entry only: reopening consumes
+ * it, so pressing the chord repeatedly cannot walk further back through
+ * history. In-memory only — a window reload starts empty.
+ */
+export declare class ClosedItemHistory extends Disposable {
+    private readonly _visibility;
+    private readonly _openChat;
+    private readonly _sessionsManagementService;
+    private readonly _sessionsPartService;
+    private readonly _item;
+    private _suspendDepth;
+    constructor(_visibility: VisibleSessions, _openChat: (session: ISession, chatResource: URI) => Promise<void>, _sessionsManagementService: ISessionsManagementService, _sessionsPartService: ISessionsPartService, contextKeyService: IContextKeyService);
+    /** Remember a chat that was hidden from its session's tab strip. */
+    recordClosedChat(session: ISession, chatResource: URI): void;
+    /**
+     * Remember a session the user closed, together with the grid slot it holds
+     * right now, so it can return to exactly that position. Must be called
+     * before the session leaves the grid; a session that is not visible is
+     * ignored.
+     */
+    recordClosedSession(session: ISession): void;
+    /**
+     * Remember a session that lost its grid slot to a newly opened one, so it
+     * can take that slot back.
+     */
+    recordReplacedSlot(replaced: ISession, index: number, sticky: boolean, replacedBySessionId: string | undefined): void;
+    /**
+     * Reopen the remembered chat or session and focus it, consuming the entry.
+     * No-op when nothing is remembered or the session is gone.
+     */
+    reopenLast(): Promise<void>;
+    private _reopenSession;
+    private _recordSession;
+    private _record;
+    private _suspend;
+}

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

@@ -0,0 +1,115 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { SessionsHasClosedItemContext } 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 { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var ClosedItemKind;
+(function(ClosedItemKind) {
+    ClosedItemKind["Chat"] = "chat";
+    ClosedItemKind["Session"] = "session";
+})(ClosedItemKind || (ClosedItemKind = {}));
+let ClosedItemHistory = class ClosedItemHistory extends Disposable {
+    constructor(
+        _visibility,
+        _openChat,
+        _sessionsManagementService,
+        _sessionsPartService,
+        contextKeyService
+    ) {
+        super();
+        this._visibility = _visibility;
+        this._openChat = _openChat;
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionsPartService = _sessionsPartService;
+        this._item = observableValue(this, undefined);
+        this._suspendDepth = 0;
+        const hasClosedItem = SessionsHasClosedItemContext.bindTo(contextKeyService);
+        this._register(
+            autorun(reader => hasClosedItem.set(this._item.read(reader) !== undefined))
+        );
+        this._register(this._sessionsManagementService.onDidDeleteSession(session => {
+            if (this._item.get()?.session.sessionId === session.sessionId) {
+                this._item.set(undefined, undefined);
+            }
+        }));
+    }
+    recordClosedChat(session, chatResource) {
+        this._record({
+            kind: ClosedItemKind.Chat,
+            session,
+            chatResource
+        });
+    }
+    recordClosedSession(session) {
+        const slot = this._visibility.getSlot(session.sessionId);
+        if (slot) {
+            this._recordSession(session, slot.index, slot.sticky);
+        }
+    }
+    recordReplacedSlot(replaced, index, sticky, replacedBySessionId) {
+        this._recordSession(replaced, index, sticky, {
+            sessionId: replacedBySessionId
+        });
+    }
+    async reopenLast() {
+        const item = this._item.get();
+        if (!item) {
+            return;
+        }
+        this._item.set(undefined, undefined);
+        const session = this._sessionsManagementService.getSessions().find(s => s.sessionId === item.session.sessionId);
+        if (!session) {
+            return;
+        }
+        const suspension = this._suspend();
+        try {
+            if (item.kind === ClosedItemKind.Chat) {
+                await this._openChat(session, item.chatResource);
+            } else {
+                this._reopenSession(item, session);
+            }
+        } finally {
+            suspension.dispose();
+        }
+        this._sessionsPartService.focusSession(this._visibility.activeSession.get());
+    }
+    _reopenSession(item, session) {
+        if (item.replacedBy && this._visibility.getSlot(item.replacedBy.sessionId)) {
+            this._sessionsManagementService.discardNewSession(this._visibility.getSession(item.replacedBy.sessionId));
+            if (this._visibility.replaceSlot(item.replacedBy.sessionId, session, item.sticky)) {
+                return;
+            }
+        }
+        this._visibility.insertAtIndex(session, item.index, item.sticky);
+    }
+    _recordSession(session, index, sticky, replacedBy) {
+        if (session.status.get() !== SessionStatus.Untitled) {
+            this._record({
+                kind: ClosedItemKind.Session,
+                session,
+                index,
+                sticky,
+                replacedBy
+            });
+        }
+    }
+    _record(item) {
+        if (this._suspendDepth === 0) {
+            this._item.set(item, undefined);
+        }
+    }
+    _suspend() {
+        this._suspendDepth++;
+        return toDisposable(() => this._suspendDepth--);
+    }
+};
+ClosedItemHistory = ( __decorate([( __param(2, ISessionsManagementService)), ( __param(3, ISessionsPartService)), ( __param(4, IContextKeyService))], ClosedItemHistory));
+
+export { ClosedItemHistory, ClosedItemKind };

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

@@ -0,0 +1,77 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionGroupsService.service";
+/**
+ * A user-created group of sessions in the sessions list. Groups render like
+ * section headers and can be reordered, renamed and deleted. Their order is
+ * owned by the section-order service and is fully user-managed; this type only
+ * carries identity, name and creation time. Membership of a session in a group
+ * is tracked separately (see {@link ISessionGroupsService}).
+ */
+export interface ISessionGroup {
+    /** Stable identifier (uuid). */
+    readonly id: string;
+    /** User-provided display name. */
+    readonly name: string;
+    /** Creation timestamp (ms). Used as the default order (newest first). */
+    readonly createdAt: number;
+}
+export interface ISessionGroupsChangeEvent {
+    /** Groups added, removed, renamed or reordered. */
+    readonly groupsChanged: boolean;
+    /** Session ids whose group membership changed. */
+    readonly membershipChanged: ReadonlySet<string>;
+}
+export declare class SessionGroupsService extends Disposable implements ISessionGroupsService {
+    private readonly storageService;
+    private readonly sessionsManagementService;
+    readonly _serviceBrand: undefined;
+    private static readonly STORAGE_KEY;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<ISessionGroupsChangeEvent>;
+    private readonly _groups;
+    /** sessionId -> groupId */
+    private readonly _membership;
+    private readonly _explicitlyUngroupedSessionIds;
+    /**
+     * Group that the composer's in-progress new session should join once sent,
+     * or `undefined` when there is no pending intent. Set via
+     * {@link setPendingNewSessionGroup} when the user picks "New Session" on a
+     * group header, locked onto a specific draft when that draft is sent, and
+     * cleared if the new session is abandoned.
+     */
+    private _pendingNewSessionGroupId;
+    /**
+     * Sends in flight: draft (or, after graduation, committed) sessionId ->
+     * groupId. A grouped send is locked here the moment it is dispatched, so a
+     * later intent or a failed/concurrent send can never rebind it. Consumed
+     * when the session is started.
+     */
+    private readonly _inFlightSessionGroups;
+    constructor(storageService: IStorageService, sessionsManagementService: ISessionsManagementService);
+    /** Fills missing custom-group membership from creation provenance; explicit membership or ungrouping remains authoritative. */
+    private updateDefaultPlacement;
+    getGroups(): ISessionGroup[];
+    getGroup(groupId: string): ISessionGroup | undefined;
+    createGroup(name: string, memberSessionIds?: Iterable<string>): ISessionGroup;
+    renameGroup(groupId: string, name: string): void;
+    deleteGroup(groupId: string): void;
+    addToGroup(sessionIdOrIds: string | Iterable<string>, groupId: string): void;
+    removeFromGroup(sessionId: string): void;
+    getGroupOfSession(sessionId: string): string | undefined;
+    getSessionIdsInGroup(groupId: string): string[];
+    setPendingNewSessionGroup(groupId: string): void;
+    private setMembership;
+    private markExplicitlyUngrouped;
+    private removeArchivedMembership;
+    /**
+     * Sort groups for display as a stable baseline: newest first (by creation
+     * time). The final user-managed order is applied by the section-order
+     * service; this baseline is used where that order is not available.
+     */
+    private sortGroups;
+    private load;
+    private save;
+}

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

@@ -0,0 +1,330 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+var SessionGroupsService_1;
+const EXPLICITLY_UNGROUPED_FIELD = "explicitlyUngroupedSessionIds";
+let SessionGroupsService = class SessionGroupsService extends Disposable {
+    static {
+        SessionGroupsService_1 = this;
+    }
+    static {
+        this.STORAGE_KEY = "sessionsListControl.groups";
+    }
+    constructor(storageService, sessionsManagementService) {
+        super();
+        this.storageService = storageService;
+        this.sessionsManagementService = sessionsManagementService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._groups = ( new Map());
+        this._membership = ( new Map());
+        this._explicitlyUngroupedSessionIds = ( new Set());
+        this._inFlightSessionGroups = ( new Map());
+        this.load();
+        const archivedMembershipChanged = ( new Set());
+        const archivedStateChanged = this.removeArchivedMembership(this.sessionsManagementService.getSessions(), archivedMembershipChanged);
+        this.updateDefaultPlacement(this.sessionsManagementService.getSessions(), archivedMembershipChanged);
+        if (archivedStateChanged || archivedMembershipChanged.size > 0) {
+            this.save();
+        }
+        this._register(this.sessionsManagementService.onDidChangeSessions(e => {
+            for (const session of e.removed) {
+                this._inFlightSessionGroups.delete(session.sessionId);
+            }
+            const changed = ( new Set());
+            const archivedStateChanged = this.removeArchivedMembership([...e.added, ...e.changed], changed);
+            this.updateDefaultPlacement(this.sessionsManagementService.getSessions(), changed);
+            if (archivedStateChanged || changed.size > 0) {
+                this.save();
+            }
+            if (changed.size > 0) {
+                this._onDidChange.fire({
+                    groupsChanged: false,
+                    membershipChanged: changed
+                });
+            }
+        }));
+        this._register(this.sessionsManagementService.onDidDeleteSession(session => {
+            const membershipDeleted = this._membership.delete(session.sessionId);
+            const ungroupedDeleted = this._explicitlyUngroupedSessionIds.delete(session.sessionId);
+            if (membershipDeleted || ungroupedDeleted) {
+                this.save();
+            }
+            if (membershipDeleted) {
+                this._onDidChange.fire({
+                    groupsChanged: false,
+                    membershipChanged: ( new Set([session.sessionId]))
+                });
+            }
+        }));
+        this._register(this.sessionsManagementService.onDidArchiveSession(session => {
+            const membershipDeleted = this._membership.delete(session.sessionId);
+            const ungroupedAdded = this.markExplicitlyUngrouped(session.sessionId);
+            if (membershipDeleted || ungroupedAdded) {
+                this.save();
+            }
+            if (membershipDeleted) {
+                this._onDidChange.fire({
+                    groupsChanged: false,
+                    membershipChanged: ( new Set([session.sessionId]))
+                });
+            }
+        }));
+        this._register(this.sessionsManagementService.onWillSendRequest(session => {
+            if (this._pendingNewSessionGroupId === undefined) {
+                return;
+            }
+            this._inFlightSessionGroups.set(session.sessionId, this._pendingNewSessionGroupId);
+            this._pendingNewSessionGroupId = undefined;
+        }));
+        this._register(this.sessionsManagementService.onDidReplaceSession((
+            {
+                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._register(this.sessionsManagementService.onDidStartSession(session => {
+            const groupId = this._inFlightSessionGroups.get(session.sessionId);
+            if (groupId === undefined) {
+                return;
+            }
+            this._inFlightSessionGroups.delete(session.sessionId);
+            if (( this._groups.has(groupId))) {
+                this.addToGroup(session.sessionId, groupId);
+            }
+        }));
+        this._register(this.sessionsManagementService.onDidDiscardNewSession(() => {
+            this._pendingNewSessionGroupId = undefined;
+        }));
+    }
+    updateDefaultPlacement(sessions, changed) {
+        let placed;
+        do {
+            placed = false;
+            for (const session of sessions) {
+                if (session.isArchived.get() || ( this._membership.has(session.sessionId)) || ( this._explicitlyUngroupedSessionIds.has(session.sessionId))) {
+                    continue;
+                }
+                const creatorResource = session.createdBySession?.get()?.session;
+                const creator = creatorResource ? this.sessionsManagementService.getSession(creatorResource) : undefined;
+                const creatorGroupId = creator ? this._membership.get(creator.sessionId) : undefined;
+                if (creatorGroupId) {
+                    this.setMembership(session.sessionId, creatorGroupId, changed);
+                    placed = true;
+                }
+            }
+        } while (placed);
+    }
+    getGroups() {
+        return this.sortGroups([...( this._groups.values())]);
+    }
+    getGroup(groupId) {
+        return this._groups.get(groupId);
+    }
+    createGroup(name, memberSessionIds) {
+        const group = {
+            id: generateUuid(),
+            name,
+            createdAt: Date.now()
+        };
+        this._groups.set(group.id, group);
+        const membershipChanged = ( new Set());
+        if (memberSessionIds) {
+            for (const sessionId of memberSessionIds) {
+                this.setMembership(sessionId, group.id, membershipChanged);
+            }
+        }
+        this.updateDefaultPlacement(this.sessionsManagementService.getSessions(), membershipChanged);
+        this.save();
+        this._onDidChange.fire({
+            groupsChanged: true,
+            membershipChanged
+        });
+        return group;
+    }
+    renameGroup(groupId, name) {
+        const group = this._groups.get(groupId);
+        if (!group || group.name === name) {
+            return;
+        }
+        this._groups.set(groupId, {
+            ...group,
+            name
+        });
+        this.save();
+        this._onDidChange.fire({
+            groupsChanged: true,
+            membershipChanged: ( new Set())
+        });
+    }
+    deleteGroup(groupId) {
+        if (!this._groups.delete(groupId)) {
+            return;
+        }
+        if (this._pendingNewSessionGroupId === groupId) {
+            this._pendingNewSessionGroupId = undefined;
+        }
+        for (const [sessionId, gid] of this._inFlightSessionGroups) {
+            if (gid === groupId) {
+                this._inFlightSessionGroups.delete(sessionId);
+            }
+        }
+        const membershipChanged = ( new Set());
+        for (const [sessionId, gid] of this._membership) {
+            if (gid === groupId) {
+                this._membership.delete(sessionId);
+                this.markExplicitlyUngrouped(sessionId);
+                membershipChanged.add(sessionId);
+            }
+        }
+        this.save();
+        this._onDidChange.fire({
+            groupsChanged: true,
+            membershipChanged
+        });
+    }
+    addToGroup(sessionIdOrIds, groupId) {
+        if (!( this._groups.has(groupId))) {
+            return;
+        }
+        const sessionIds = typeof sessionIdOrIds === "string" ? [sessionIdOrIds] : sessionIdOrIds;
+        const membershipChanged = ( new Set());
+        for (const sessionId of sessionIds) {
+            this.setMembership(sessionId, groupId, membershipChanged);
+        }
+        this.updateDefaultPlacement(this.sessionsManagementService.getSessions(), membershipChanged);
+        if (membershipChanged.size === 0) {
+            return;
+        }
+        this.save();
+        this._onDidChange.fire({
+            groupsChanged: false,
+            membershipChanged
+        });
+    }
+    removeFromGroup(sessionId) {
+        if (!this._membership.delete(sessionId)) {
+            return;
+        }
+        this.markExplicitlyUngrouped(sessionId);
+        this.save();
+        this._onDidChange.fire({
+            groupsChanged: false,
+            membershipChanged: ( new Set([sessionId]))
+        });
+    }
+    getGroupOfSession(sessionId) {
+        return this._membership.get(sessionId);
+    }
+    getSessionIdsInGroup(groupId) {
+        const result = [];
+        for (const [sessionId, gid] of this._membership) {
+            if (gid === groupId) {
+                result.push(sessionId);
+            }
+        }
+        return result;
+    }
+    setPendingNewSessionGroup(groupId) {
+        this._pendingNewSessionGroupId = ( this._groups.has(groupId)) ? groupId : undefined;
+    }
+    setMembership(sessionId, groupId, changed) {
+        if (this._explicitlyUngroupedSessionIds.delete(sessionId) || this._membership.get(sessionId) !== groupId) {
+            this._membership.set(sessionId, groupId);
+            changed.add(sessionId);
+        }
+    }
+    markExplicitlyUngrouped(sessionId) {
+        const size = this._explicitlyUngroupedSessionIds.size;
+        this._explicitlyUngroupedSessionIds.add(sessionId);
+        return this._explicitlyUngroupedSessionIds.size !== size;
+    }
+    removeArchivedMembership(sessions, changed) {
+        let stateChanged = false;
+        for (const session of sessions) {
+            if (session.isArchived.get()) {
+                if (this._membership.delete(session.sessionId)) {
+                    changed.add(session.sessionId);
+                    stateChanged = true;
+                }
+                stateChanged = this.markExplicitlyUngrouped(session.sessionId) || stateChanged;
+            }
+        }
+        return stateChanged;
+    }
+    sortGroups(groups) {
+        return groups.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    load() {
+        const raw = this.storageService.get(SessionGroupsService_1.STORAGE_KEY, StorageScope.PROFILE);
+        if (!raw) {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed.groups)) {
+                for (const group of parsed.groups) {
+                    if (group && typeof group.id === "string" && typeof group.name === "string") {
+                        this._groups.set(group.id, {
+                            id: group.id,
+                            name: group.name,
+                            createdAt: typeof group.createdAt === "number" ? group.createdAt : Date.now()
+                        });
+                    }
+                }
+            }
+            if (parsed.membership && typeof parsed.membership === "object") {
+                for (const [sessionId, groupId] of Object.entries(parsed.membership)) {
+                    if (typeof groupId === "string" && ( this._groups.has(groupId))) {
+                        this._membership.set(sessionId, groupId);
+                    }
+                }
+            }
+            const explicitlyUngroupedSessionIds = parsed[EXPLICITLY_UNGROUPED_FIELD];
+            if (Array.isArray(explicitlyUngroupedSessionIds)) {
+                for (const sessionId of explicitlyUngroupedSessionIds) {
+                    if (typeof sessionId === "string") {
+                        this._explicitlyUngroupedSessionIds.add(sessionId);
+                    }
+                }
+            }
+        } catch {}
+    }
+    save() {
+        if (this._groups.size === 0 && this._explicitlyUngroupedSessionIds.size === 0) {
+            this.storageService.remove(SessionGroupsService_1.STORAGE_KEY, StorageScope.PROFILE);
+            return;
+        }
+        const state = {
+            groups: [...( this._groups.values())],
+            membership: Object.fromEntries(this._membership),
+            [EXPLICITLY_UNGROUPED_FIELD]: [...this._explicitlyUngroupedSessionIds]
+        };
+        this.storageService.store(
+            SessionGroupsService_1.STORAGE_KEY,
+            JSON.stringify(state),
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+    }
+};
+SessionGroupsService = SessionGroupsService_1 = ( __decorate([( __param(0, IStorageService)), ( __param(1, ISessionsManagementService))], SessionGroupsService));
+
+export { SessionGroupsService };

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

@@ -0,0 +1,67 @@
+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 { 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";
+/**
+ * The subset of opening behaviour {@link SessionsNavigation} drives. Implemented
+ * by the view service, passed in to avoid the navigation (a `services` module)
+ * depending on the core view service.
+ */
+export interface ISessionOpener {
+    openSession(sessionResource: URI, options?: {
+        preserveFocus?: boolean;
+        source?: "navigation";
+    }): Promise<void>;
+    openChat(session: ISession, chatResource: URI): 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).
+ */
+export declare class SessionsNavigation extends Disposable {
+    private readonly _opener;
+    private readonly _activeSession;
+    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 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);
+    onDidRemoveSessions(e: ISessionsChangeEvent): void;
+    goBack(): Promise<void>;
+    goForward(): Promise<void>;
+    /** Index of the current cursor entry in the recency history, or -1. */
+    private _indexOfCurrent;
+    private _indexOf;
+    private _navigateTo;
+}