@codingame/monaco-vscode-api 6.0.3 → 7.0.1

package/vscode/src/vs/workbench/contrib/testing/common/testResult.d.ts

@@ -0,0 +1,226 @@
+import { VSBuffer } from '../../../../base/common/buffer.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IObservable } from '../../../../base/common/observableInternal/base.js';
+import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { TestCoverage } from './testCoverage.js';
+import { TestStateCount } from './testingStates.js';
+import { ResolvedTestRunRequest, ITestItem, IRichLocation, ITestRunTask, TestResultState, ITestMessage, ISerializedTestResults, ITestTaskState, TestResultItem, ITestOutputMessage } from './testTypes.js';
+
+interface ITestRunTaskResults extends ITestRunTask {
+    /**
+     * Contains test coverage for the result, if it's available.
+     */
+    readonly coverage: IObservable<TestCoverage | undefined>;
+    /**
+     * Messages from the task not associated with any specific test.
+     */
+    readonly otherMessages: ITestOutputMessage[];
+    /**
+     * Test results output for the task.
+     */
+    readonly output: ITaskRawOutput;
+}
+interface ITestResult {
+    /**
+     * Count of the number of tests in each run state.
+     */
+    readonly counts: Readonly<TestStateCount>;
+    /**
+     * Unique ID of this set of test results.
+     */
+    readonly id: string;
+    /**
+     * If the test is completed, the unix milliseconds time at which it was
+     * completed. If undefined, the test is still running.
+     */
+    readonly completedAt: number | undefined;
+    /**
+     * Whether this test result is triggered from an auto run.
+     */
+    readonly request: ResolvedTestRunRequest;
+    /**
+     * Human-readable name of the test result.
+     */
+    readonly name: string;
+    /**
+     * Gets all tests involved in the run.
+     */
+    tests: IterableIterator<TestResultItem>;
+    /**
+     * List of this result's subtasks.
+     */
+    tasks: ReadonlyArray<ITestRunTaskResults>;
+    /**
+     * Gets the state of the test by its extension-assigned ID.
+     */
+    getStateById(testExtId: string): TestResultItem | undefined;
+    /**
+     * Serializes the test result. Used to save and restore results
+     * in the workspace.
+     */
+    toJSON(): ISerializedTestResults | undefined;
+    /**
+     * Serializes the test result, includes messages. Used to send the test states to the extension host.
+     */
+    toJSONWithMessages(): ISerializedTestResults | undefined;
+}
+/**
+ * Output type exposed from live test results.
+ */
+interface ITaskRawOutput {
+    readonly onDidWriteData: Event<VSBuffer>;
+    readonly endPromise: Promise<void>;
+    readonly buffers: VSBuffer[];
+    readonly length: number;
+    /** Gets a continuous buffer for the desired range */
+    getRange(start: number, length: number): VSBuffer;
+    /** Gets an iterator of buffers for the range; may avoid allocation of getRange() */
+    getRangeIter(start: number, length: number): Iterable<VSBuffer>;
+}
+declare class TaskRawOutput implements ITaskRawOutput {
+    private readonly writeDataEmitter;
+    private readonly endDeferred;
+    private offset;
+    /** @inheritdoc */
+    readonly onDidWriteData: Event<VSBuffer>;
+    /** @inheritdoc */
+    readonly endPromise: Promise<void>;
+    /** @inheritdoc */
+    readonly buffers: VSBuffer[];
+    /** @inheritdoc */
+    get length(): number;
+    /** @inheritdoc */
+    getRange(start: number, length: number): VSBuffer;
+    /** @inheritdoc */
+    getRangeIter(start: number, length: number): Generator<VSBuffer, void, unknown>;
+    /**
+     * Appends data to the output, returning the byte range where the data can be found.
+     */
+    append(data: VSBuffer, marker?: number): {
+        offset: number;
+        length: number;
+    };
+    private push;
+    /** Signals the output has ended. */
+    end(): void;
+}
+interface TestResultItemWithChildren extends TestResultItem {
+    /** Children in the run */
+    children: TestResultItemWithChildren[];
+}
+declare const enum TestResultItemChangeReason {
+    ComputedStateChange = 0,
+    OwnStateChange = 1,
+    NewMessage = 2
+}
+type TestResultItemChange = {
+    item: TestResultItem;
+    result: ITestResult;
+} & ({
+    reason: TestResultItemChangeReason.ComputedStateChange;
+} | {
+    reason: TestResultItemChangeReason.OwnStateChange;
+    previousState: TestResultState;
+    previousOwnDuration: number | undefined;
+} | {
+    reason: TestResultItemChangeReason.NewMessage;
+    message: ITestMessage;
+});
+/**
+ * Results of a test. These are created when the test initially started running
+ * and marked as "complete" when the run finishes.
+ */
+declare class LiveTestResult extends Disposable implements ITestResult {
+    readonly id: string;
+    readonly persist: boolean;
+    readonly request: ResolvedTestRunRequest;
+    private readonly telemetry;
+    private readonly completeEmitter;
+    private readonly newTaskEmitter;
+    private readonly endTaskEmitter;
+    private readonly changeEmitter;
+    /** todo@connor4312: convert to a WellDefinedPrefixTree */
+    private readonly testById;
+    private testMarkerCounter;
+    private _completedAt?;
+    readonly startedAt: number;
+    readonly onChange: Event<TestResultItemChange>;
+    readonly onComplete: Event<void>;
+    readonly onNewTask: Event<number>;
+    readonly onEndTask: Event<number>;
+    readonly tasks: (ITestRunTaskResults & {
+        output: TaskRawOutput;
+    })[];
+    readonly name: string;
+    /**
+     * @inheritdoc
+     */
+    get completedAt(): number | undefined;
+    /**
+     * @inheritdoc
+     */
+    readonly counts: TestStateCount;
+    /**
+     * @inheritdoc
+     */
+    get tests(): IterableIterator<TestResultItemWithChildren>;
+    /** Gets an included test item by ID. */
+    getTestById(id: string): ITestItem | undefined;
+    private readonly computedStateAccessor;
+    constructor(id: string, persist: boolean, request: ResolvedTestRunRequest, telemetry: ITelemetryService);
+    /**
+     * @inheritdoc
+     */
+    getStateById(extTestId: string): TestResultItemWithChildren | undefined;
+    /**
+     * Appends output that occurred during the test run.
+     */
+    appendOutput(output: VSBuffer, taskId: string, location?: IRichLocation, testId?: string): void;
+    /**
+     * Adds a new run task to the results.
+     */
+    addTask(task: ITestRunTask): void;
+    /**
+     * Add the chain of tests to the run. The first test in the chain should
+     * be either a test root, or a previously-known test.
+     */
+    addTestChainToRun(controllerId: string, chain: ReadonlyArray<ITestItem>): undefined;
+    /**
+     * Updates the state of the test by its internal ID.
+     */
+    updateState(testId: string, taskId: string, state: TestResultState, duration?: number): void;
+    /**
+     * Appends a message for the test in the run.
+     */
+    appendMessage(testId: string, taskId: string, message: ITestMessage): void;
+    /**
+     * Marks the task in the test run complete.
+     */
+    markTaskComplete(taskId: string): void;
+    /**
+     * Notifies the service that all tests are complete.
+     */
+    markComplete(): void;
+    /**
+     * Marks the test and all of its children in the run as retired.
+     */
+    markRetired(testIds: WellDefinedPrefixTree<undefined> | undefined): void;
+    /**
+     * @inheritdoc
+     */
+    toJSON(): ISerializedTestResults | undefined;
+    toJSONWithMessages(): ISerializedTestResults | undefined;
+    /**
+     * Updates all tests in the collection to the given state.
+     */
+    protected setAllToState(state: TestResultState, taskId: string, when: (task: ITestTaskState, item: TestResultItem) => boolean): void;
+    private fireUpdateAndRefresh;
+    private addTestToRun;
+    private mustGetTaskIndex;
+    private readonly doSerialize;
+    private readonly doSerializeWithMessages;
+}
+
+export { type ITaskRawOutput, type ITestResult, type ITestRunTaskResults, LiveTestResult, TaskRawOutput, type TestResultItemChange, TestResultItemChangeReason };

