@codingame/monaco-vscode-welcome-service-override 36.2.7 → 37.2.0

package/index.js

@@ -8,6 +8,7 @@ import './vscode/src/vs/workbench/contrib/onboarding/browser/onboarding.contribu
 import './vscode/src/vs/workbench/contrib/welcomeViews/common/viewsWelcome.contribution.js';
 import './vscode/src/vs/workbench/contrib/welcomeViews/common/newFile.contribution.js';
 import './vscode/src/vs/workbench/contrib/welcomeOnboarding/browser/welcomeOnboarding.contribution.js';
+import './vscode/src/vs/workbench/contrib/welcomeAgentSessions/browser/agentSessionsWelcome.contribution.js';
 
 function getServiceOverride() {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-welcome-service-override",
-  "version": "36.2.7",
+  "version": "37.2.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - welcome service-override",
   "keywords": [],
@@ -15,7 +15,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "36.2.7"
+    "@codingame/monaco-vscode-api": "37.2.0",
+    "@codingame/monaco-vscode-katex-common": "37.2.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/workbench/contrib/onboarding/browser/media/spotlight.css

@@ -13,6 +13,11 @@
 	z-index: 2600;
 }
 
+/* Expanded pickers and mobile sheets remain above the spotlight blocker. */
+.spotlight-overlay.target-overlay-visible {
+	z-index: 1999;
+}
+
 /* Full-screen click blocker. Transparent; swallows interaction outside the hole. */
 .spotlight-blocker {
 	position: fixed;

package/vscode/src/vs/workbench/contrib/onboarding/browser/onboarding.contribution.js

@@ -12,21 +12,34 @@ import { workbenchConfigurationNodeBase } from '@codingame/monaco-vscode-api/vsc
 import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
 import { onboardingPresentationRegistry } from '../common/onboardingPresentation.js';
 import { onboardingScenarioRegistry } from '../common/onboardingRegistry.js';
-import { ONBOARDING_DEVELOPER_MODE_CONFIG, ONBOARDING_ENABLED_CONFIG } from '../common/onboardingScenarioService.js';
+import { onboardingSequenceStepPresentationRegistry } from '../common/onboardingSequence.js';
+import { ONBOARDING_DEVELOPER_MODE_VARIATIONS_CONFIG, ONBOARDING_DEVELOPER_MODE_CONFIG, ONBOARDING_ENABLED_CONFIG } from '../common/onboardingScenarioService.js';
 import { IOnboardingScenarioService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService.service';
 import './onboardingService.js';
+import { RunOnboardingStepPresentation } from './sequence/runOnboardingStep.js';
+import { OnboardingSequencePresentation } from './sequence/sequencePresentation.js';
 import { SpotlightPresentation } from './spotlight/spotlightPresentation.js';
 
 const configurationRegistry = ( Registry.as(Extensions.Configuration));
 function buildDeveloperModeConfigurationNode() {
     const properties = {};
     const defaultValue = {};
-    for (const id of ( onboardingScenarioRegistry.getScenarios().map(scenario => scenario.id)).sort()) {
-        properties[id] = {
+    const variationProperties = {};
+    const variationDefaultValue = {};
+    for (const scenario of [...onboardingScenarioRegistry.getScenarios()].sort((a, b) => a.id.localeCompare(b.id))) {
+        properties[scenario.id] = {
             type: "boolean",
             default: false
         };
-        defaultValue[id] = false;
+        defaultValue[scenario.id] = false;
+        if (scenario.developerModeVariations?.length) {
+            variationProperties[scenario.id] = {
+                type: "string",
+                default: "",
+                enum: ["", ...scenario.developerModeVariations]
+            };
+            variationDefaultValue[scenario.id] = "";
+        }
     }
     return {
         ...workbenchConfigurationNodeBase,
@@ -40,10 +53,23 @@ function buildDeveloperModeConfigurationNode() {
                 },
                 tags: ["experimental"],
                 description: ( localize(
-                    12885,
+                    14868,
                     "Map of onboarding scenario/tour id to whether developer mode is enabled for it. When enabled for a scenario, that onboarding tour ignores usage-based eligibility checks (such as how many sessions you have started), previously persisted shown state, and any linked experiment (so it is shown even if the experiment is not running or you are in the control group). It does not override the {0} setting. The tour is still shown at most once per window session, so reload the window to show it again.",
                     `\`#${ONBOARDING_ENABLED_CONFIG}#\``
                 ))
+            },
+            [ONBOARDING_DEVELOPER_MODE_VARIATIONS_CONFIG]: {
+                type: "object",
+                default: variationDefaultValue,
+                properties: variationProperties,
+                additionalProperties: {
+                    type: "string"
+                },
+                tags: ["experimental"],
+                description: ( localize(
+                    14869,
+                    "Map of onboarding scenario/tour id to the variation used while developer mode is enabled for that scenario. An empty value uses the experiment-selected or default variation."
+                ))
             }
         }
     };
@@ -56,7 +82,7 @@ configurationRegistry.registerConfiguration({
             type: "boolean",
             default: true,
             description: ( localize(
-                12886,
+                14870,
                 "When enabled, onboarding tours and hints may appear automatically to highlight features. Disabling this does not affect tours you start manually."
             ))
         }
@@ -83,6 +109,10 @@ let OnboardingContribution = class OnboardingContribution extends Disposable {
         );
         const spotlight = this._register(instantiationService.createInstance(SpotlightPresentation));
         this._register(onboardingPresentationRegistry.register(spotlight));
+        this._register(onboardingSequenceStepPresentationRegistry.register(spotlight));
+        const sequence = this._register(( new OnboardingSequencePresentation()));
+        this._register(onboardingPresentationRegistry.register(sequence));
+        this._register(onboardingSequenceStepPresentationRegistry.register(( new RunOnboardingStepPresentation())));
         onboardingService.start();
     }
 };
@@ -96,7 +126,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "workbench.action.onboarding.resetShownState",
-            title: ( localize2(12887, "Reset Onboarding Shown State")),
+            title: ( localize2(14871, "Reset Onboarding Shown State")),
             category: Categories.Developer,
             f1: true
         });

