@codingame/monaco-vscode-api 32.0.2 → 33.0.3

package/vscode/src/vs/platform/agentHost/common/state/protocol/actions.js

@@ -0,0 +1,59 @@
+
+
+var ActionType;
+(function (ActionType) {
+    ActionType["RootAgentsChanged"] = "root/agentsChanged";
+    ActionType["RootActiveSessionsChanged"] = "root/activeSessionsChanged";
+    ActionType["SessionReady"] = "session/ready";
+    ActionType["SessionCreationFailed"] = "session/creationFailed";
+    ActionType["SessionTurnStarted"] = "session/turnStarted";
+    ActionType["SessionDelta"] = "session/delta";
+    ActionType["SessionResponsePart"] = "session/responsePart";
+    ActionType["SessionToolCallStart"] = "session/toolCallStart";
+    ActionType["SessionToolCallDelta"] = "session/toolCallDelta";
+    ActionType["SessionToolCallReady"] = "session/toolCallReady";
+    ActionType["SessionToolCallConfirmed"] = "session/toolCallConfirmed";
+    ActionType["SessionToolCallComplete"] = "session/toolCallComplete";
+    ActionType["SessionToolCallResultConfirmed"] = "session/toolCallResultConfirmed";
+    ActionType["SessionToolCallContentChanged"] = "session/toolCallContentChanged";
+    ActionType["SessionTurnComplete"] = "session/turnComplete";
+    ActionType["SessionTurnCancelled"] = "session/turnCancelled";
+    ActionType["SessionError"] = "session/error";
+    ActionType["SessionTitleChanged"] = "session/titleChanged";
+    ActionType["SessionUsage"] = "session/usage";
+    ActionType["SessionReasoning"] = "session/reasoning";
+    ActionType["SessionModelChanged"] = "session/modelChanged";
+    ActionType["SessionServerToolsChanged"] = "session/serverToolsChanged";
+    ActionType["SessionActiveClientChanged"] = "session/activeClientChanged";
+    ActionType["SessionActiveClientToolsChanged"] = "session/activeClientToolsChanged";
+    ActionType["SessionPendingMessageSet"] = "session/pendingMessageSet";
+    ActionType["SessionPendingMessageRemoved"] = "session/pendingMessageRemoved";
+    ActionType["SessionQueuedMessagesReordered"] = "session/queuedMessagesReordered";
+    ActionType["SessionInputRequested"] = "session/inputRequested";
+    ActionType["SessionInputAnswerChanged"] = "session/inputAnswerChanged";
+    ActionType["SessionInputCompleted"] = "session/inputCompleted";
+    ActionType["SessionCustomizationsChanged"] = "session/customizationsChanged";
+    ActionType["SessionCustomizationToggled"] = "session/customizationToggled";
+    ActionType["SessionTruncated"] = "session/truncated";
+    ActionType["SessionIsReadChanged"] = "session/isReadChanged";
+    ActionType["SessionIsArchivedChanged"] = "session/isArchivedChanged";
+    ActionType["SessionActivityChanged"] = "session/activityChanged";
+    ActionType["SessionDiffsChanged"] = "session/diffsChanged";
+    ActionType["SessionConfigChanged"] = "session/configChanged";
+    ActionType["SessionMetaChanged"] = "session/metaChanged";
+    ActionType["RootTerminalsChanged"] = "root/terminalsChanged";
+    ActionType["RootConfigChanged"] = "root/configChanged";
+    ActionType["TerminalData"] = "terminal/data";
+    ActionType["TerminalInput"] = "terminal/input";
+    ActionType["TerminalResized"] = "terminal/resized";
+    ActionType["TerminalClaimed"] = "terminal/claimed";
+    ActionType["TerminalTitleChanged"] = "terminal/titleChanged";
+    ActionType["TerminalCwdChanged"] = "terminal/cwdChanged";
+    ActionType["TerminalExited"] = "terminal/exited";
+    ActionType["TerminalCleared"] = "terminal/cleared";
+    ActionType["TerminalCommandDetectionAvailable"] = "terminal/commandDetectionAvailable";
+    ActionType["TerminalCommandExecuted"] = "terminal/commandExecuted";
+    ActionType["TerminalCommandFinished"] = "terminal/commandFinished";
+})(ActionType || (ActionType = {}));
+
+export { ActionType };

package/vscode/src/vs/platform/agentHost/common/state/protocol/commands.d.ts