package/vscode/src/vs/workbench/contrib/testing/common/testTypes.d.ts

@@ -0,0 +1,319 @@
+import { IMarkdownString } from '../../../../base/common/htmlContent.js';
+import { URI, UriComponents } from '../../../../base/common/uri.js';
+import { Position, IPosition } from '../../../../editor/common/core/position.js';
+import { Range, IRange } from '../../../../editor/common/core/range.js';
+
+declare const enum TestResultState {
+    Unset = 0,
+    Queued = 1,
+    Running = 2,
+    Passed = 3,
+    Failed = 4,
+    Skipped = 5,
+    Errored = 6
+}
+declare const enum TestRunProfileBitset {
+    Run = 2,
+    Debug = 4,
+    Coverage = 8,
+    HasNonDefaultProfile = 16,
+    HasConfigurable = 32,
+    SupportsContinuousRun = 64
+}
+/**
+ * A fully-resolved request to run tests, passsed between the main thread
+ * and extension host.
+ */
+interface ResolvedTestRunRequest {
+    group: TestRunProfileBitset;
+    targets: {
+        testIds: string[];
+        controllerId: string;
+        profileId: number;
+    }[];
+    exclude?: string[];
+    /** Whether this is a continuous test run */
+    continuous?: boolean;
+    /** Whether this was trigged by a user action in UI. Default=true */
+    preserveFocus?: boolean;
+}
+/** Subset of the IUriIdentityService */
+interface ITestUriCanonicalizer {
+    /** @link import('vs/platform/uriIdentity/common/uriIdentity').IUriIdentityService */
+    asCanonicalUri(uri: URI): URI;
+}
+/**
+ * Location with a fully-instantiated Range and URI.
+ */
+interface IRichLocation {
+    range: Range;
+    uri: URI;
+}
+declare namespace IRichLocation {
+    interface Serialize {
+        range: IRange;
+        uri: UriComponents;
+    }
+    const serialize: (location: Readonly<IRichLocation>) => Serialize;
+    const deserialize: (uriIdentity: ITestUriCanonicalizer, location: Serialize) => IRichLocation;
+}
+declare const enum TestMessageType {
+    Error = 0,
+    Output = 1
+}
+interface ITestErrorMessage {
+    message: string | IMarkdownString;
+    type: TestMessageType.Error;
+    expected: string | undefined;
+    actual: string | undefined;
+    contextValue: string | undefined;
+    location: IRichLocation | undefined;
+}
+declare namespace ITestErrorMessage {
+    interface Serialized {
+        message: string | IMarkdownString;
+        type: TestMessageType.Error;
+        expected: string | undefined;
+        actual: string | undefined;
+        contextValue: string | undefined;
+        location: IRichLocation.Serialize | undefined;
+    }
+    const serialize: (message: Readonly<ITestErrorMessage>) => Serialized;
+    const deserialize: (uriIdentity: ITestUriCanonicalizer, message: Serialized) => ITestErrorMessage;
+}
+interface ITestOutputMessage {
+    message: string;
+    type: TestMessageType.Output;
+    offset: number;
+    length: number;
+    marker?: number;
+    location: IRichLocation | undefined;
+}
+declare namespace ITestOutputMessage {
+    interface Serialized {
+        message: string;
+        offset: number;
+        length: number;
+        type: TestMessageType.Output;
+        location: IRichLocation.Serialize | undefined;
+    }
+    const serialize: (message: Readonly<ITestOutputMessage>) => Serialized;
+    const deserialize: (uriIdentity: ITestUriCanonicalizer, message: Serialized) => ITestOutputMessage;
+}
+type ITestMessage = ITestErrorMessage | ITestOutputMessage;
+declare namespace ITestMessage {
+    type Serialized = ITestErrorMessage.Serialized | ITestOutputMessage.Serialized;
+    const serialize: (message: Readonly<ITestMessage>) => Serialized;
+    const deserialize: (uriIdentity: ITestUriCanonicalizer, message: Serialized) => ITestMessage;
+}
+interface ITestTaskState {
+    state: TestResultState;
+    duration: number | undefined;
+    messages: ITestMessage[];
+}
+declare namespace ITestTaskState {
+    interface Serialized {
+        state: TestResultState;
+        duration: number | undefined;
+        messages: ITestMessage.Serialized[];
+    }
+    const serializeWithoutMessages: (state: ITestTaskState) => Serialized;
+    const serialize: (state: Readonly<ITestTaskState>) => Serialized;
+    const deserialize: (uriIdentity: ITestUriCanonicalizer, state: Serialized) => ITestTaskState;
+}
+interface ITestRunTask {
+    id: string;
+    name: string | undefined;
+    running: boolean;
+}
+/**
+ * The TestItem from .d.ts, as a plain object without children.
+ */
+interface ITestItem {
+    /** ID of the test given by the test controller */
+    extId: string;
+    label: string;
+    tags: string[];
+    busy: boolean;
+    children?: never;
+    uri: URI | undefined;
+    range: Range | null;
+    description: string | null;
+    error: string | IMarkdownString | null;
+    sortText: string | null;
+}
+declare namespace ITestItem {
+    interface Serialized {
+        extId: string;
+        label: string;
+        tags: string[];
+        busy: boolean;
+        children?: never;
+        uri: UriComponents | undefined;
+        range: IRange | null;
+        description: string | null;
+        error: string | IMarkdownString | null;
+        sortText: string | null;
+    }
+    const serialize: (item: Readonly<ITestItem>) => Serialized;
+    const deserialize: (uriIdentity: ITestUriCanonicalizer, serialized: Serialized) => ITestItem;
+}
+declare const enum TestItemExpandState {
+    NotExpandable = 0,
+    Expandable = 1,
+    BusyExpanding = 2,
+    Expanded = 3
+}
+/**
+ * TestItem-like shape, but with an ID and children as strings.
+ */
+interface InternalTestItem {
+    /** Controller ID from whence this test came */
+    controllerId: string;
+    /** Expandability state */
+    expand: TestItemExpandState;
+    /** Raw test item properties */
+    item: ITestItem;
+}
+declare namespace InternalTestItem {
+    interface Serialized {
+        expand: TestItemExpandState;
+        item: ITestItem.Serialized;
+    }
+    const serialize: (item: Readonly<InternalTestItem>) => Serialized;
+    const deserialize: (uriIdentity: ITestUriCanonicalizer, serialized: Serialized) => InternalTestItem;
+}
+/**
+ * Test result item used in the main thread.
+ */
+interface TestResultItem extends InternalTestItem {
+    /** State of this test in various tasks */
+    tasks: ITestTaskState[];
+    /** State of this test as a computation of its tasks */
+    ownComputedState: TestResultState;
+    /** Computed state based on children */
+    computedState: TestResultState;
+    /** Max duration of the item's tasks (if run directly) */
+    ownDuration?: number;
+    /** Whether this test item is outdated */
+    retired?: boolean;
+}
+declare namespace TestResultItem {
+    /**
+     * Serialized version of the TestResultItem. Note that 'retired' is not
+     * included since all hydrated items are automatically retired.
+     */
+    interface Serialized extends InternalTestItem.Serialized {
+        tasks: ITestTaskState.Serialized[];
+        ownComputedState: TestResultState;
+        computedState: TestResultState;
+    }
+    const serializeWithoutMessages: (original: TestResultItem) => Serialized;
+    const serialize: (original: Readonly<TestResultItem>) => Serialized;
+    const deserialize: (uriIdentity: ITestUriCanonicalizer, serialized: Serialized) => TestResultItem;
+}
+interface ISerializedTestResults {
+    /** ID of these test results */
+    id: string;
+    /** Time the results were compelted */
+    completedAt: number;
+    /** Subset of test result items */
+    items: TestResultItem.Serialized[];
+    /** Tasks involved in the run. */
+    tasks: {
+        id: string;
+        name: string | undefined;
+    }[];
+    /** Human-readable name of the test run. */
+    name: string;
+    /** Test trigger informaton */
+    request: ResolvedTestRunRequest;
+}
+interface ICoverageCount {
+    covered: number;
+    total: number;
+}
+declare namespace ICoverageCount {
+    const empty: () => ICoverageCount;
+    const sum: (target: ICoverageCount, src: Readonly<ICoverageCount>) => void;
+}
+interface IFileCoverage {
+    id: string;
+    uri: URI;
+    testIds?: string[];
+    statement: ICoverageCount;
+    branch?: ICoverageCount;
+    declaration?: ICoverageCount;
+}
+declare namespace IFileCoverage {
+    interface Serialized {
+        id: string;
+        uri: UriComponents;
+        testIds: string[] | undefined;
+        statement: ICoverageCount;
+        branch?: ICoverageCount;
+        declaration?: ICoverageCount;
+    }
+    const serialize: (original: Readonly<IFileCoverage>) => Serialized;
+    const deserialize: (uriIdentity: ITestUriCanonicalizer, serialized: Serialized) => IFileCoverage;
+    const empty: (id: string, uri: URI) => IFileCoverage;
+}
+declare const enum DetailType {
+    Declaration = 0,
+    Statement = 1,
+    Branch = 2
+}
+type CoverageDetails = IDeclarationCoverage | IStatementCoverage;
+declare namespace CoverageDetails {
+    type Serialized = IDeclarationCoverage.Serialized | IStatementCoverage.Serialized;
+    const serialize: (original: Readonly<CoverageDetails>) => Serialized;
+    const deserialize: (serialized: Serialized) => CoverageDetails;
+}
+interface IBranchCoverage {
+    count: number | boolean;
+    label?: string;
+    location?: Range | Position;
+}
+declare namespace IBranchCoverage {
+    interface Serialized {
+        count: number | boolean;
+        label?: string;
+        location?: IRange | IPosition;
+    }
+    const serialize: (original: IBranchCoverage) => Serialized;
+    const deserialize: (original: Serialized) => IBranchCoverage;
+}
+interface IDeclarationCoverage {
+    type: DetailType.Declaration;
+    name: string;
+    count: number | boolean;
+    location: Range | Position;
+}
+declare namespace IDeclarationCoverage {
+    interface Serialized {
+        type: DetailType.Declaration;
+        name: string;
+        count: number | boolean;
+        location: IRange | IPosition;
+    }
+    const serialize: (original: IDeclarationCoverage) => Serialized;
+    const deserialize: (original: Serialized) => IDeclarationCoverage;
+}
+interface IStatementCoverage {
+    type: DetailType.Statement;
+    count: number | boolean;
+    location: Range | Position;
+    branches?: IBranchCoverage[];
+}
+declare namespace IStatementCoverage {
+    interface Serialized {
+        type: DetailType.Statement;
+        count: number | boolean;
+        location: IRange | IPosition;
+        branches?: IBranchCoverage.Serialized[];
+    }
+    const serialize: (original: Readonly<IStatementCoverage>) => Serialized;
+    const deserialize: (serialized: Serialized) => IStatementCoverage;
+}
+
+export { CoverageDetails, DetailType, IBranchCoverage, ICoverageCount, IDeclarationCoverage, IFileCoverage, IRichLocation, type ISerializedTestResults, IStatementCoverage, ITestErrorMessage, ITestItem, ITestMessage, ITestOutputMessage, type ITestRunTask, ITestTaskState, type ITestUriCanonicalizer, InternalTestItem, type ResolvedTestRunRequest, TestItemExpandState, TestMessageType, TestResultItem, TestResultState, TestRunProfileBitset };