package/vscode/src/vs/workbench/contrib/onboarding/browser/onboardingService.d.ts

@@ -93,6 +93,8 @@ export declare class OnboardingScenarioService extends Disposable implements IOn
     private _pump;
     private _doPump;
     private _runPresentation;
+    /** Emit an impression when a presentation has rendered visible onboarding UI. */
+    private _reportShown;
     /** Emit per-tour telemetry. Only called when a tour was actually shown. */
     private _reportOutcome;
     private _registerTriggerListeners;

package/vscode/src/vs/workbench/contrib/onboarding/browser/onboardingService.js

@@ -61,7 +61,10 @@ let OnboardingScenarioService = class OnboardingScenarioService extends Disposab
         this._openedAssignmentContextIds = this._loadOpenedIds();
         this.assignmentService.addTelemetryAssignmentFilter({
             id: "onboarding",
-            exclude: assignment => assignment.startsWith(ONBOARDING_ASSIGNMENT_CONTEXT_PREFIX) && !( this._openedAssignmentContextIds.has(assignment)),
+            exclude: assignment => {
+                const variant = getAssignmentContextVariant(assignment);
+                return variant.startsWith(ONBOARDING_ASSIGNMENT_CONTEXT_PREFIX) && !( this._openedAssignmentContextIds.has(variant));
+            },
             onDidChange: this._onDidChangeOpenedIds.event
         });
         this._register(this.lifecycleService.onWillShutdown(() => this._stop()));
@@ -136,10 +139,19 @@ let OnboardingScenarioService = class OnboardingScenarioService extends Disposab
                 claimedSeenKeys.add(this._seenKey(scenario));
             }
         }
