@codingame/monaco-vscode-api 30.0.1 → 31.0.1

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

@@ -0,0 +1,234 @@
+import type { IInitializeParams, IInitializeResult, IReconnectParams, IReconnectResult, ISubscribeParams, ISubscribeResult, ICreateSessionParams, IDisposeSessionParams, ICreateTerminalParams, IDisposeTerminalParams, IListSessionsParams, IListSessionsResult, IResourceReadParams, IResourceReadResult, IResourceWriteParams, IResourceWriteResult, IResourceListParams, IResourceListResult, IResourceCopyParams, IResourceCopyResult, IResourceDeleteParams, IResourceDeleteResult, IResourceMoveParams, IResourceMoveResult, IFetchTurnsParams, IFetchTurnsResult, IUnsubscribeParams, IDispatchActionParams, IAuthenticateParams, IAuthenticateResult, IResolveSessionConfigParams, IResolveSessionConfigResult, ISessionConfigCompletionsParams, ISessionConfigCompletionsResult } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import type { IActionEnvelope } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+import type { IProtocolNotification } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
+/** A JSON-RPC request: has both `method` and `id`. */
+export interface IJsonRpcRequest {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly method: string;
+    readonly params?: unknown;
+}
+/** A JSON-RPC success response. */
+export interface IJsonRpcSuccessResponse {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly result: unknown;
+}
+/** A JSON-RPC error response. */
+export interface IJsonRpcErrorResponse {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly error: {
+        readonly code: number;
+        readonly message: string;
+        readonly data?: unknown;
+    };
+}
+/** A JSON-RPC response (success or error). */
+export type IJsonRpcResponse = IJsonRpcSuccessResponse | IJsonRpcErrorResponse;
+/** A JSON-RPC notification: has `method` but no `id`. */
+export interface IJsonRpcNotification {
+    readonly jsonrpc: "2.0";
+    readonly method: string;
+    readonly params?: unknown;
+}
+/**
+ * Registry mapping each command method name to its params and result types.
+ *
+ * @category Commands
+ */
+export interface ICommandMap {
+    "initialize": {
+        params: IInitializeParams;
+        result: IInitializeResult;
+    };
+    "reconnect": {
+        params: IReconnectParams;
+        result: IReconnectResult;
+    };
+    "subscribe": {
+        params: ISubscribeParams;
+        result: ISubscribeResult;
+    };
+    "createSession": {
+        params: ICreateSessionParams;
+        result: null;
+    };
+    "disposeSession": {
+        params: IDisposeSessionParams;
+        result: null;
+    };
+    "createTerminal": {
+        params: ICreateTerminalParams;
+        result: null;
+    };
+    "disposeTerminal": {
+        params: IDisposeTerminalParams;
+        result: null;
+    };
+    "listSessions": {
+        params: IListSessionsParams;
+        result: IListSessionsResult;
+    };
+    "resourceRead": {
+        params: IResourceReadParams;
+        result: IResourceReadResult;
+    };
+    "resourceWrite": {
+        params: IResourceWriteParams;
+        result: IResourceWriteResult;
+    };
+    "resourceList": {
+        params: IResourceListParams;
+        result: IResourceListResult;
+    };
+    "resourceCopy": {
+        params: IResourceCopyParams;
+        result: IResourceCopyResult;
+    };
+    "resourceDelete": {
+        params: IResourceDeleteParams;
+        result: IResourceDeleteResult;
+    };
+    "resourceMove": {
+        params: IResourceMoveParams;
+        result: IResourceMoveResult;
+    };
+    "fetchTurns": {
+        params: IFetchTurnsParams;
+        result: IFetchTurnsResult;
+    };
+    "authenticate": {
+        params: IAuthenticateParams;
+        result: IAuthenticateResult;
+    };
+    "resolveSessionConfig": {
+        params: IResolveSessionConfigParams;
+        result: IResolveSessionConfigResult;
+    };
+    "sessionConfigCompletions": {
+        params: ISessionConfigCompletionsParams;
+        result: ISessionConfigCompletionsResult;
+    };
+}
+/** Params for the server → client `notification` method. */
+export interface INotificationMethodParams {
+    notification: IProtocolNotification;
+}
+/**
+ * Registry mapping each client → server notification method to its params type.
+ *
+ * @category Notifications
+ */
+export interface IClientNotificationMap {
+    "unsubscribe": {
+        params: IUnsubscribeParams;
+    };
+    "dispatchAction": {
+        params: IDispatchActionParams;
+    };
+}
+/**
+ * Registry mapping each server → client notification method to its params type.
+ *
+ * @category Notifications
+ */
+export interface IServerNotificationMap {
+    "action": {
+        params: IActionEnvelope;
+    };
+    "notification": {
+        params: INotificationMethodParams;
+    };
+}
+/** Combined notification map for all directions. */
+export type INotificationMap = IClientNotificationMap & IServerNotificationMap;
+/**
+ * A fully typed JSON-RPC request for a specific AHP command.
+ *
+ * When used as a union (default generic), narrowing on `method` gives typed `params`:
+ *
+ * ```ts
+ * function handle(req: IAhpRequest) {
+ *   if (req.method === 'fetchTurns') {
+ *     req.params.session; // typed as URI
+ *   }
+ * }
+ * ```
+ */
+export type IAhpRequest<M extends keyof ICommandMap = keyof ICommandMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly method: M;
+    readonly params: ICommandMap[M]["params"];
+} : never;
+/**
+ * A fully typed JSON-RPC success response for a specific AHP command.
+ *
+ * Since JSON-RPC responses do not carry `method`, use this with an explicit
+ * generic parameter when you know the method from the associated request:
+ *
+ * ```ts
+ * const result: IAhpSuccessResponse<'fetchTurns'> = ...;
+ * result.result.turns; // typed as ITurn[]
+ * ```
+ */
+export type IAhpSuccessResponse<M extends keyof ICommandMap = keyof ICommandMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly result: ICommandMap[M]["result"];
+} : never;
+/** Typed JSON-RPC response (success with known result type, or error). */
+export type IAhpResponse<M extends keyof ICommandMap = keyof ICommandMap> = IAhpSuccessResponse<M> | IJsonRpcErrorResponse;
+/**
+ * A fully typed JSON-RPC notification for a specific AHP notification method.
+ *
+ * When used as a union (default generic), narrowing on `method` gives typed `params`:
+ *
+ * ```ts
+ * function handle(notif: IAhpNotification) {
+ *   if (notif.method === 'action') {
+ *     notif.params.serverSeq; // typed as number
+ *   }
+ * }
+ * ```
+ */
+export type IAhpNotification<M extends keyof INotificationMap = keyof INotificationMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly method: M;
+    readonly params: INotificationMap[M]["params"];
+} : never;
+/** A client → server notification. */
+export type IAhpClientNotification<M extends keyof IClientNotificationMap = keyof IClientNotificationMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly method: M;
+    readonly params: IClientNotificationMap[M]["params"];
+} : never;
+/** A server → client notification. */
+export type IAhpServerNotification<M extends keyof IServerNotificationMap = keyof IServerNotificationMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly method: M;
+    readonly params: IServerNotificationMap[M]["params"];
+} : never;
+/**
+ * Discriminated union of all AHP protocol messages.
+ *
+ * Narrow using standard JSON-RPC structure:
+ * - Has `method` + `id` → request ({@link IAhpRequest})
+ * - Has `method`, no `id` → notification ({@link IAhpNotification})
+ * - Has `result` or `error` + `id` → response ({@link IAhpResponse})
+ *
+ * Then narrow on `method` for fully typed params:
+ *
+ * ```ts
+ * function dispatch(msg: IProtocolMessage) {
+ *   if ('method' in msg && 'id' in msg) {
+ *     // msg is IAhpRequest
+ *     if (msg.method === 'fetchTurns') {
+ *       msg.params.session; // URI
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export type IProtocolMessage = IAhpRequest | IAhpSuccessResponse | IJsonRpcErrorResponse | IAhpNotification;

package/vscode/src/vs/platform/agentHost/common/tunnelAgentHost.d.ts

@@ -0,0 +1,91 @@
+/**
+ * IPC channel name for the shared-process tunnel service.
+ */
+export declare const TUNNEL_AGENT_HOST_CHANNEL = "tunnelAgentHost";
+/** Configuration key for the list of manually configured tunnel names. */
+export declare const TunnelAgentHostsSettingId = "chat.remoteAgentTunnels";
+/** Minimum protocol version required for agent host connections. */
+export declare const TUNNEL_MIN_PROTOCOL_VERSION = 5;
+/** Well-known port for the agent host on tunnel machines. */
+export declare const TUNNEL_AGENT_HOST_PORT = 31546;
+/** Label used to identify VS Code server launcher tunnels. */
+export declare const TUNNEL_LAUNCHER_LABEL = "vscode-server-launcher";
+/** Address prefix for tunnel-backed connections (e.g. `tunnel:myTunnelId`). */
+export declare const TUNNEL_ADDRESS_PREFIX = "tunnel:";
+/** Prefix for protocol version tags. */
+export declare const PROTOCOL_VERSION_TAG_PREFIX = "protocolv";
+/**
+ * Parse tunnel tags to extract display name and protocol version.
+ * Follows the convention from the vscode-remote-tunnels SDK: the
+ * first label that is not `vscode-server-launcher`, does not start
+ * with `_`, and is not a `protocolvN` tag is the display name.
+ */
+export declare class TunnelTags {
+    readonly value: readonly string[] | undefined;
+    readonly protocolVersion: number;
+    readonly name: string | undefined;
+    constructor(value: readonly string[] | undefined);
+}
+/** A recently used tunnel cached in storage. */
+export interface ICachedTunnel {
+    readonly tunnelId: string;
+    readonly clusterId: string;
+    readonly name: string;
+    readonly authProvider?: "github" | "microsoft";
+}
+/** Information about a discovered dev tunnel with an agent host. */
+export interface ITunnelInfo {
+    /** The tunnel's unique identifier. */
+    readonly tunnelId: string;
+    /** The cluster region where the tunnel is hosted. */
+    readonly clusterId: string;
+    /** Display name derived from tunnel tags or tunnel name. */
+    readonly name: string;
+    /** All tags/labels on the tunnel. */
+    readonly tags: readonly string[];
+    /** Parsed protocol version from tags. */
+    readonly protocolVersion: number;
+    /** Number of hosts currently accepting connections (0 = offline). */
+    readonly hostConnectionCount: number;
+}
+/**
+ * Serializable result from a successful tunnel connect operation.
+ * Returned over IPC from the shared process.
+ */
+export interface ITunnelConnectResult {
+    /** Unique identifier for this connection's relay channel. */
+    readonly connectionId: string;
+    /** Display-friendly address (e.g. "tunnel:myTunnel"). */
+    readonly address: string;
+    /** Display name for the tunnel. */
+    readonly name: string;
+    /** Connection token derived from the tunnel ID. */
+    readonly connectionToken: string;
+}
+/**
+ * A message relayed from a remote agent host through the tunnel.
+ * The shared process acts as a WebSocket proxy, forwarding JSON
+ * messages bidirectionally between the tunnel and the renderer via IPC.
+ */
+export interface ITunnelRelayMessage {
+    readonly connectionId: string;
+    readonly data: string;
+}
+/** IPC channel name for the tunnel host service. */
+export declare const TUNNEL_HOST_CHANNEL = "tunnelHost";
+/** Output channel ID for the tunnel host logs. */
+export declare const TUNNEL_HOST_LOG_ID = "tunnelHostService";
+/** Information about an actively hosted tunnel. */
+export interface ITunnelHostInfo {
+    readonly tunnelName: string;
+    readonly tunnelId: string;
+    readonly clusterId: string;
+    readonly domain: string;
+}
+/** Status of the tunnel host. */
+export type TunnelHostStatus = {
+    readonly active: false;
+} | {
+    readonly active: true;
+    readonly info: ITunnelHostInfo;
+};