@@ -1,5 +1,5 @@
 import type { URI, Snapshot, SessionConfigSchema, SessionSummary, ModelSelection, Turn, TerminalClaim, SessionActiveClient, MessageAttachment } from "./state.js";
-import type { ActionEnvelope, StateAction } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+import type { ActionEnvelope, StateAction } from "./actions.js";
 export type { ConfigPropertySchema, ConfigSchema, SessionConfigPropertySchema, SessionConfigSchema } from "./state.js";
 /**
  * Establishes a new connection and negotiates the protocol version.
@@ -64,6 +64,22 @@ export interface InitializeResult {
      */
     completionTriggerCharacters?: string[];
 }
+/**
+ * Verifies that the AHP connection is still alive and keeps it from being
+ * closed by idle-timeout intermediaries (proxies, load balancers, etc.).
+ *
+ * The server MUST respond regardless of whether the client has completed
+ * `initialize` or holds any subscriptions. Ping carries no payload in either
+ * direction; the response itself is the signal.
+ *
+ * @category Commands
+ * @method ping
+ * @direction Client → Server
+ * @messageType Request
+ * @version 0.1.0
+ */
+export interface PingParams {
+}
 /**
  * Discriminant for reconnect result types.
  *

package/vscode/src/vs/platform/agentHost/common/state/protocol/messages.d.ts

@@ -1,5 +1,5 @@
-import type { InitializeParams, InitializeResult, ReconnectParams, ReconnectResult, SubscribeParams, SubscribeResult, CreateSessionParams, DisposeSessionParams, CreateTerminalParams, DisposeTerminalParams, ListSessionsParams, ListSessionsResult, ResourceReadParams, ResourceReadResult, ResourceWriteParams, ResourceWriteResult, ResourceListParams, ResourceListResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceMoveParams, ResourceMoveResult, ResourceRequestParams, ResourceRequestResult, FetchTurnsParams, FetchTurnsResult, UnsubscribeParams, DispatchActionParams, AuthenticateParams, AuthenticateResult, ResolveSessionConfigParams, ResolveSessionConfigResult, SessionConfigCompletionsParams, SessionConfigCompletionsResult, CompletionsParams, CompletionsResult } from "./commands.js";
-import type { ActionEnvelope } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+import type { InitializeParams, InitializeResult, PingParams, ReconnectParams, ReconnectResult, SubscribeParams, SubscribeResult, CreateSessionParams, DisposeSessionParams, CreateTerminalParams, DisposeTerminalParams, ListSessionsParams, ListSessionsResult, ResourceReadParams, ResourceReadResult, ResourceWriteParams, ResourceWriteResult, ResourceListParams, ResourceListResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceMoveParams, ResourceMoveResult, ResourceRequestParams, ResourceRequestResult, FetchTurnsParams, FetchTurnsResult, UnsubscribeParams, DispatchActionParams, AuthenticateParams, AuthenticateResult, ResolveSessionConfigParams, ResolveSessionConfigResult, SessionConfigCompletionsParams, SessionConfigCompletionsResult, CompletionsParams, CompletionsResult } from "./commands.js";
+import type { ActionEnvelope } from "./actions.js";
 import type { ProtocolNotification } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
 import type { AhpError } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/errors";
 /** A JSON-RPC request: has both `method` and `id`. */
@@ -57,6 +57,10 @@ export interface CommandMap {
         params: InitializeParams;
         result: InitializeResult;
     };