package/vscode/src/vs/workbench/contrib/testing/common/testTypes.js

@@ -280,7 +280,7 @@ var IFileCoverage;
         statement: original.statement,
         branch: original.branch,
         declaration: original.declaration,
-        testId: original.testId?.toString(),
+        testIds: original.testIds,
         uri: original.uri.toJSON(),
     });
     IFileCoverage.deserialize = (uriIdentity, serialized) => ({
@@ -288,13 +288,12 @@ var IFileCoverage;
         statement: serialized.statement,
         branch: serialized.branch,
         declaration: serialized.declaration,
-        testId: serialized.testId ? TestId.fromString(serialized.testId) : undefined,
+        testIds: serialized.testIds,
         uri: uriIdentity.asCanonicalUri(URI.revive(serialized.uri)),
     });
     IFileCoverage.empty = (id, uri) => ({
         id,
         uri,
-        testId: undefined,
         statement: ICoverageCount.empty(),
     });
 })(IFileCoverage || (IFileCoverage = {})));

package/vscode/src/vs/workbench/contrib/testing/common/testingStates.d.ts

@@ -0,0 +1,10 @@
+import { TestResultState } from './testTypes.js';
+
+/**
+ * Count of the number of tests in each run state.
+ */
+type TestStateCount = {
+    [K in TestResultState]: number;
+};
+
+export type { TestStateCount };

