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

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

@@ -0,0 +1,157 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+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 { 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';
+
+function entryKey(sessionResource, chatResource) {
+    return `${( sessionResource.toString())}::${chatResource?.toString() ?? ""}`;
+}
+class SessionsNavigation extends Disposable {
+    constructor(
+        _opener,
+        _activeSession,
+        _sessionsManagementService,
+        _recency,
+        contextKeyService,
+        _logService
+    ) {
+        super();
+        this._opener = _opener;
+        this._activeSession = _activeSession;
+        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;
+        });
+        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) {
+                return;
+            }
+            if (!activeSession || sessionStatus === SessionStatus.Untitled) {
+                if (this._recency.entries.length > 0) {
+                    this._beyondHistory.set(true, undefined);
+                }
+                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._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._register(autorun(reader => {
+            this._canGoBackCtx.set(this._canGoBack.read(reader));
+            this._canGoForwardCtx.set(this._canGoForward.read(reader));
+        }));
+    }
+    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()))));
+    }
+    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);
+    }
+    async goForward() {
+        const idx = this._indexOfCurrent();
+        if (idx <= 0) {
+            return;
+        }
+        await this._navigateTo(idx - 1);
+    }
+    _indexOfCurrent(reader) {
+        const key = reader ? this._currentKey.read(reader) : this._currentKey.get();
+        if (reader) {
+            this._recency.version.read(reader);
+        }
+        if (key === undefined) {
+            return -1;
+        }
+        return this._indexOf(key);
+    }
+    _indexOf(key) {
+        return this._recency.entries.findIndex(e => entryKey(e.sessionResource, e.chatResource) === 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) {
+                        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"
+                    });
+                }
+            } else {
+                const sessionUri = ( entry.sessionResource.toString());
+                this._recency.remove(e => ( e.sessionResource.toString()) === sessionUri);
+            }
+        } finally {
+            this._navigating = false;
+        }
+    }
+}
+
+export { SessionsNavigation };

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