+    "ping": {
+        params: PingParams;
+        result: null;
+    };
     "reconnect": {
         params: ReconnectParams;
         result: ReconnectResult;

package/vscode/src/vs/platform/agentHost/common/state/protocol/state.d.ts

@@ -1644,6 +1644,11 @@ export interface UsageInfo {
     model?: string;
     /** Tokens read from cache */
     cacheReadTokens?: number;
+    /**
+     * Additional provider-specific metadata for this usage report.
+     * Clients MAY look for well-known optional keys here to provide enhanced UI.
+     */
+    _meta?: Record<string, unknown>;
 }
 /**
  * @category Common Types

package/vscode/src/vs/platform/agentHost/common/state/protocolUpgrade.d.ts

@@ -0,0 +1,73 @@
+import type { UnsupportedProtocolVersionErrorData } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/errors";
+/**
+ * Name of the JSON-RPC method that, when invoked on an agent host spawned
+ * by the VS Code CLI, asks the CLI to check for a server upgrade and
+ * restart the running server if a newer build is available.
+ *
+ * Servers advertise this method through {@link UnsupportedProtocolVersionErrorMeta.vscodeUpgradeMethod}
+ * in the `_meta` payload of an `UnsupportedProtocolVersion` error so the
+ * client can offer an "Update server" action without hard-coding the method
+ * name on the renderer side.
+ */
+export declare const VSCODE_UPGRADE_METHOD: "_vscodeUpgrade";
+/**
+ * Status payload returned by the {@link VSCODE_UPGRADE_METHOD} RPC. The
+ * agent host server forwards the CLI's `POST /upgrade` response back to
+ * the client unchanged, so the UI can describe what happened (e.g.
+ * "already on the latest version" vs "upgrade scheduled, please reconnect").
+ */
+export interface IVscodeUpgradeResult {
+    /** Whether the CLI accepted the request without an internal error. */
+    readonly ok: boolean;
+    /** Whether the running server is older than the latest known release. */
+    readonly upgradeNeeded?: boolean;
+    /**
+     * Whether the CLI committed to actually performing the upgrade. When
+     * `true`, the client SHOULD reconnect after at least
+     * {@link restartDelayMs} milliseconds; the existing transport will be
+     * torn down by the CLI.
+     */
+    readonly upgradeStarted?: boolean;
+    /** Commit of the currently running server, or `null` if no server is running. */
+    readonly runningCommit?: string | null;
+    /** Latest known release commit at the time of the call. */
+    readonly latestCommit?: string;
+    /**
+     * Milliseconds the client should wait before attempting to reconnect.
+     * The CLI deliberately delays the kill+restart so this HTTP response
+     * can drain back through the proxy first; reconnecting immediately
+     * would land on the still-running pre-upgrade server. Populated only
+     * when {@link upgradeStarted} is `true`.
+     */
+    readonly restartDelayMs?: number;
+    /** Human-readable error when {@link ok} is `false`. */
+    readonly error?: string;
+}
+/**
+ * Optional `_meta` side-channel on the `UnsupportedProtocolVersion` error
+ * data payload. Servers that are spawned by the VS Code CLI populate this
+ * to let the renderer offer a one-click upgrade flow; servers without a
+ * managing CLI omit it.
+ *
+ * The MCP `_meta` convention is followed: this is an open-ended record so
+ * future versions can carry additional fields without bumping the wire
+ * shape of the error.
+ */
+export interface UnsupportedProtocolVersionErrorMeta {
+    /**
+     * JSON-RPC method name the client MAY invoke on the same transport to
+     * ask the server to upgrade itself. Currently always {@link VSCODE_UPGRADE_METHOD}.
+     */
+    readonly vscodeUpgradeMethod?: string;
+}
+/**
+ * `UnsupportedProtocolVersionErrorData` augmented with the local `_meta`
+ * extension used by VS Code-hosted agent hosts.
+ *
+ * Kept out of the auto-generated `errors.ts` so the synced types stay
+ * untouched. Read at runtime as a best-effort field — older servers
+ * simply won't set it.
+ */
+export interface UnsupportedProtocolVersionErrorDataEx extends UnsupportedProtocolVersionErrorData {
+    readonly _meta?: UnsupportedProtocolVersionErrorMeta;
+}

package/vscode/src/vs/platform/agentHost/common/state/sessionState.d.ts

@@ -0,0 +1,139 @@
+import { URI as ResourceURI } from "../../../../base/common/uri.js";
+import { ToolResultFileEditContent, type ActiveTurn, type RootState, type SessionState, type SessionSummary, type ToolCallCancelledState, type ToolCallCompletedState, type ToolCallResult, type ToolCallState, type ToolResultContent, type ToolResultSubagentContent, type URI as ProtocolURI, type UserMessage, TerminalState } from "./protocol/state.js";
+export { type ActiveTurn, type AgentInfo, type ConfigPropertySchema, type ConfigSchema, type ContentRef, type ErrorInfo, type ProjectInfo, type MarkdownResponsePart, type MessageAttachment, type MessageResourceAttachment, type ReasoningResponsePart, type ResponsePart, type RootState, type SessionActiveClient, type SessionConfigState, type FileEdit as ISessionFileDiff, type ModelSelection, type SessionModelInfo, type SessionState, type SessionSummary, type Snapshot, type TerminalState, type ToolAnnotations, type ToolCallCancelledState, type ToolCallCompletedState, type ToolCallPendingConfirmationState, type ToolCallPendingResultConfirmationState, type ToolCallResponsePart, type ToolCallResult, type ToolCallRunningState, type ToolCallState, type ToolCallStreamingState, type ToolDefinition, type CustomizationRef, type SessionCustomization, type ToolResultEmbeddedResourceContent as IToolResultBinaryContent, type ToolResultContent, type ToolResultFileEditContent, type ToolResultSubagentContent, type ToolResultTextContent, type Turn, type UsageInfo, type UserMessage, type PendingMessage, type StringOrMarkdown, type URI, type SessionInputRequest, type SessionInputQuestion, type SessionInputAnswer, type SessionInputOption, CustomizationStatus, MessageAttachmentKind, PendingMessageKind, PolicyState, ResponsePartKind, SessionInputAnswerState, SessionInputAnswerValueKind, SessionInputQuestionKind, SessionInputResponseKind, SessionLifecycle, SessionStatus, ToolCallConfirmationReason, ToolCallCancellationReason, ToolCallStatus, ToolResultContentType, TurnState, } from "./protocol/state.js";
+/**
+ * The kind of file edit operation. Derived from the presence/absence of
+ * `before`/`after` in {@link ToolResultFileEditContent}.
+ */
+export declare enum FileEditKind {
+    /** Content edit (same file URI, different content). */
+    Edit = "edit",
+    /** File creation (no before state). */
+    Create = "create",
+    /** File deletion (no after state). */
+    Delete = "delete",
+    /** File rename/move (different before and after URIs). */
+    Rename = "rename"
+}
+/** URI for the root state subscription. */
+export declare const ROOT_STATE_URI = "agenthost:/root";
+/**
+ * A tool call in a terminal state, stored in completed turns.
+ */
+export type ICompletedToolCall = ToolCallCompletedState | ToolCallCancelledState;
+/**
+ * Derived status type for the tool call lifecycle.
+ */
+export type ToolCallStatusString = ToolCallState["status"];
+/**
+ * Extracts a plain-text tool output string from a tool call result's `content`
+ * array. Joins all text-type content parts into a single string.
+ *
+ * Returns `undefined` if there are no text content parts.
+ */
+export declare function getToolOutputText(result: ToolCallResult): string | undefined;
+/**
+ * Extracts file edit content entries from a tool call result's `content` array.
+ * Returns an empty array if there are no file edit content parts.
+ */
+export declare function getToolFileEdits(result: ToolCallResult): ToolResultFileEditContent[];
+/**
+ * Extracts the first subagent content entry from a tool call's `content` array.
+ * Works with both completed tool call results and running tool call states.
+ * Returns `undefined` if there are no subagent content parts.
+ */
+export declare function getToolSubagentContent(result: {
+    content?: readonly ToolResultContent[];
+}): ToolResultSubagentContent | undefined;
+/**
+ * Builds a subagent session URI from a parent session URI and tool call ID.
+ * Convention: `{parentSessionUri}/subagent/{toolCallId}`
+ */
+export declare function buildSubagentSessionUri(parentSession: ProtocolURI | ResourceURI, toolCallId: string): string;
+/**
+ * Parses a subagent session URI into its parent session URI and tool call ID.
+ * Returns `undefined` if the URI does not follow the subagent convention.
+ */
+export declare function parseSubagentSessionUri(uri: ProtocolURI | ResourceURI): {
+    parentSession: ResourceURI;
+    toolCallId: string;
+} | undefined;
+/**
+ * Returns whether a session URI represents a subagent session.
+ */
+export declare function isSubagentSession(uri: ProtocolURI | ResourceURI): boolean;
+/**
+ * Builds the string prefix used by the state manager for cached subagent sessions.
+ */
+export declare function buildSubagentSessionUriPrefix(parentSession: ProtocolURI | ResourceURI): string;
+export declare function createRootState(): RootState;
+export declare function createSessionState(summary: SessionSummary): SessionState;
+export declare function createActiveTurn(id: string, userMessage: UserMessage): ActiveTurn;
+export declare enum StateComponents {
+    Root = 0,
+    Session = 1,
+    Terminal = 2
+}
+export type ComponentToState = {
+    [StateComponents.Root]: RootState;
+    [StateComponents.Session]: SessionState;
+    [StateComponents.Terminal]: TerminalState;
+};
+/**
+ * VS Code-side alias for the protocol's open `_meta` property bag on
+ * {@link SessionState}. Keys SHOULD be namespaced (e.g. `git`, `vscode.foo`)
+ * to avoid collisions; values MUST be JSON-serializable.
+ */
+export type SessionMeta = Record<string, unknown>;
+/**
+ * Reserved key under {@link SessionMeta} for the well-known git-state
+ * payload. Value at this key, when present, MUST be shaped like
+ * {@link ISessionGitState}. This is a VS Code-specific convention layered
+ * on top of the protocol's generic `_meta` bag — the protocol itself does
+ * not know about git state.
+ */
+export declare const SESSION_META_GIT_KEY = "git";
+/**
+ * Git state of a session's working directory, carried under
+ * {@link SessionMeta} at {@link SESSION_META_GIT_KEY}. Used by clients to
+ * drive source-control affordances (e.g. PR/merge buttons in the Agents
+ * app).
+ *
+ * All fields are optional — agents that do not track a particular field
+ * should omit it rather than send a placeholder, so clients can distinguish
+ * "unknown" from "known to be zero".
+ */
+export interface ISessionGitState {
+    /** Whether the working directory has a `github.com` git remote. */
+    readonly hasGitHubRemote?: boolean;
+    /** Current branch name. */
+    readonly branchName?: string;
+    /** Base branch the work targets (e.g. `main`). */
+    readonly baseBranchName?: string;
+    /** Upstream tracking branch (e.g. `origin/feature`). */
+    readonly upstreamBranchName?: string;
+    /** Number of commits the upstream branch has ahead of the local branch. */
+    readonly incomingChanges?: number;
+    /** Number of commits the local branch has ahead of the upstream branch. */
+    readonly outgoingChanges?: number;
+    /** Number of files with uncommitted changes. */
+    readonly uncommittedChanges?: number;
+    /** GitHub repository owner parsed from the working copy's GitHub remote (preferring `origin`, falling back to the first GitHub remote). */
+    readonly githubOwner?: string;
+    /** GitHub repository name parsed from the working copy's GitHub remote (preferring `origin`, falling back to the first GitHub remote). */
+    readonly githubRepo?: string;
+}
+/**
+ * Reads the well-known git-state payload from {@link SessionMeta}, if
+ * present. Returns `undefined` when the meta bag is absent or the value at
+ * the git key is not a plain object (e.g. an array or a primitive).
+ * Individual fields with wrong types are silently dropped so partial state
+ * still propagates.
+ */
+export declare function readSessionGitState(meta: SessionMeta | undefined): ISessionGitState | undefined;
+/**
+ * Returns a new {@link SessionMeta} with the git-state payload set to
+ * `gitState`, or with the git slot removed if `gitState` is `undefined`.
+ * Returns `undefined` if the result would be empty.
+ */
+export declare function withSessionGitState(meta: SessionMeta | undefined, gitState: ISessionGitState | undefined): SessionMeta | undefined;

package/vscode/src/vs/platform/agentHost/common/state/sessionState.js

@@ -0,0 +1,24 @@
+
+import '../../../../base/common/errors.js';
+import '../../../../base/common/charCode.js';
+import '../../../../base/common/marshallingIds.js';
+import '../../../../base/common/path.js';
+import '../../../../base/common/platform.js';
+export { CustomizationStatus, MessageAttachmentKind, PendingMessageKind, PolicyState, ResponsePartKind, SessionInputAnswerState, SessionInputAnswerValueKind, SessionInputQuestionKind, SessionInputResponseKind, SessionLifecycle, SessionStatus, ToolCallCancellationReason, ToolCallConfirmationReason, ToolCallStatus, ToolResultContentType, TurnState } from './protocol/state.js';
+
+var FileEditKind;
+(function(FileEditKind) {
+    FileEditKind["Edit"] = "edit";
+    FileEditKind["Create"] = "create";
+    FileEditKind["Delete"] = "delete";
+    FileEditKind["Rename"] = "rename";
+})(FileEditKind || (FileEditKind = {}));
+const ROOT_STATE_URI = "agenthost:/root";
+var StateComponents;
+(function(StateComponents) {
+    StateComponents[StateComponents["Root"] = 0] = "Root";
+    StateComponents[StateComponents["Session"] = 1] = "Session";
+    StateComponents[StateComponents["Terminal"] = 2] = "Terminal";
+})(StateComponents || (StateComponents = {}));
+
+export { FileEditKind, ROOT_STATE_URI, StateComponents };

package/vscode/src/vs/platform/browserView/common/browserView.d.ts

@@ -2,6 +2,7 @@ import { Event } from "../../../base/common/event.js";
 import { VSBuffer } from "../../../base/common/buffer.js";
 export declare enum BrowserViewCommandId {
     Open = "workbench.action.browser.open",
+    OpenFile = "workbench.action.browser.openFile",
     NewTab = "workbench.action.browser.newTab",
     QuickOpen = "workbench.action.browser.quickOpen",
     OpenOrList = "workbench.action.browser.openOrList",
@@ -51,6 +52,15 @@ export interface IElementData {
     };
     readonly innerText?: string;
 }
+export interface IBrowserViewTheme {
+    readonly focusBorder?: string;
+    readonly buttonBackground?: string;
+    readonly buttonForeground?: string;
+    readonly font?: string;
+}
+export interface IBrowserViewConfiguration {
+    readonly aiFeaturesDisabled?: boolean;
+}
 export interface IBrowserViewBounds {
     windowId: number;
     x: number;
@@ -420,6 +430,11 @@ export interface IBrowserViewService {
      * @param enabled Whether to enable or disable. Omit to toggle.
      */
     toggleElementSelection(id: string, enabled?: boolean): Promise<void>;
+    /**
+     * Update the theme used by injected UI across all browser views.
+     * @param theme The theme variables to apply
+     */
+    updateTheme(theme: IBrowserViewTheme): Promise<void>;
     /**
      * Update the keybinding accelerators used in browser view context menus.
      * @param keybindings A map of command ID to accelerator label
@@ -427,4 +442,9 @@ export interface IBrowserViewService {
     updateKeybindings(keybindings: {
         [commandId: string]: string;
     }): Promise<void>;
+    /**
+     * Update workbench configuration that affect browser view behavior.
+     * @param config The configuration to apply
+     */
+    updateConfiguration(config: IBrowserViewConfiguration): Promise<void>;
 }

package/vscode/src/vs/platform/browserView/common/browserView.js

@@ -4,6 +4,7 @@ import '../../../nls.js';
 var BrowserViewCommandId;
 (function(BrowserViewCommandId) {
     BrowserViewCommandId["Open"] = "workbench.action.browser.open";
+    BrowserViewCommandId["OpenFile"] = "workbench.action.browser.openFile";
     BrowserViewCommandId["NewTab"] = "workbench.action.browser.newTab";
     BrowserViewCommandId["QuickOpen"] = "workbench.action.browser.quickOpen";
     BrowserViewCommandId["OpenOrList"] = "workbench.action.browser.openOrList";

package/vscode/src/vs/platform/browserView/common/browserViewTelemetry.d.ts

@@ -31,5 +31,7 @@ export type IntegratedBrowserOpenSource =
  * (e.g., Shift+click). */
  | "browserLinkNewWindow"
 /** Opened when the user copies a browser editor to a new window via "Copy into New Window". */
- | "copyToNewWindow";
+ | "copyToNewWindow"
+/** Opened via the "Open in Integrated Browser" command for a local file. */
+ | "openFileCommand";
 export declare function logBrowserOpen(telemetryService: ITelemetryService, source: IntegratedBrowserOpenSource): void;

package/vscode/src/vs/platform/configuration/common/configuration.js

@@ -129,7 +129,7 @@ function doRemoveFromValueTree(valueTree, segments) {
     }
     if (( Object.keys(valueTreeRecord)).indexOf(first) !== -1) {
         const value = valueTreeRecord[first];
-        if (typeof value === "object" && !Array.isArray(value)) {
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
             doRemoveFromValueTree(value, segments);
             if (( Object.keys(value)).length === 0) {
                 delete valueTreeRecord[first];

package/vscode/src/vs/platform/configuration/common/configurationRegistry.js

@@ -82,7 +82,7 @@ class ConfigurationRegistry extends Disposable {
         this.configurationDefaultsOverrides = ( new Map());
         this.defaultLanguageConfigurationOverridesNode = {
             id: "defaultOverrides",
-            title: ( localize(1819, "Default Language Configuration Overrides")),
+            title: ( localize(1841, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -283,7 +283,7 @@ class ConfigurationRegistry extends Disposable {
             type: "object",
             default: newDefaultOverride.value,
             description: ( localize(
-                1820,
+                1842,
                 "Configure settings to be overridden for {0}.",
                 getLanguageTagSettingPlainKey(key)
             )),
@@ -601,8 +601,8 @@ class ConfigurationRegistry extends Disposable {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: "object",
-                description: ( localize(1821, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localize(1822, "This setting does not support per-language configuration.")),
+                description: ( localize(1843, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(1844, "This setting does not support per-language configuration.")),
                 $ref: resourceLanguageSettingsSchemaId
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -618,8 +618,8 @@ class ConfigurationRegistry extends Disposable {
     registerOverridePropertyPatternKey() {
         const resourceLanguagePropertiesSchema = {
             type: "object",
-            description: ( localize(1821, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localize(1822, "This setting does not support per-language configuration.")),
+            description: ( localize(1843, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(1844, "This setting does not support per-language configuration.")),
             $ref: resourceLanguageSettingsSchemaId
         };
         allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
@@ -694,25 +694,25 @@ const configurationRegistry = ( new ConfigurationRegistry());
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema, extensionId) {
     if (!property.trim()) {
-        return localize(1823, "Cannot register an empty property");
+        return localize(1845, "Cannot register an empty property");
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return localize(
-            1824,
+            1846,
             "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
             property
         );
     }
     if (configurationRegistry.getConfigurationProperties()[property] !== undefined && (!extensionId || !( EXTENSION_UNIFICATION_EXTENSION_IDS.has(extensionId.toLowerCase())))) {
         return localize(
-            1825,
+            1847,
             "Cannot register '{0}'. This property is already registered.",
             property
         );
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return localize(
-            1826,
+            1848,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,

package/vscode/src/vs/platform/contextkey/browser/contextKeyService.js

@@ -533,7 +533,7 @@ CommandsRegistry.registerCommand({
         return [...RawContextKey.all()].sort((a, b) => a.key.localeCompare(b.key));
     },
     metadata: {
-        description: ( localize(1827, "A command that returns information about context keys")),
+        description: ( localize(1849, "A command that returns information about context keys")),
         args: []
     }
 });

package/vscode/src/vs/platform/contextkey/common/contextkey.js

@@ -47,17 +47,17 @@ var ContextKeyExprType;
 const defaultConfig = {
     regexParsingWithErrorRecovery: true
 };
-const errorEmptyString = ( localize(1828, "Empty context key expression"));
+const errorEmptyString = ( localize(1850, "Empty context key expression"));
 const hintEmptyString = ( localize(
-    1829,
+    1851,
     "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively."
 ));
-const errorNoInAfterNot = ( localize(1830, "'in' after 'not'."));
-const errorClosingParenthesis = ( localize(1831, "closing parenthesis ')'"));
-const errorUnexpectedToken = ( localize(1832, "Unexpected token"));
-const hintUnexpectedToken = ( localize(1833, "Did you forget to put && or || before the token?"));
-const errorUnexpectedEOF = ( localize(1834, "Unexpected end of expression"));
-const hintUnexpectedEOF = ( localize(1835, "Did you forget to put a context key?"));
+const errorNoInAfterNot = ( localize(1852, "'in' after 'not'."));
+const errorClosingParenthesis = ( localize(1853, "closing parenthesis ')'"));
+const errorUnexpectedToken = ( localize(1854, "Unexpected token"));
+const hintUnexpectedToken = ( localize(1855, "Did you forget to put && or || before the token?"));
+const errorUnexpectedEOF = ( localize(1856, "Unexpected end of expression"));
+const hintUnexpectedEOF = ( localize(1857, "Did you forget to put a context key?"));
 class Parser {
     static {
         this._parseError = ( new Error());
@@ -391,7 +391,7 @@ class Parser {
         throw this._errExpectedButGot(message, this._peek());
     }
     _errExpectedButGot(expected, got, additionalInfo) {
-        const message = ( localize(1836, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
+        const message = ( localize(1858, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
         const offset = got.offset;
         const lexeme = Scanner.getLexeme(got);
         this._parsingErrors.push({
@@ -479,7 +479,7 @@ function validateWhenClauses(whenClauses) {
         parser.parse(whenClause);
         if (parser.lexingErrors.length > 0) {
             return (parser.lexingErrors.map(se => ({
-                errorMessage: se.additionalInfo ? ( localize(1837, "Unexpected token. Hint: {0}", se.additionalInfo)) : ( localize(1838, "Unexpected token.")),
+                errorMessage: se.additionalInfo ? ( localize(1859, "Unexpected token. Hint: {0}", se.additionalInfo)) : ( localize(1860, "Unexpected token.")),
                 offset: se.offset,
                 length: se.lexeme.length
             })));

package/vscode/src/vs/platform/contextkey/common/contextkeys.js

@@ -3,16 +3,16 @@ import { isMacintosh, isLinux, isWindows, isWeb, isIOS, isMobile } from '../../.
 import { localize } from '../../../nls.js';
 import { RawContextKey } from './contextkey.js';
 
-const IsMacContext = ( new RawContextKey("isMac", isMacintosh, ( localize(1839, "Whether the operating system is macOS"))));
-const IsLinuxContext = ( new RawContextKey("isLinux", isLinux, ( localize(1840, "Whether the operating system is Linux"))));
-const IsWindowsContext = ( new RawContextKey("isWindows", isWindows, ( localize(1841, "Whether the operating system is Windows"))));
-const IsWebContext = ( new RawContextKey("isWeb", isWeb, ( localize(1842, "Whether the platform is a web browser"))));
-const IsMacNativeContext = ( new RawContextKey("isMacNative", isMacintosh && !isWeb, ( localize(1843, "Whether the operating system is macOS on a non-browser platform"))));
-const IsIOSContext = ( new RawContextKey("isIOS", isIOS, ( localize(1844, "Whether the operating system is iOS"))));
-const IsMobileContext = ( new RawContextKey("isMobile", isMobile, ( localize(1845, "Whether the platform is a mobile web browser"))));
+const IsMacContext = ( new RawContextKey("isMac", isMacintosh, ( localize(1861, "Whether the operating system is macOS"))));
+const IsLinuxContext = ( new RawContextKey("isLinux", isLinux, ( localize(1862, "Whether the operating system is Linux"))));
+const IsWindowsContext = ( new RawContextKey("isWindows", isWindows, ( localize(1863, "Whether the operating system is Windows"))));
+const IsWebContext = ( new RawContextKey("isWeb", isWeb, ( localize(1864, "Whether the platform is a web browser"))));
+const IsMacNativeContext = ( new RawContextKey("isMacNative", isMacintosh && !isWeb, ( localize(1865, "Whether the operating system is macOS on a non-browser platform"))));
+const IsIOSContext = ( new RawContextKey("isIOS", isIOS, ( localize(1866, "Whether the operating system is iOS"))));
+const IsMobileContext = ( new RawContextKey("isMobile", isMobile, ( localize(1867, "Whether the platform is a mobile web browser"))));
 const IsDevelopmentContext = ( new RawContextKey("isDevelopment", false, true));
-const ProductQualityContext = ( new RawContextKey("productQualityType", "", ( localize(1846, "Quality type of VS Code"))));
+const ProductQualityContext = ( new RawContextKey("productQualityType", "", ( localize(1868, "Quality type of VS Code"))));
 const InputFocusedContextKey = "inputFocus";
-const InputFocusedContext = ( new RawContextKey(InputFocusedContextKey, false, ( localize(1847, "Whether keyboard focus is inside an input box"))));
+const InputFocusedContext = ( new RawContextKey(InputFocusedContextKey, false, ( localize(1869, "Whether keyboard focus is inside an input box"))));
 
 export { InputFocusedContext, InputFocusedContextKey, IsDevelopmentContext, IsIOSContext, IsLinuxContext, IsMacContext, IsMacNativeContext, IsMobileContext, IsWebContext, IsWindowsContext, ProductQualityContext };

package/vscode/src/vs/platform/contextkey/common/scanner.js

@@ -30,18 +30,18 @@ var TokenType;
 function hintDidYouMean(...meant) {
     switch (meant.length) {
     case 1:
-        return localize(1848, "Did you mean {0}?", meant[0]);
+        return localize(1870, "Did you mean {0}?", meant[0]);
     case 2:
-        return localize(1849, "Did you mean {0} or {1}?", meant[0], meant[1]);
+        return localize(1871, "Did you mean {0} or {1}?", meant[0], meant[1]);
     case 3:
-        return localize(1850, "Did you mean {0}, {1} or {2}?", meant[0], meant[1], meant[2]);
+        return localize(1872, "Did you mean {0}, {1} or {2}?", meant[0], meant[1], meant[2]);
     default:
         return undefined;
     }
 }
-const hintDidYouForgetToOpenOrCloseQuote = ( localize(1851, "Did you forget to open or close the quote?"));
+const hintDidYouForgetToOpenOrCloseQuote = ( localize(1873, "Did you forget to open or close the quote?"));
 const hintDidYouForgetToEscapeSlash = ( localize(
-    1852,
+    1874,
     "Did you forget to escape the '/' (slash) character? Put two backslashes before it to escape, e.g., '\\\\/'."
 ));
 class Scanner {