package/vscode/src/vs/workbench/contrib/webview/browser/webviewWindowDragMonitor.js

@@ -3,18 +3,37 @@ import { Disposable } from '../../../../base/common/lifecycle.js';
 class WebviewWindowDragMonitor extends Disposable {
     constructor(targetWindow, getWebview) {
         super();
-        this._register(addDisposableListener(targetWindow, EventType.DRAG_START, () => {
+        const onDragStart = () => {
             getWebview()?.windowDidDragStart();
-        }));
+        };
         const onDragEnd = () => {
             getWebview()?.windowDidDragEnd();
         };
+        this._register(addDisposableListener(targetWindow, EventType.DRAG_START, () => {
+            onDragStart();
+        }));
         this._register(addDisposableListener(targetWindow, EventType.DRAG_END, onDragEnd));
         this._register(addDisposableListener(targetWindow, EventType.MOUSE_MOVE, currentEvent => {
             if (currentEvent.buttons === 0) {
                 onDragEnd();
             }
         }));
+        this._register(addDisposableListener(targetWindow, EventType.DRAG, (event) => {
+            if (event.shiftKey) {
+                onDragEnd();
+            }
+            else {
+                onDragStart();
+            }
+        }));
+        this._register(addDisposableListener(targetWindow, EventType.DRAG_OVER, (event) => {
+            if (event.shiftKey) {
+                onDragEnd();
+            }
+            else {
+                onDragStart();
+            }
+        }));
     }
 }
 export { WebviewWindowDragMonitor };

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewIconManager.js