@@ -0,0 +1,32 @@
+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 { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { ISessionOpenTelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionOpenTelemetryService.service";
+export declare const SESSION_OPEN_TIMEOUT_MS = 60000;
+export type SessionOpenSource = "sessionsList" | "navigation" | "link" | "notification" | "automation" | "chat" | "voice" | "fork" | "fallback" | "unknown";
+export type SessionOpenOutcome = "success" | "cancelled" | "failure" | "timeout";
+export interface ISessionOpenTelemetryAttempt {
+    readonly id: number;
+}
+export declare class SessionOpenTelemetryService extends Disposable implements ISessionOpenTelemetryService {
+    private readonly telemetryService;
+    readonly _serviceBrand: undefined;
+    private readonly _boundChats;
+    private _activeAttempt;
+    private _nextAttemptId;
+    constructor(telemetryService: ITelemetryService);
+    withOpenRequest<T>(source: SessionOpenSource, token: CancellationToken, operation: (attempt: ISessionOpenTelemetryAttempt) => Promise<T>): Promise<T>;
+    private _start;
+    sessionResolved(attempt: ISessionOpenTelemetryAttempt, sessionResource: URI, providerId: string, alreadyActive: boolean, sessionWasLoading: boolean): void;
+    sessionActivated(attempt: ISessionOpenTelemetryAttempt, chatResource: URI): void;
+    sessionLoaded(attempt: ISessionOpenTelemetryAttempt): void;
+    modelBound(sessionResource: URI, chatResource: URI): void;
+    modelUnbound(sessionResource: URI, chatResource: URI): void;
+    modelBindFailed(sessionResource: URI, chatResource: URI): void;
+    private _completeIfReady;
+    private _getActive;
+    private _finishActive;
+    private _finish;
+    private _elapsed;
+}

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

@@ -0,0 +1,162 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { getSessionsTelemetryProviderId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const SESSION_OPEN_TIMEOUT_MS = 60_000;
+class SessionOpenTelemetryAttempt extends Disposable {
+    constructor(id, source) {
+        super();
+        this.id = id;
+        this.source = source;
+        this.stopwatch = StopWatch.create(false);
+        this.resources = this._register(( new DisposableStore()));
+        this.provider = "unknown";
+    }
+}
+let SessionOpenTelemetryService = class SessionOpenTelemetryService extends Disposable {
+    constructor(telemetryService) {
+        super();
+        this.telemetryService = telemetryService;
+        this._boundChats = ( new ResourceMap());
+        this._nextAttemptId = 1;
+        this._register(toDisposable(() => this._finishActive("cancelled")));
+    }
+    async withOpenRequest(source, token, operation) {
+        const attempt = this._start(source, token);
+        try {
+            return await operation(attempt);
+        } catch (error) {
+            this._finish(attempt, "failure");
+            throw error;
+        }
+    }
+    _start(source, token) {
+        this._finishActive("cancelled");
+        const attempt = ( new SessionOpenTelemetryAttempt(this._nextAttemptId++, source));
+        this._activeAttempt = attempt;
+        attempt.resources.add(token.onCancellationRequested(() => this._finish(attempt, "cancelled")));
+        attempt.resources.add(
+            disposableTimeout(() => this._finish(attempt, "timeout"), SESSION_OPEN_TIMEOUT_MS)
+        );
+        return attempt;
+    }
+    sessionResolved(attempt, sessionResource, providerId, alreadyActive, sessionWasLoading) {
+        const activeAttempt = this._getActive(attempt);
+        if (!activeAttempt) {
+            return;
+        }
+        activeAttempt.sessionResource = sessionResource;
+        activeAttempt.provider = getSessionsTelemetryProviderId(providerId);
+        activeAttempt.alreadyActive = alreadyActive;
+        activeAttempt.sessionWasLoading = sessionWasLoading;
+        activeAttempt.resourceResolvedDurationMs = this._elapsed(activeAttempt);
+    }
+    sessionActivated(attempt, chatResource) {
+        const activeAttempt = this._getActive(attempt);
+        if (!activeAttempt?.sessionResource) {
+            return;
+        }
+        activeAttempt.chatResource = chatResource;
+        if (activeAttempt.modelBindFailedChatResource && isEqual(activeAttempt.modelBindFailedChatResource, chatResource)) {
+            this._finish(activeAttempt, "failure");
+            return;
+        }
+        activeAttempt.modelAlreadyBound = isEqual(this._boundChats.get(activeAttempt.sessionResource), chatResource);
+        if (activeAttempt.modelAlreadyBound) {
+            activeAttempt.modelBoundDurationMs = this._elapsed(activeAttempt);
+        }
+    }
+    sessionLoaded(attempt) {
+        const activeAttempt = this._getActive(attempt);
+        if (!activeAttempt) {
+            return;
+        }
+        activeAttempt.sessionLoadedDurationMs = this._elapsed(activeAttempt);
+        this._completeIfReady(activeAttempt);
+    }
+    modelBound(sessionResource, chatResource) {
+        this._boundChats.set(sessionResource, chatResource);
+        const activeAttempt = this._activeAttempt;
+        if (!activeAttempt?.sessionResource || !activeAttempt.chatResource || !isEqual(activeAttempt.sessionResource, sessionResource) || !isEqual(activeAttempt.chatResource, chatResource)) {
+            return;
+        }
+        activeAttempt.modelBoundDurationMs = this._elapsed(activeAttempt);
+        this._completeIfReady(activeAttempt);
+    }
+    modelUnbound(sessionResource, chatResource) {
+        const boundChat = this._boundChats.get(sessionResource);
+        if (boundChat && isEqual(boundChat, chatResource)) {
+            this._boundChats.delete(sessionResource);
+        }
+    }
+    modelBindFailed(sessionResource, chatResource) {
+        const activeAttempt = this._activeAttempt;
+        if (!activeAttempt?.sessionResource || !isEqual(activeAttempt.sessionResource, sessionResource)) {
+            return;
+        }
+        if (!activeAttempt.chatResource) {
+            activeAttempt.modelBindFailedChatResource = chatResource;
+        } else if (isEqual(activeAttempt.chatResource, chatResource)) {
+            this._finish(activeAttempt, "failure");
+        } else {
+            activeAttempt.modelBindFailedChatResource = chatResource;
+        }
+    }
+    _completeIfReady(attempt) {
+        if (attempt.sessionLoadedDurationMs !== undefined && attempt.modelBoundDurationMs !== undefined) {
+            this._finish(attempt, "success");
+        }
+    }
+    _getActive(attempt) {
+        const activeAttempt = this._activeAttempt;
+        return activeAttempt?.id === attempt.id ? activeAttempt : undefined;
+    }
+    _finishActive(outcome) {
+        if (this._activeAttempt) {
+            this._finish(this._activeAttempt, outcome);
+        }
+    }
+    _finish(attempt, outcome) {
+        if (this._activeAttempt !== attempt) {
+            return;
+        }
+        this._activeAttempt = undefined;
+        const resourceResolvedDurationMs = attempt.resourceResolvedDurationMs;
+        const sessionLoadedDurationMs = attempt.sessionLoadedDurationMs === undefined ? undefined : Math.max(resourceResolvedDurationMs ?? 0, attempt.sessionLoadedDurationMs);
+        const modelBoundDurationMs = attempt.modelBoundDurationMs === undefined ? undefined : Math.max(
+            sessionLoadedDurationMs ?? resourceResolvedDurationMs ?? 0,
+            attempt.modelBoundDurationMs
+        );
+        const totalDurationMs = Math.max(
+            modelBoundDurationMs ?? sessionLoadedDurationMs ?? resourceResolvedDurationMs ?? 0,
+            this._elapsed(attempt)
+        );
+        attempt.dispose();
+        this.telemetryService.publicLog2("agents/sessionOpen", {
+            outcome,
+            source: attempt.source,
+            provider: attempt.provider,
+            alreadyActive: attempt.alreadyActive,
+            sessionWasLoading: attempt.sessionWasLoading,
+            modelAlreadyBound: attempt.modelAlreadyBound,
+            resourceResolvedDurationMs,
+            sessionLoadedDurationMs,
+            modelBoundDurationMs,
+            totalDurationMs
+        });
+    }
+    _elapsed(attempt) {
+        return Math.max(0, Math.round(attempt.stopwatch.elapsed()));
+    }
+};
+SessionOpenTelemetryService = ( __decorate([( __param(0, ITelemetryService))], SessionOpenTelemetryService));
+
+export { SESSION_OPEN_TIMEOUT_MS, SessionOpenTelemetryService };

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

@@ -0,0 +1,40 @@
+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 { ISessionSectionOrderService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionSectionOrderService.service";
+export declare class SessionSectionOrderService extends Disposable implements ISessionSectionOrderService {
+    private readonly storageService;
+    readonly _serviceBrand: undefined;
+    private static readonly STORAGE_KEY;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    private _order;
+    private _promoted;
+    constructor(storageService: IStorageService);
+    resolveOrder(defaultOrderedIds: readonly string[]): string[];
+    reorder(visibleOrder: readonly string[], draggedId: string, targetId: string, position: "before" | "after", promoteId?: string): void;
+    isPromoted(id: string): boolean;
+    retain(liveIds: Iterable<string>): void;
+    private load;
+    private save;
+}
+/**
+ * Combine a persisted manual order with a default order. Identities present in
+ * `persisted` keep their relative manual order; identities only in
+ * `defaultOrderedIds` are inserted at their default position (after their
+ * nearest preceding default neighbour that is already placed). Stale persisted
+ * identities not in `defaultOrderedIds` are dropped from the result.
+ */
+export declare function resolveSectionOrder(persisted: readonly string[], defaultOrderedIds: readonly string[]): string[];
+/**
+ * Move `draggedId` before/after `targetId` within `order`. Returns the new
+ * array, or `undefined` when the target is not present.
+ */
+export declare function spliceSectionOrder(order: readonly string[], draggedId: string, targetId: string, position: "before" | "after"): string[] | undefined;
+/**
+ * Merge a new order for a subset of identities (`visibleAfter`) into the full
+ * persisted order. Identities not in `visibleAfter` keep their relative
+ * position by staying anchored to the visible identity they previously
+ * followed (or the head, if they preceded all visible identities).
+ */
+export declare function mergeSectionOrder(persisted: readonly string[], visibleAfter: readonly string[]): string[];

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

@@ -0,0 +1,170 @@
+
+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 '@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 '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+var SessionSectionOrderService_1;
+let SessionSectionOrderService = class SessionSectionOrderService extends Disposable {
+    static {
+        SessionSectionOrderService_1 = this;
+    }
+    static {
+        this.STORAGE_KEY = "sessionsListControl.sectionOrder";
+    }
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._order = [];
+        this._promoted = ( new Set());
+        this.load();
+    }
+    resolveOrder(defaultOrderedIds) {
+        return resolveSectionOrder(this._order, defaultOrderedIds);
+    }
+    reorder(visibleOrder, draggedId, targetId, position, promoteId) {
+        const visibleAfter = spliceSectionOrder(visibleOrder, draggedId, targetId, position);
+        if (!visibleAfter) {
+            return;
+        }
+        const next = mergeSectionOrder(this._order, visibleAfter);
+        const orderChanged = !arraysEqual(next, this._order);
+        const promoteChanged = promoteId !== undefined && !( this._promoted.has(promoteId));
+        if (!orderChanged && !promoteChanged) {
+            return;
+        }
+        this._order = next;
+        if (promoteId !== undefined) {
+            this._promoted.add(promoteId);
+        }
+        this.save();
+        this._onDidChange.fire();
+    }
+    isPromoted(id) {
+        return ( this._promoted.has(id));
+    }
+    retain(liveIds) {
+        const live = liveIds instanceof Set ? liveIds : ( new Set(liveIds));
+        const order = this._order.filter(id => ( live.has(id)));
+        const promoted = [...this._promoted].filter(id => ( live.has(id)));
+        if (order.length === this._order.length && promoted.length === this._promoted.size) {
+            return;
+        }
+        this._order = order;
+        this._promoted = ( new Set(promoted));
+        this.save();
+    }
+    load() {
+        const raw = this.storageService.get(SessionSectionOrderService_1.STORAGE_KEY, StorageScope.PROFILE);
+        if (!raw) {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed.order)) {
+                this._order = parsed.order.filter(id => typeof id === "string");
+            }
+            if (Array.isArray(parsed.promoted)) {
+                this._promoted = ( new Set(parsed.promoted.filter(id => typeof id === "string")));
+            }
+        } catch {}
+    }
+    save() {
+        if (this._order.length === 0 && this._promoted.size === 0) {
+            this.storageService.remove(SessionSectionOrderService_1.STORAGE_KEY, StorageScope.PROFILE);
+            return;
+        }
+        const state = {
+            order: this._order,
+            promoted: [...this._promoted]
+        };
+        this.storageService.store(
+            SessionSectionOrderService_1.STORAGE_KEY,
+            JSON.stringify(state),
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+    }
+};
+SessionSectionOrderService = SessionSectionOrderService_1 = ( __decorate([( __param(0, IStorageService))], SessionSectionOrderService));
+function resolveSectionOrder(persisted, defaultOrderedIds) {
+    const live = ( new Set(defaultOrderedIds));
+    const result = persisted.filter(id => ( live.has(id)));
+    const placed = ( new Set(result));
+    for (let i = 0; i < defaultOrderedIds.length; i++) {
+        const id = defaultOrderedIds[i];
+        if (( placed.has(id))) {
+            continue;
+        }
+        let insertAt = 0;
+        for (let j = i - 1; j >= 0; j--) {
+            const idx = result.indexOf(defaultOrderedIds[j]);
+            if (idx !== -1) {
+                insertAt = idx + 1;
+                break;
+            }
+        }
+        result.splice(insertAt, 0, id);
+        placed.add(id);
+    }
+    return result;
+}
+function spliceSectionOrder(order, draggedId, targetId, position) {
+    const without = order.filter(id => id !== draggedId);
+    const targetIndex = without.indexOf(targetId);
+    if (targetIndex === -1) {
+        return undefined;
+    }
+    const insertIndex = position === "before" ? targetIndex : targetIndex + 1;
+    without.splice(insertIndex, 0, draggedId);
+    return without;
+}
+function mergeSectionOrder(persisted, visibleAfter) {
+    const scope = ( new Set(visibleAfter));
+    const head = [];
+    const trailing = ( new Map());
+    let lastInScope;
+    for (const id of persisted) {
+        if (( scope.has(id))) {
+            lastInScope = id;
+            continue;
+        }
+        if (lastInScope === undefined) {
+            head.push(id);
+        } else {
+            let arr = trailing.get(lastInScope);
+            if (!arr) {
+                arr = [];
+                trailing.set(lastInScope, arr);
+            }
+            arr.push(id);
+        }
+    }
+    const result = [...head];
+    for (const id of visibleAfter) {
+        result.push(id);
+        const t = trailing.get(id);
+        if (t) {
+            result.push(...t);
+        }
+    }
+    return result;
+}
+function arraysEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { SessionSectionOrderService, mergeSectionOrder, resolveSectionOrder, spliceSectionOrder };

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

@@ -0,0 +1,63 @@
+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 { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ISession, 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 { ISessionsListModelService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsListModelService.service";
+export declare enum SessionListModelChangeKind {
+    Pinned = "pinned",
+    Sort = "sort"
+}
+/**
+ * The two sort modes the sessions list supports. Mirrors the values of the
+ * (contrib-layer) `SessionsSorting` enum, kept as a plain string union here so
+ * this service stays in the services layer and never imports from contrib.
+ */
+export type SessionSortMode = "created" | "updated";
+export interface ISessionListModelChangeEvent {
+    readonly changes: ReadonlyArray<{
+        readonly sessionId: string;
+        readonly kind: SessionListModelChangeKind;
+    }>;
+}
+export declare class SessionsListModelService extends Disposable implements ISessionsListModelService {
+    private readonly storageService;
+    private readonly sessionsManagementService;
+    readonly _serviceBrand: undefined;
+    private static readonly PINNED_SESSIONS_KEY;
+    private static readonly SORT_OVERRIDES_KEY;
+    private static readonly UPDATED_DEFAULT_PLACEMENTS_KEY;
+    private static readonly LEGACY_READ_SESSIONS_KEY;
+    private static readonly READ_MIGRATION_DONE_KEY;
+    private static readonly UNREAD_DEFAULT_CUTOFF;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<ISessionListModelChangeEvent>;
+    private readonly _pinnedSessionIds;
+    private readonly _sortOverrides;
+    private readonly _updatedDefaultPlacements;
+    private readonly _legacyReadSessionIds;
+    private readonly _migratedReadSessionIds;
+    constructor(storageService: IStorageService, sessionsManagementService: ISessionsManagementService);
+    migrateLegacyReadState(session: ISession): void;
+    pinSession(session: ISession): void;
+    unpinSession(session: ISession): void;
+    unpinSessions(sessions: ISession[]): void;
+    isSessionPinned(session: ISession): boolean;
+    /** Fills missing sort overrides so created sessions start beside their creator; existing overrides remain authoritative. */
+    private updateDefaultPlacement;
+    private ensureCreatorAdjacentSortOverride;
+    private expireUpdatedDefaultPlacements;
+    getNaturalSortKey(session: ISession, mode: SessionSortMode): number;
+    getSortKey(session: ISession, mode: SessionSortMode): number;
+    hasSortOverride(sessionId: string, mode: SessionSortMode): boolean;
+    applySortChanges(mode: SessionSortMode, set: ReadonlyMap<string, number>, clear: Iterable<string>): void;
+    getStatusIcon(status: SessionStatus, isRead: boolean, isArchived: boolean, completedStateIcon?: ThemeIcon): ThemeIcon;
+    private deleteSession;
+    private loadSet;
+    private saveSet;
+    private loadSortOverrides;
+    private saveSortOverrides;
+    private loadUpdatedDefaultPlacements;
+    private saveUpdatedDefaultPlacements;
+}