package/vscode/src/vs/platform/agentHost/common/tunnelAgentHost.js

@@ -0,0 +1,5 @@
+
+
+const TUNNEL_ADDRESS_PREFIX = 'tunnel:';
+
+export { TUNNEL_ADDRESS_PREFIX };

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

@@ -1,7 +1,6 @@
 import { Event } from "../../../base/common/event.js";
 import { VSBuffer } from "../../../base/common/buffer.js";
 import { UriComponents } from "../../../base/common/uri.js";
-import { IElementData } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/browserElements/common/browserElements";
 export declare enum BrowserViewCommandId {
     Open = "workbench.action.browser.open",
     NewTab = "workbench.action.browser.newTab",
@@ -26,6 +25,32 @@ export declare enum BrowserViewCommandId {
     FindNext = "workbench.action.browser.findNext",
     FindPrevious = "workbench.action.browser.findPrevious"
 }
+export interface IElementAncestor {
+    readonly tagName: string;
+    readonly id?: string;
+    readonly classNames?: string[];
+}
+export interface IElementData {
+    readonly url?: string;
+    readonly outerHTML: string;
+    readonly computedStyle: string;
+    readonly bounds: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly ancestors?: IElementAncestor[];
+    readonly attributes?: Record<string, string>;
+    readonly computedStyles?: Record<string, string>;
+    readonly dimensions?: {
+        readonly top: number;
+        readonly left: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly innerText?: string;
+}
 export interface IBrowserViewBounds {
     windowId: number;
     x: number;
@@ -285,8 +310,9 @@ export interface IBrowserViewService {
     /**
      * Focus the browser view
      * @param id The browser view identifier
+     * @param force Whether to force focus even if the view's window is not focused.
      */
-    focus(id: string): Promise<void>;
+    focus(id: string, force?: boolean): Promise<void>;
     /**
      * Find text in the browser view's page
      * @param id The browser view identifier

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

@@ -0,0 +1,34 @@
+import { ITelemetryService } from "../../telemetry/common/telemetry.service.js";
+/** Source of an Integrated Browser open event. */
+export type IntegratedBrowserOpenSource = 
+/** Created via CDP, such as by the agent using Playwright tools. */
+"cdpCreated"
+/** Opened via a (non-agentic) chat tool invocation. */
+ | "chatTool"
+/** Opened via the "Open Integrated Browser" command without a URL argument.
+ * This typically means the user ran the command manually from the Command Palette. */
+ | "commandWithoutUrl"
+/** Opened via the "Open Integrated Browser" command with a URL argument.
+ * This typically means another extension or component invoked the command programmatically. */
+ | "commandWithUrl"
+/** Opened via the quick open feature with no initial URL. */
+ | "quickOpenWithoutUrl"
+/** Opened via the quick open feature with an initial URL. */
+ | "quickOpenWithUrl"
+/** Opened via the "New Tab" command from an existing tab. */
+ | "newTabCommand"
+/** Opened via the localhost link opener when the `workbench.browser.openLocalhostLinks` setting
+ * is enabled. This happens when clicking localhost links from the terminal, chat, or other sources. */
+ | "localhostLinkOpener"
+/** Opened when clicking a link inside the Integrated Browser that opens in a new focused editor
+ * (e.g., links with target="_blank"). */
+ | "browserLinkForeground"
+/** Opened when clicking a link inside the Integrated Browser that opens in a new background editor
+ * (e.g., Ctrl/Cmd+click). */
+ | "browserLinkBackground"
+/** Opened when clicking a link inside the Integrated Browser that opens in a new window
+ * (e.g., Shift+click). */
+ | "browserLinkNewWindow"
+/** Opened when the user copies a browser editor to a new window via "Copy into New Window". */
+ | "copyToNewWindow";
+export declare function logBrowserOpen(telemetryService: ITelemetryService, source: IntegratedBrowserOpenSource): void;

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

@@ -0,0 +1,7 @@
+
+
+function logBrowserOpen(telemetryService, source) {
+    telemetryService.publicLog2('integratedBrowser.open', { source });
+}
+
+export { logBrowserOpen };

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

@@ -0,0 +1,21 @@
+import { URI } from "../../../base/common/uri.js";
+/**
+ * Helper for creating and parsing browser view URIs.
+ */
+export declare namespace BrowserViewUri {
+    const scheme = "vscode-browser";
+    /**
+     * Creates a resource URI for a browser view with the given ID.
+     */
+    function forId(id: string): URI;
+    /**
+     * Parses a browser view resource URI to extract the ID.
+     */
+    function parse(resource: URI): {
+        id: string;
+    } | undefined;
+    /**
+     * Extracts the ID from a browser view resource URI.
+     */
+    function getId(resource: URI): string | undefined;
+}

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

@@ -0,0 +1,34 @@
+
+import { Schemas } from '../../../base/common/network.js';
+import { URI } from '../../../base/common/uri.js';
+
+var BrowserViewUri;
+(function(BrowserViewUri) {
+    BrowserViewUri.scheme = Schemas.vscodeBrowser;
+    function forId(id) {
+        return ( URI.from({
+            scheme: BrowserViewUri.scheme,
+            path: `/${id}`
+        }));
+    }
+    BrowserViewUri.forId = forId;
+    function parse(resource) {
+        if (resource.scheme !== BrowserViewUri.scheme) {
+            return undefined;
+        }
+        const id = resource.path.startsWith("/") ? resource.path.substring(1) : resource.path;
+        if (!id) {
+            return undefined;
+        }
+        return {
+            id
+        };
+    }
+    BrowserViewUri.parse = parse;
+    function getId(resource) {
+        return parse(resource)?.id;
+    }
+    BrowserViewUri.getId = getId;
+})(BrowserViewUri || (BrowserViewUri = {}));
+
+export { BrowserViewUri };

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

@@ -94,20 +94,29 @@ export interface CDPWindowBounds {
  * A debuggable CDP target (e.g., a browser view).
  * Targets can be attached to by CDP clients.
  */
-export interface ICDPTarget {
-    /** Get target info for CDP protocol. Initializes the target if needed. */
-    getTargetInfo(): Promise<CDPTargetInfo>;
-    /** Attach to receive events and send commands. Initializes if needed. Dispose to detach. */
+export interface ICDPTarget extends IDisposable {
+    /** Get target info for CDP protocol. */
+    targetInfo: CDPTargetInfo;
+    /** Fired when target info changes. */
+    readonly onTargetInfoChanged: Event<CDPTargetInfo>;
+    /** Attach to receive events and send commands. Dispose to detach. */
     attach(): Promise<ICDPConnection>;
+    /** All active sessions on this target. */
+    readonly sessions: ReadonlyMap<string, ICDPConnection>;
+    /** Fired when a new session is created on this target. */
+    readonly onSessionCreated: Event<{
+        session: ICDPConnection;
+        waitingForDebugger: boolean;
+    }>;
+    /** Can be called to notify the target that a new session has been created for it. */
+    notifySessionCreated(session: ICDPConnection, waitingForDebugger: boolean): void;
+    /** Fired when this target is closed or disposed. */
+    readonly onClose: Event<void>;
 }
 /**
  * Service interface for managing CDP targets and browser contexts.
  */
 export interface ICDPBrowserTarget extends ICDPTarget {
-    /** Event fired when a target is created */
-    readonly onTargetCreated: Event<ICDPTarget>;
-    /** Event fired when a target is about to be destroyed */
-    readonly onTargetDestroyed: Event<ICDPTarget>;
     /** Get browser version info for CDP Browser.getVersion */
     getVersion(): CDPBrowserVersion;
     /** Get the window ID and bounds for a target */
@@ -115,8 +124,6 @@ export interface ICDPBrowserTarget extends ICDPTarget {
         windowId: number;
         bounds: CDPWindowBounds;
     };
-    /** Get all available targets */
-    getTargets(): IterableIterator<ICDPTarget>;
     /** Create a new target in the specified browser context */
     createTarget(url: string, browserContextId?: string, windowId?: number): Promise<ICDPTarget>;
     /** Activate a target (bring to foreground) */
@@ -136,8 +143,12 @@ export interface ICDPBrowserTarget extends ICDPTarget {
  * implemented by CDPBrowserProxy for the full protocol-aware connection.
  */
 export interface ICDPConnection extends IDisposable {
+    /** Optional parent session ID of this connection, if created via a specific session */
+    readonly parentSessionId?: string;
     /** The session ID for this connection */
     readonly sessionId: string;
+    /** The target ID this session is attached to */
+    readonly targetId: string;
     /** Event fired when the connection receives a CDP event */
     readonly onEvent: Event<CDPEvent>;
     /** Event fired when the connection is closed */

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

@@ -0,0 +1,7 @@
+export interface IInvokeFunctionResult {
+    result?: unknown;
+    error?: string;
+    summary: string;
+    /** When present the function did not complete within the timeout. Pass this ID to {@link IPlaywrightService.waitForDeferredResult} to keep waiting. */
+    deferredResultId?: string;
+}

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

@@ -1,4 +1,5 @@
 import { Event } from "../../../base/common/event.js";
+import { IInvokeFunctionResult } from "./playwrightService.js";
 export declare const IPlaywrightService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IPlaywrightService>;
 /**
 * A service for using Playwright to connect to and automate the integrated browser.
@@ -60,15 +61,29 @@ export interface IPlaywrightService {
     /**
     * Run a function with access to a Playwright page and return a result for tool output, including error handling.
     * The first function argument is always the Playwright `page` object, and additional arguments can be passed after.
+    *
+    * When {@link timeoutMs} is provided, the call races against that timeout.
+    * If the timeout fires before the function completes, or the function is otherwise interrupted,
+    * the in-flight promise is stored as a *deferred result* and the returned object includes a
+    * {@link deferredResultId} that can be passed to {@link waitForDeferredResult} to resume waiting.
+    * When {@link timeoutMs} is omitted the function runs to completion with no deferral.
+    *
     * @param pageId The browser view ID identifying the page to operate on.
     * @param fnDef The function code to execute. Should contain the function definition but not its invocation, e.g. `async (page, arg1, arg2) => { ... }`.
     * @param args Additional arguments to pass to the function after the `page` object.
-    * @returns The result of the function execution, including a page summary.
+    * @param timeoutMs Maximum time (in ms) to wait for the function to complete before deferring. When omitted the call awaits indefinitely.
+    * @returns The result of the function execution, including a page summary and optionally a deferredResultId if the call did not complete.
     */
-    invokeFunction(pageId: string, fnDef: string, ...args: unknown[]): Promise<{
-        result: unknown;
-        summary: string;
-    }>;
+    invokeFunction(pageId: string, fnDef: string, args?: unknown[], timeoutMs?: number): Promise<IInvokeFunctionResult>;
+    /**
+    * Continue waiting for a previously deferred function invocation.
+    *
+    * @param deferredResultId The ID returned from a timed-out {@link invokeFunction} call.
+    * @param timeoutMs Maximum time (in ms) to wait before returning a deferred result again.
+    * @returns The same shape as {@link invokeFunction}. If the result is still not
+    * available after the timeout, {@link deferredResultId} is returned again.
+    */
+    waitForDeferredResult(deferredResultId: string, timeoutMs: number): Promise<IInvokeFunctionResult>;
     /**
     * Responds to a file chooser dialog on the given page.
     * @param pageId The browser view ID identifying the page.

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(1806, "Default Language Configuration Overrides")),
+            title: ( localize(1807, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -283,7 +283,7 @@ class ConfigurationRegistry extends Disposable {
             type: "object",
             default: newDefaultOverride.value,
             description: ( localize(
-                1807,
+                1808,
                 "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(1808, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localize(1809, "This setting does not support per-language configuration.")),
+                description: ( localize(1809, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(1810, "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(1808, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localize(1809, "This setting does not support per-language configuration.")),
+            description: ( localize(1809, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(1810, "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(1810, "Cannot register an empty property");
+        return localize(1811, "Cannot register an empty property");
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return localize(
-            1811,
+            1812,
             "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(
-            1812,
+            1813,
             "Cannot register '{0}'. This property is already registered.",
             property
         );
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return localize(
-            1813,
+            1814,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,