@@ -1,29 +1,28 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { createStyleSheet, asCSSUrl } from '../../../../base/browser/dom.js';
-import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { LifecyclePhase } from '../../../services/lifecycle/common/lifecycle.js';
 import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.service.js';
-let WebviewIconManager = class WebviewIconManager {
+let WebviewIconManager = class WebviewIconManager extends Disposable {
     constructor(_lifecycleService, _configService) {
+        super();
         this._lifecycleService = _lifecycleService;
         this._configService = _configService;
         this._icons = ( new Map());
-        this._configService.onDidChangeConfiguration(e => {
+        this._register(this._configService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration('workbench.iconTheme')) {
                 this.updateStyleSheet();
             }
-        });
+        }));
     }
     dispose() {
-        this._styleElementDisposable?.dispose();
-        this._styleElementDisposable = undefined;
+        super.dispose();
         this._styleElement = undefined;
     }
     get styleElement() {
         if (!this._styleElement) {
-            this._styleElementDisposable = ( new DisposableStore());
-            this._styleElement = createStyleSheet(undefined, undefined, this._styleElementDisposable);
+            this._styleElement = createStyleSheet(undefined, undefined, this._store);
             this._styleElement.className = 'webview-icons';
         }
         return this._styleElement;

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -137,10 +137,10 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         }
         throw ( new Error(`No authentication provider '${id}' is currently registered.`));
     }
-    async getSessions(id, scopes, activateImmediate = false) {
+    async getSessions(id, scopes, account, activateImmediate = false) {
         const authProvider = this._authenticationProviders.get(id) || (await this.tryActivateProvider(id, activateImmediate));
         if (authProvider) {
-            return await authProvider.getSessions(scopes);
+            return await authProvider.getSessions(scopes, { account });
         }
         else {
             throw ( new Error(`No authentication provider '${id}' is currently registered.`));
@@ -150,7 +150,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         const authProvider = this._authenticationProviders.get(id) || (await this.tryActivateProvider(id, !!options?.activateImmediate));
         if (authProvider) {
             return await authProvider.createSession(scopes, {
-                sessionToRecreate: options?.sessionToRecreate
+                account: options?.account
             });
         }
         else {