-        for (const scenario of onboardingScenarioRegistry.getScenarios()) {
-            if (!this._isAutoEligible(scenario)) {
-                continue;
+        const eligibleScenarios = ( onboardingScenarioRegistry.getScenarios().map((scenario, registrationIndex) => ({
+            scenario,
+            registrationIndex
+        }))).filter((
+            {
+                scenario
             }
+        ) => this._isAutoEligible(scenario)).sort(
+            (a, b) => (b.scenario.priority ?? 0) - (a.scenario.priority ?? 0) || a.registrationIndex - b.registrationIndex
+        );
+        for (const {
+            scenario
+        } of eligibleScenarios) {
             const seenKey = this._seenKey(scenario);
             if (!scenario.repeatable && ( claimedSeenKeys.has(seenKey))) {
                 continue;
@@ -242,10 +254,17 @@ let OnboardingScenarioService = class OnboardingScenarioService extends Disposab
         const abort = ( new Emitter());
         this._activeAbort = abort;
         const startTime = Date.now();
+        let didReportShown = false;
         try {
             const result = await presentation.run(scenario, {
                 targetWindow: mainWindow,
-                onAbort: abort.event
+                onAbort: abort.event,
+                onDidShow: () => {
+                    if (!didReportShown) {
+                        didReportShown = true;
+                        this._reportShown(scenario);
+                    }
+                }
             });
             this._recordOutcome(this._seenKey(scenario), result.outcome);
             if (result.shown) {
@@ -257,6 +276,14 @@ let OnboardingScenarioService = class OnboardingScenarioService extends Disposab
             abort.dispose();
         }
     }
+    _reportShown(scenario) {
+        const experimentState = scenario.experiment ? this._experimentStates.get(scenario.id) : undefined;
+        this.telemetryService.publicLog2("onboarding.scenarioShown", {
+            scenarioId: scenario.id,
+            experimentActive: experimentState?.active === true,
+            experimentAssignmentContextId: experimentState?.active ? experimentState.assignmentContextId : undefined
+        });
+    }
     _reportOutcome(scenario, result, durationMs) {
         const experimentActive = !!scenario.experiment && this._experimentStates.get(scenario.id)?.active === true;
         this.telemetryService.publicLog2("onboarding.scenarioOutcome", {
@@ -374,5 +401,9 @@ let OnboardingScenarioService = class OnboardingScenarioService extends Disposab
     }
 };
 OnboardingScenarioService = OnboardingScenarioService_1 = ( __decorate([( __param(0, IStorageService)), ( __param(1, IContextKeyService)), ( __param(2, IConfigurationService)), ( __param(3, ILifecycleService)), ( __param(4, IWorkbenchAssignmentService)), ( __param(5, ITelemetryService))], OnboardingScenarioService));
+function getAssignmentContextVariant(assignment) {
+    const separatorIndex = assignment.lastIndexOf(":");
+    return separatorIndex === -1 ? assignment : assignment.slice(0, separatorIndex);
+}
 
 export { OnboardingScenarioService };

package/vscode/src/vs/workbench/contrib/onboarding/browser/sequence/runOnboardingStep.d.ts

@@ -0,0 +1,17 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IOnboardingSequenceStep, IOnboardingSequenceStepContext, IOnboardingSequenceStepPresentation, IOnboardingSequenceStepResult } from "../../common/onboardingSequence.js";
+export declare const RUN_ONBOARDING_STEP_KIND = "run";
+export interface IRunOnboardingStepResult {
+    readonly shown?: boolean;
+}
+/** Callback payload for a cancellable non-visual sequence step. */
+export interface IRunOnboardingStepPayload {
+    readonly run: (token: CancellationToken) => Promise<IRunOnboardingStepResult | void> | IRunOnboardingStepResult | void;
+}
+/** Executes a run-step callback once and continues after reported errors. */
+export declare class RunOnboardingStepPresentation implements IOnboardingSequenceStepPresentation {
+    readonly kind = "run";
+    readonly countsAsVisualStep = false;
+    readonly runOnce = true;
+    runStep(step: IOnboardingSequenceStep, context: IOnboardingSequenceStepContext): Promise<IOnboardingSequenceStepResult>;
+}

package/vscode/src/vs/workbench/contrib/onboarding/browser/sequence/runOnboardingStep.js

@@ -0,0 +1,32 @@
+
+import { raceCancellation } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+
+const RUN_ONBOARDING_STEP_KIND = 'run';
+class RunOnboardingStepPresentation {
+    constructor() {
+        this.kind = RUN_ONBOARDING_STEP_KIND;
+        this.countsAsVisualStep = false;
+        this.runOnce = true;
+    }
+    async runStep(step, context) {
+        if (context.cancellationToken.isCancellationRequested) {
+            return { action: 'abort', shown: false };
+        }
+        let result = undefined;
+        try {
+            const payload = step.payload;
+            result = await raceCancellation(Promise.resolve(payload.run(context.cancellationToken)), context.cancellationToken);
+        }
+        catch (error) {
+            if (!context.cancellationToken.isCancellationRequested) {
+                onUnexpectedError(error);
+            }
+        }
+        return context.cancellationToken.isCancellationRequested
+            ? { action: 'abort', shown: false }
+            : { action: 'next', shown: result?.shown === true };
+    }
+}
+
+export { RUN_ONBOARDING_STEP_KIND, RunOnboardingStepPresentation };

package/vscode/src/vs/workbench/contrib/onboarding/browser/sequence/sequencePresentation.d.ts

@@ -0,0 +1,10 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IOnboardingPresentation, IOnboardingRunContext } from "../../common/onboardingPresentation.js";
+import { IOnboardingRunResult, IOnboardingScenario } from "../../common/onboardingScenario.js";
+/** Runs a heterogeneous sequence while leaving each step's rendering to its registered kind. */
+export declare class OnboardingSequencePresentation extends Disposable implements IOnboardingPresentation {
+    readonly kind = "sequence";
+    run(scenario: IOnboardingScenario, context: IOnboardingRunContext): Promise<IOnboardingRunResult>;
+    private _presentation;
+    private _visualStepIndex;
+}

package/vscode/src/vs/workbench/contrib/onboarding/browser/sequence/sequencePresentation.js

@@ -0,0 +1,154 @@
+
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { OnboardingDismissReason, OnboardingOutcome } from '../../common/onboardingScenario.js';
+import { ONBOARDING_SEQUENCE_PRESENTATION_KIND, onboardingSequenceStepPresentationRegistry } from '../../common/onboardingSequence.js';
+
+class OnboardingSequencePresentation extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.kind = ONBOARDING_SEQUENCE_PRESENTATION_KIND;
+    }
+    async run(scenario, context) {
+        const steps = scenario.presentation.payload?.steps ?? [];
+        if (steps.length === 0) {
+            return {
+                outcome: OnboardingOutcome.Completed,
+                shown: false,
+                dismissReason: OnboardingDismissReason.Completed,
+                lastStepIndex: 0,
+                stepCount: 0
+            };
+        }
+        const store = ( new DisposableStore());
+        try {
+            const cancellation = store.add(( new CancellationTokenSource()));
+            store.add(context.onAbort(() => cancellation.cancel()));
+            const skippedVisualSteps = ( new Set());
+            const shownVisualSteps = ( new Set());
+            const executedRunOnceSteps = ( new Set());
+            const visualStepCount = steps.reduce(
+                (count, step) => count + (this._presentation(step)?.countsAsVisualStep ? 1 : 0),
+                0
+            );
+            let index = 0;
+            let direction = 1;
+            let shown = false;
+            let lastStepIndex = 0;
+            let dismissReason = OnboardingDismissReason.Completed;
+            while (index >= 0 && index < steps.length && !cancellation.token.isCancellationRequested) {
+                const step = steps[index];
+                const presentation = this._presentation(step);
+                if (!presentation) {
+                    onUnexpectedError(( new Error(`No onboarding sequence step presentation registered for '${step.kind}'.`)));
+                    return {
+                        outcome: OnboardingOutcome.Aborted,
+                        shown,
+                        dismissReason: OnboardingDismissReason.Aborted,
+                        lastStepIndex,
+                        stepCount: steps.length
+                    };
+                }
+                if (!presentation.countsAsVisualStep && direction === -1) {
+                    index--;
+                    continue;
+                }
+                if (presentation.runOnce && ( executedRunOnceSteps.has(index))) {
+                    index += direction;
+                    continue;
+                }
+                if (presentation.runOnce) {
+                    executedRunOnceSteps.add(index);
+                }
+                if (presentation.countsAsVisualStep) {
+                    skippedVisualSteps.delete(index);
+                }
+                const visualStepIndex = this._visualStepIndex(steps, index, skippedVisualSteps);
+                const currentVisualStepCount = visualStepCount - skippedVisualSteps.size;
+                if (!presentation.countsAsVisualStep) {
+                    lastStepIndex = Math.max(lastStepIndex, index);
+                }
+                const result = await presentation.runStep(step, {
+                    ...context,
+                    cancellationToken: cancellation.token,
+                    stepIndex: index,
+                    visualStepIndex,
+                    visualStepCount: currentVisualStepCount,
+                    canGoBack: ( Array.from(shownVisualSteps).some(stepIndex => stepIndex < index)),
+                    isLastVisualStep: visualStepIndex === currentVisualStepCount - 1
+                });
+                if (cancellation.token.isCancellationRequested || result.action === "abort") {
+                    return {
+                        outcome: OnboardingOutcome.Aborted,
+                        shown,
+                        dismissReason: OnboardingDismissReason.Aborted,
+                        lastStepIndex,
+                        stepCount: steps.length
+                    };
+                }
+                if (result.shown) {
+                    shown = true;
+                    lastStepIndex = Math.max(lastStepIndex, index);
+                    if (presentation.countsAsVisualStep) {
+                        shownVisualSteps.add(index);
+                    }
+                }
+                switch (result.action) {
+                case "next":
+                    dismissReason = result.dismissReason ?? dismissReason;
+                    direction = 1;
+                    index++;
+                    break;
+                case "back":
+                    direction = -1;
+                    index--;
+                    break;
+                case "skipStep":
+                    if (presentation.countsAsVisualStep) {
+                        skippedVisualSteps.add(index);
+                    }
+                    index += direction;
+                    break;
+                case "skipSequence":
+                    return {
+                        outcome: OnboardingOutcome.Skipped,
+                        shown,
+                        dismissReason: result.dismissReason ?? OnboardingDismissReason.SkipButton,
+                        lastStepIndex,
+                        stepCount: steps.length
+                    };
+                }
+            }
+            return cancellation.token.isCancellationRequested ? {
+                outcome: OnboardingOutcome.Aborted,
+                shown,
+                dismissReason: OnboardingDismissReason.Aborted,
+                lastStepIndex,
+                stepCount: steps.length
+            } : {
+                outcome: OnboardingOutcome.Completed,
+                shown,
+                dismissReason,
+                lastStepIndex,
+                stepCount: steps.length
+            };
+        } finally {
+            store.dispose();
+        }
+    }
+    _presentation(step) {
+        return onboardingSequenceStepPresentationRegistry.get(step.kind);
+    }
+    _visualStepIndex(steps, index, skippedVisualSteps) {
+        let visualStepIndex = 0;
+        for (let stepIndex = 0; stepIndex < index; stepIndex++) {
+            if (this._presentation(steps[stepIndex])?.countsAsVisualStep && !( skippedVisualSteps.has(stepIndex))) {
+                visualStepIndex++;
+            }
+        }
+        return visualStepIndex;
+    }
+}
+
+export { OnboardingSequencePresentation };

package/vscode/src/vs/workbench/contrib/onboarding/browser/spotlight/onboardingTarget.d.ts

@@ -8,12 +8,18 @@ import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/
  */
 export declare const ONBOARDING_TARGET_ATTR = "data-onboarding-id";
 export declare const ONBOARDING_TARGET_PULSE_CLASS = "onboarding-target-pulse";
+export interface IOnboardingTargetOptions {
+    /** Opens or expands the target before its spotlight step is shown. */
+    readonly open?: () => Promise<void> | void;
+}
 /**
  * Marks `element` as the onboarding target identified by `id`.
  *
  * @returns A disposable that removes the attribute again.
  */
-export declare function markOnboardingTarget(element: HTMLElement, id: string): IDisposable;
+export declare function markOnboardingTarget(element: HTMLElement, id: string, options?: IOnboardingTargetOptions): IDisposable;
+/** Opens or expands a target through the behavior registered by its owner. */
+export declare function openOnboardingTarget(element: HTMLElement): Promise<void> | void;
 /**
  * Applies the standard onboarding pulse treatment to `element`.
  *

package/vscode/src/vs/workbench/contrib/onboarding/browser/spotlight/onboardingTarget.js

@@ -5,6 +5,10 @@ import * as onboardingTarget from '../media/onboardingTarget.css';
 
 registerCss(onboardingTarget);
 const ONBOARDING_TARGET_ATTR = "data-onboarding-id";
+const onboardingTargetRegistrations = ( new WeakMap());
+function openOnboardingTarget(element) {
+    return onboardingTargetRegistrations.get(element)?.options.open?.();
+}
 function findOnboardingTarget(targetWindow, id) {
     const selector = `[${ONBOARDING_TARGET_ATTR}="${CSS.escape(id)}"]`;
     const targets = Array.from(targetWindow.document.querySelectorAll(selector));
@@ -22,4 +26,4 @@ function isVisibleOnboardingTarget(targetWindow, target) {
     return rect.width > 0 && rect.height > 0;
 }
 
-export { ONBOARDING_TARGET_ATTR, findOnboardingTarget };
+export { ONBOARDING_TARGET_ATTR, findOnboardingTarget, openOnboardingTarget };

package/vscode/src/vs/workbench/contrib/onboarding/browser/spotlight/spotlightOverlay.d.ts

@@ -1,7 +1,7 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
-import { SpotlightPlacement } from "./spotlightTypes.js";
+import { SpotlightPlacement, SpotlightTargetClickBehavior } from "./spotlightTypes.js";
 import { OnboardingDismissReason } from "../../common/onboardingScenario.js";
 /** How the user advanced to the next step. */
 export type SpotlightAdvanceSource = "button" | "target";
@@ -11,9 +11,11 @@ export type SpotlightSkipReason = OnboardingDismissReason.SkipButton | Onboardin
 export interface ISpotlightContent {
     readonly title: string;
     readonly description: string | IMarkdownString;
+    /** Localized primary button label, replacing the default Next or Done. */
+    readonly nextButtonLabel?: string;
     /** Zero-based index of the current step. */
     readonly stepIndex: number;
-    /** Total number of steps in the tour. */
+    /** Total number of steps in the tour. Progress is displayed only for multi-step tours. */
     readonly stepCount: number;
     /** Whether a "Back" action should be offered. */
     readonly canGoBack: boolean;
@@ -25,12 +27,10 @@ export interface ISpotlightShowOptions {
     readonly placement?: SpotlightPlacement;
     readonly allowTargetInteraction?: boolean;
     readonly padding?: number;
-    /**
-     * When set, the step advances (fires `onDidClickNext`) when the user clicks
-     * the spotlighted target itself. The "Next" button is hidden and the target
-     * is kept interactive so the user can press it to continue.
-     */
-    readonly advanceOnTargetClick?: boolean;
+    readonly hideNext?: boolean;
+    readonly targetOverlayVisible?: boolean;
+    /** Advances on target activation; `advanceOnly` consumes the activation without running its action. */
+    readonly advanceOnTargetClick?: SpotlightTargetClickBehavior;
 }
 /**
  * A pure-DOM spotlight overlay: dims the window, cuts a highlight hole around a
@@ -63,11 +63,14 @@ export declare class SpotlightOverlay extends Disposable {
     readonly onDidSkip: Event<SpotlightSkipReason>;
     private _target;
     private _options;
+    private _hasShown;
     private _previousFocus;
     private _scheduledLayout;
     constructor(_container: HTMLElement, _resizeObserverCtor?: typeof ResizeObserver);
     /** Show `content` spotlighting `target`. */
     show(target: HTMLElement, content: ISpotlightContent, options?: ISpotlightShowOptions): void;
+    /** Hide the current step while another target is being resolved. */
+    hide(): void;
     /** Recompute the hole and callout positions for the current target. */
     layout(): void;
     private _layoutBlocker;
@@ -83,13 +86,14 @@ export declare class SpotlightOverlay extends Disposable {
     private _trapFocus;
     /**
      * The focusable elements participating in the focus trap, in DOM order: the
-     * spotlighted target (when the step advances by pressing it), then any
+     * spotlighted target (when it is interactive or the Next button is hidden), then any
      * interactive content in the (possibly markdown) description, then the visible
      * action buttons. Including the target keeps the spotlighted control
      * keyboard-reachable, and querying the description keeps markdown links
      * reachable despite `aria-modal`.
      */
     private _collectFocusable;
+    private _isTabbable;
     scheduleLayout(): void;
     private _restoreFocus;
     dispose(): void;