@codingame/monaco-vscode-api 34.1.3 → 35.0.1

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

@@ -1,5 +1,7 @@
 import { Event } from "../../../base/common/event.js";
 import { VSBuffer } from "../../../base/common/buffer.js";
+import { ITunnelProxyInfo } from "../../tunnel/common/tunnelProxy.js";
+import { IPermissionCategoryState, ISerializedBrowserPermissionsSnapshot, IBrowserDeviceCandidate, BrowserDeviceType, PermissionCategory } from "./browserPermissions.js";
 export declare enum BrowserViewCommandId {
     Open = "workbench.action.browser.open",
     OpenFile = "workbench.action.browser.openFile",
@@ -17,6 +19,7 @@ export declare enum BrowserViewCommandId {
     OpenSettings = "workbench.action.browser.openSettings",
     ToggleFavorite = "workbench.action.browser.toggleFavorite",
     ShowHistory = "workbench.action.browser.showHistory",
+    ManagePermissions = "workbench.action.browser.managePermissions",
     AddElementToChat = "workbench.action.browser.addElementToChat",
     AddConsoleLogsToChat = "workbench.action.browser.addConsoleLogsToChat",
     AddScreenshotToChat = "workbench.action.browser.addScreenshotToChat",
@@ -69,10 +72,44 @@ export interface IBrowserViewTheme {
     readonly buttonForeground?: string;
     readonly font?: string;
 }
-export interface IBrowserViewConfiguration {
+/**
+ * The full set of configuration a window contributes for the browser views it
+ * owns. Sent as a single unit by the owning window.
+ */
+export interface IBrowserViewWindowConfiguration {
+    /** Theme variables for injected UI. */
+    readonly theme: IBrowserViewTheme;
+    /** Map of command ID to accelerator label for context menus. */
+    readonly keybindings: {
+        [commandId: string]: string;
+    };
+    /** Whether AI features are disabled for this window. */
     readonly aiFeaturesDisabled?: boolean;
     /** Maximum number of entries to retain per browser session history. */
     readonly maxHistoryEntries?: number;
+    /**
+     * Resolved tunnel-proxy credentials for the window's remote browser views,
+     * produced by the window's local node extension host (which hosts the HTTPS
+     * tunnel proxy). `undefined` until the proxy has started, or when no proxy
+     * is used. Applied to the Electron sessions of the window's remote views.
+     */
+    readonly proxyInfo?: ITunnelProxyInfo;
+    /**
+     * The window's contribution to the `file://` allowlist used by integrated
+     * browser sessions. Main unions every window's contribution into a
+     * process-wide allowlist; entries are dropped when the window is destroyed.
+     * Usually `getTrustedUris()` plus, when the workspace itself is trusted, its
+     * workspace folder paths.
+     */
+    readonly trustedFileRoots: readonly string[];
+    /**
+     * Whether Workspace Trust is disabled entirely
+     * (`security.workspace.trust.enabled: false`) for this window. When
+     * `true`, every `file://` request is allowed regardless of
+     * {@link trustedFileRoots} since there is no meaningful notion of an
+     * untrusted folder to enforce.
+     */
+    readonly trustAllFiles: boolean;
 }
 export interface IBrowserViewBounds {
     windowId: number;
@@ -156,13 +193,14 @@ export interface IBrowserViewCreatedEvent {
 }
 export interface IBrowserViewCreateOptions {
     readonly owner: IBrowserViewOwner;
-    readonly scope: BrowserViewStorageScope;
+    readonly sessionOptions: IBrowserSessionOptions;
     readonly initialState?: Partial<IBrowserViewState>;
 }
 /** `applicationSharedStorage` keys this session writes to. Empty for ephemeral sessions. */
 export interface IBrowserViewStorageKeys {
     readonly history?: string;
     readonly favicons?: string;
+    readonly permissions?: string;
 }
 export interface IBrowserViewState {
     url: string;
@@ -179,8 +217,10 @@ export interface IBrowserViewState {
     certificateError: IBrowserViewCertificateError | undefined;
     storageScope: BrowserViewStorageScope;
     storageKeys: IBrowserViewStorageKeys;
+    permissions: ISerializedBrowserPermissionsSnapshot;
     browserZoomIndex: number;
     isElementSelectionActive: boolean;
+    isRemoteSession: boolean;
     isAreaSelectionActive: boolean;
     device: IBrowserDeviceProfile | undefined;
 }
@@ -237,6 +277,16 @@ export interface IBrowserViewTitleChangeEvent {
 export interface IBrowserViewFaviconChangeEvent {
     favicon: string | undefined;
 }
+export interface IBrowserViewPermissionRequestEvent {
+    origin: string;
+    category: PermissionCategory;
+    device?: IBrowserViewDeviceRequest;
+}
+export interface IBrowserViewDeviceRequest {
+    requestId: string;
+    deviceType: BrowserDeviceType;
+    devices: IBrowserDeviceCandidate[];
+}
 export interface IBrowserViewFindInPageOptions {
     recompute?: boolean;
     forward?: boolean;
@@ -253,6 +303,10 @@ export declare enum BrowserViewStorageScope {
     Workspace = "workspace",
     Ephemeral = "ephemeral"
 }
+export interface IBrowserSessionOptions {
+    /** Storage / data-isolation scope for the session. */
+    scope: BrowserViewStorageScope;
+}
 export declare const ipcBrowserViewChannelName = "browserView";
 /**
  * Discrete zoom levels matching Edge/Chrome.
@@ -314,13 +368,12 @@ export interface IBrowserViewService {
     onDynamicDidClose(id: string): Event<void>;
     onDynamicDidSelectElement(id: string): Event<IElementData>;
     onDynamicDidChangeElementSelectionActive(id: string): Event<boolean>;
-    /**
-     * Fires exactly once per area-selection session, terminating it. Receives the user-drawn
-     * rectangle on success, or `undefined` if the picker was cancelled.
-     */
     onDynamicDidPickArea(id: string): Event<IBrowserViewRect | undefined>;
     onDynamicDidChangeAreaSelectionActive(id: string): Event<boolean>;
     onDynamicDidChangeDeviceEmulation(id: string): Event<IBrowserDeviceProfile | undefined>;
+    onDynamicDidChangeRemoteStatus(id: string): Event<boolean>;
+    onDynamicDidRequestPermission(id: string): Event<IBrowserViewPermissionRequestEvent>;
+    onDynamicDidChangePermissions(id: string): Event<ISerializedBrowserPermissionsSnapshot>;
     /**
      * Get all known browser views with their ownership and state information.
      */
@@ -471,6 +524,30 @@ export interface IBrowserViewService {
      * @param entryIds The IDs of the history entries to delete. If omitted, deletes all history.
      */
     deleteBrowserHistory(id: string, entryIds?: readonly number[]): Promise<void>;
+    /**
+     * Record permission decisions for an origin in this view's session. This is
+     * the single write API for permissions: it is used both by the management UI
+     * and to answer an outstanding {@link onDynamicDidRequestPermission} prompt.
+     * Recording a decision for a category auto-resolves any pending request for
+     * that (origin, category). The only values ever stored are `'allow'` and
+     * `'deny'`; passing a `null` decision clears the saved choice, falling back
+     * to the category default. Changes are persisted immediately.
+     *
+     * @param id The browser view identifier
+     * @param origin The origin (URL or origin string) to record decisions for
+     * @param grants The per-category decisions to record
+     */
+    setPermissions(id: string, origin: string, grants: readonly IPermissionCategoryState[]): Promise<void>;
+    /**
+     * Answer an in-progress hardware-device chooser raised via
+     * {@link onDynamicDidRequestPermission} (its `device` payload). Pass the
+     * chosen `deviceId`, or `null` to cancel the chooser.
+     *
+     * @param id The browser view identifier
+     * @param requestId The device request to answer
+     * @param deviceId The selected device id, or `null` to cancel
+     */
+    selectDevice(id: string, requestId: string, deviceId: string | null): Promise<void>;
     /**
      * Get captured console logs for a browser view.
      * Console messages are automatically captured from the moment the view is created.
@@ -498,32 +575,10 @@ export interface IBrowserViewService {
      */
     toggleAreaSelection(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
-     */
-    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>;
-    /**
-     * Replace the calling window's contribution to the `file://` allowlist
-     * used by integrated browser sessions. Main unions every window's
-     * contribution into a process-wide allowlist; entries are dropped when
-     * the window is destroyed.
+     * Replace the calling window's configuration for the browser views it owns.
      *
      * @param windowId The calling window's `vscodeWindowId`.
-     * @param roots Normalized filesystem paths the window deems trusted —
-     * usually `getTrustedUris()` plus, when the workspace itself is trusted,
-     * its workspace folder paths.
+     * @param config The configuration to apply.
      */
-    updateTrustedFileRoots(windowId: number, roots: readonly string[]): Promise<void>;
+    updateWindowConfiguration(windowId: number, config: IBrowserViewWindowConfiguration): Promise<void>;
 }

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

@@ -19,6 +19,7 @@ var BrowserViewCommandId;
     BrowserViewCommandId["OpenSettings"] = "workbench.action.browser.openSettings";
     BrowserViewCommandId["ToggleFavorite"] = "workbench.action.browser.toggleFavorite";
     BrowserViewCommandId["ShowHistory"] = "workbench.action.browser.showHistory";
+    BrowserViewCommandId["ManagePermissions"] = "workbench.action.browser.managePermissions";
     BrowserViewCommandId["AddElementToChat"] = "workbench.action.browser.addElementToChat";
     BrowserViewCommandId["AddConsoleLogsToChat"] = "workbench.action.browser.addConsoleLogsToChat";
     BrowserViewCommandId["AddScreenshotToChat"] = "workbench.action.browser.addScreenshotToChat";

package/vscode/src/vs/platform/configuration/common/configurationRegistry.d.ts

@@ -1,7 +1,7 @@
 import { IStringDictionary } from "../../../base/common/collections.js";
 import { Event } from "../../../base/common/event.js";
 import { IJSONSchema } from "../../../base/common/jsonSchema.js";
-import { IPolicy, PolicyName } from "../../../base/common/policy.js";
+import { IPolicy, IPolicyReference, PolicyName } from "../../../base/common/policy.js";
 export declare enum EditPresentationTypes {
     Multiline = "multilineText",
     Singleline = "singlelineText"
@@ -85,9 +85,13 @@ export interface IConfigurationRegistry {
      */
     getConfigurationProperties(): IStringDictionary<IRegisteredConfigurationPropertySchema>;
     /**
-     * Return all configurations by policy name
+     * Returns the owning setting key per policy name (at most one owner per name).
      */
     getPolicyConfigurations(): Map<PolicyName, string>;
+    /**
+     * Returns the referencing setting keys per policy name.
+     */
+    getPolicyReferenceConfigurations(): Map<PolicyName, Set<string>>;
     /**
      * Returns all excluded configurations settings of all configuration nodes contributed to this registry.
      */
@@ -176,9 +180,15 @@ export interface IConfigurationPropertySchema extends IJSONSchema {
     order?: number;
     /**
      * When specified, this setting's value can always be overwritten by
-     * a system-wide policy.
+     * a system-wide policy. Exactly one setting may *own* a given policy name.
      */
     policy?: IPolicy;
+    /**
+     * When specified, this setting is governed by a policy owned by another setting.
+     * A setting must not declare both `policy` and `policyReference`.
+     * The type must match the owning setting (enforced when exporting the policy catalog).
+     */
+    policyReference?: IPolicyReference;
     /**
      * When specified, this setting's default value can always be overwritten by
      * an experiment.

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(1871, "Default Language Configuration Overrides")),
+            title: ( localize(1947, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -95,6 +95,7 @@ class ConfigurationRegistry extends Disposable {
         };
         this.configurationProperties = {};
         this.policyConfigurations = ( new Map());
+        this.policyReferenceConfigurations = ( new Map());
         this.excludedConfigurationProperties = {};
         contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
         this.registerOverridePropertyPatternKey();
@@ -283,7 +284,7 @@ class ConfigurationRegistry extends Disposable {
             type: "object",
             default: newDefaultOverride.value,
             description: ( localize(
-                1872,
+                1948,
                 "Configure settings to be overridden for {0}.",
                 getLanguageTagSettingPlainKey(key)
             )),
@@ -420,6 +421,15 @@ class ConfigurationRegistry extends Disposable {
                     if (property?.policy?.name) {
                         this.policyConfigurations.delete(property.policy.name);
                     }
+                    if (property?.policyReference?.name) {
+                        const refs = this.policyReferenceConfigurations.get(property.policyReference.name);
+                        if (refs) {
+                            refs.delete(key);
+                            if (refs.size === 0) {
+                                this.policyReferenceConfigurations.delete(property.policyReference.name);
+                            }
+                        }
+                    }
                     delete this.configurationProperties[key];
                     this.removeFromSchema(key, configuration.properties[key]);
                 }
@@ -481,18 +491,26 @@ class ConfigurationRegistry extends Disposable {
                 }
                 const excluded = properties[key].hasOwnProperty("included") && !properties[key].included;
                 const policyName = properties[key].policy?.name;
+                const policyReferenceName = properties[key].policyReference?.name;
                 if (excluded) {
                     this.excludedConfigurationProperties[key] = properties[key];
                     if (policyName) {
                         this.policyConfigurations.set(policyName, key);
                         bucket.add(key);
                     }
+                    if (policyReferenceName) {
+                        this.addPolicyReferenceConfiguration(policyReferenceName, key);
+                        bucket.add(key);
+                    }
                     delete properties[key];
                 } else {
                     bucket.add(key);
                     if (policyName) {
                         this.policyConfigurations.set(policyName, key);
                     }
+                    if (policyReferenceName) {
+                        this.addPolicyReferenceConfiguration(policyReferenceName, key);
+                    }
                     this.configurationProperties[key] = properties[key];
                     if (!properties[key].deprecationMessage && properties[key].markdownDeprecationMessage) {
                         properties[key].deprecationMessage = properties[key].markdownDeprecationMessage;
@@ -507,6 +525,14 @@ class ConfigurationRegistry extends Disposable {
             }
         }
     }
+    addPolicyReferenceConfiguration(policyName, key) {
+        let keys = this.policyReferenceConfigurations.get(policyName);
+        if (!keys) {
+            keys = ( new Set());
+            this.policyReferenceConfigurations.set(policyName, keys);
+        }
+        keys.add(key);
+    }
     getConfigurations() {
         return this.configurationContributors;
     }
@@ -516,6 +542,9 @@ class ConfigurationRegistry extends Disposable {
     getPolicyConfigurations() {
         return this.policyConfigurations;
     }
+    getPolicyReferenceConfigurations() {
+        return this.policyReferenceConfigurations;
+    }
     getExcludedConfigurationProperties() {
         return this.excludedConfigurationProperties;
     }
@@ -601,8 +630,8 @@ class ConfigurationRegistry extends Disposable {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: "object",
-                description: ( localize(1873, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localize(1874, "This setting does not support per-language configuration.")),
+                description: ( localize(1949, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(1950, "This setting does not support per-language configuration.")),
                 $ref: resourceLanguageSettingsSchemaId
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -618,8 +647,8 @@ class ConfigurationRegistry extends Disposable {
     registerOverridePropertyPatternKey() {
         const resourceLanguagePropertiesSchema = {
             type: "object",
-            description: ( localize(1873, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localize(1874, "This setting does not support per-language configuration.")),
+            description: ( localize(1949, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(1950, "This setting does not support per-language configuration.")),
             $ref: resourceLanguageSettingsSchemaId
         };
         allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
@@ -694,26 +723,33 @@ const configurationRegistry = ( new ConfigurationRegistry());
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema, extensionId) {
     if (!property.trim()) {
-        return localize(1875, "Cannot register an empty property");
+        return localize(1951, "Cannot register an empty property");
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return localize(
-            1876,
+            1952,
             "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(
-            1877,
+            1953,
             "Cannot register '{0}'. This property is already registered.",
             property
         );
     }
+    if (schema.policy && schema.policyReference) {
+        return localize(
+            1954,
+            "Cannot register '{0}'. A setting must not declare both 'policy' and 'policyReference'.",
+            property
+        );
+    }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return localize(
-            1878,
-            "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
+            1955,
+            "Cannot register '{0}'. The associated policy {1} is already registered with {2}. To attach another setting to the same policy, use 'policyReference'.",
             property,
             schema.policy?.name,
             configurationRegistry.getPolicyConfigurations().get(schema.policy?.name)

package/vscode/src/vs/platform/configuration/common/configurations.d.ts

@@ -42,9 +42,17 @@ export declare class PolicyConfiguration extends Disposable implements IPolicyCo
     private readonly configurationRegistry;
     private _configurationModel;
     get configurationModel(): ConfigurationModel;
+    /** Last definition submitted per policy name; avoids redundant re-registration. */
+    private readonly _submittedPolicyDefinitions;
+    /** Maps each policy-controlled setting key to its policy name, so removed keys can be re-resolved. */
+    private readonly _policyNameByKey;
     constructor(defaultConfiguration: DefaultConfiguration, policyService: IPolicyService, logService: ILogService);
     initialize(): Promise<ConfigurationModel>;
+    private toPolicyDefinitionType;
     private updatePolicyDefinitions;
+    private isSamePolicyDefinition;
+    /** Resolve the authoritative definition: owner wins; references provide a bare type fallback. */
+    private resolvePolicyDefinition;
     private onDidChangePolicies;
     private update;
     private parse;

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

@@ -1,6 +1,5 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { coalesce } from '../../../base/common/arrays.js';
 import { Emitter, Event } from '../../../base/common/event.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { deepClone, equals } from '../../../base/common/objects.js';
@@ -92,6 +91,8 @@ let PolicyConfiguration = class PolicyConfiguration extends Disposable {
         this.logService = logService;
         this._onDidChangeConfiguration = this._register(( new Emitter()));
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this._submittedPolicyDefinitions = ( new Map());
+        this._policyNameByKey = ( new Map());
         this._configurationModel = ConfigurationModel.createEmptyModel(this.logService);
         this.configurationRegistry = ( Registry.as(Extensions.Configuration));
     }
@@ -112,44 +113,107 @@ let PolicyConfiguration = class PolicyConfiguration extends Disposable {
         ) => this.update(await this.updatePolicyDefinitions(properties), true)));
         return this._configurationModel;
     }
+    toPolicyDefinitionType(configType, policyName) {
+        const configTypes = Array.isArray(configType) ? configType : [configType];
+        const supportedTypes = configTypes.filter(
+            type => type === "string" || type === "number" || type === "array" || type === "object" || type === "boolean"
+        );
+        if (supportedTypes.length === 0) {
+            this.logService.warn(
+                `PolicyConfiguration#updatePolicyDefinitions - policy '${policyName}' has unsupported type '${configType}'`
+            );
+            return undefined;
+        }
+        return supportedTypes.includes("number") ? "number" : supportedTypes.includes("boolean") ? "boolean" : "string";
+    }
     async updatePolicyDefinitions(properties) {
         this.logService.trace("PolicyConfiguration#updatePolicyDefinitions", properties);
-        const policyDefinitions = {};
         const keys = [];
+        const policyNames = ( new Set());
         const configurationProperties = this.configurationRegistry.getConfigurationProperties();
         const excludedConfigurationProperties = this.configurationRegistry.getExcludedConfigurationProperties();
         for (const key of properties) {
             const config = configurationProperties[key] ?? excludedConfigurationProperties[key];
             if (!config) {
                 keys.push(key);
+                const removedPolicyName = this._policyNameByKey.get(key);
+                if (removedPolicyName !== undefined) {
+                    this._policyNameByKey.delete(key);
+                    policyNames.add(removedPolicyName);
+                }
                 continue;
             }
-            if (config.policy) {
-                if (config.type !== "string" && config.type !== "number" && config.type !== "array" && config.type !== "object" && config.type !== "boolean") {
-                    this.logService.warn(`Policy ${config.policy.name} has unsupported type ${config.type}`);
-                    continue;
-                }
+            const policyName = config.policy?.name ?? config.policyReference?.name;
+            if (policyName) {
+                keys.push(key);
+                policyNames.add(policyName);
+                this._policyNameByKey.set(key, policyName);
+            }
+        }
+        const changedDefinitions = {};
+        for (const policyName of policyNames) {
+            const definition = this.resolvePolicyDefinition(policyName);
+            if (definition && !this.isSamePolicyDefinition(this._submittedPolicyDefinitions.get(policyName), definition)) {
+                this._submittedPolicyDefinitions.set(policyName, definition);
+                changedDefinitions[policyName] = definition;
+            }
+        }
+        if (!isEmptyObject(changedDefinitions)) {
+            await this.policyService.updatePolicyDefinitions(changedDefinitions);
+        }
+        return keys;
+    }
+    isSamePolicyDefinition(a, b) {
+        return !!a && a.type === b.type && a.value === b.value && a.managedSettings === b.managedSettings && a.restrictedValue === b.restrictedValue;
+    }
+    resolvePolicyDefinition(policyName) {
+        const configurationProperties = this.configurationRegistry.getConfigurationProperties();
+        const excludedConfigurationProperties = this.configurationRegistry.getExcludedConfigurationProperties();
+        const ownerKey = this.configurationRegistry.getPolicyConfigurations().get(policyName);
+        if (ownerKey !== undefined) {
+            const config = configurationProperties[ownerKey] ?? excludedConfigurationProperties[ownerKey];
+            if (config?.policy) {
+                const type = this.toPolicyDefinitionType(config.type, policyName);
                 const {
                     value,
+                    managedSettings,
                     restrictedValue
                 } = config.policy;
-                keys.push(key);
-                policyDefinitions[config.policy.name] = {
-                    type: config.type === "number" ? "number" : config.type === "boolean" ? "boolean" : "string",
+                return type ? {
+                    type,
                     value,
+                    managedSettings,
                     restrictedValue
-                };
+                } : undefined;
             }
         }
-        if (!isEmptyObject(policyDefinitions)) {
-            await this.policyService.updatePolicyDefinitions(policyDefinitions);
+        const referenceKeys = this.configurationRegistry.getPolicyReferenceConfigurations().get(policyName);
+        for (const referenceKey of referenceKeys ?? []) {
+            const config = configurationProperties[referenceKey] ?? excludedConfigurationProperties[referenceKey];
+            if (config?.policyReference) {
+                const type = this.toPolicyDefinitionType(config.type, policyName);
+                return type ? {
+                    type
+                } : undefined;
+            }
         }
-        return keys;
+        return undefined;
     }
     onDidChangePolicies(policyNames) {
         this.logService.trace("PolicyConfiguration#onDidChangePolicies", policyNames);
         const policyConfigurations = this.configurationRegistry.getPolicyConfigurations();
-        const keys = coalesce(( policyNames.map(policyName => policyConfigurations.get(policyName))));
+        const policyReferenceConfigurations = this.configurationRegistry.getPolicyReferenceConfigurations();
+        const keys = [];
+        for (const policyName of policyNames) {
+            const owner = policyConfigurations.get(policyName);
+            if (owner) {
+                keys.push(owner);
+            }
+            const references = policyReferenceConfigurations.get(policyName);
+            if (references) {
+                keys.push(...references);
+            }
+        }
         this.update(keys, true);
     }
     update(keys, trigger) {
@@ -159,11 +223,12 @@ let PolicyConfiguration = class PolicyConfiguration extends Disposable {
         const changed = [];
         const wasEmpty = this._configurationModel.isEmpty();
         for (const key of keys) {
-            const proprety = configurationProperties[key] ?? excludedConfigurationProperties[key];
-            const policyName = proprety?.policy?.name;
+            const property = configurationProperties[key] ?? excludedConfigurationProperties[key];
+            const policyName = property?.policy?.name ?? property?.policyReference?.name;
             if (policyName) {
                 let policyValue = this.policyService.getPolicyValue(policyName);
-                if (isString(policyValue) && proprety.type !== "string") {
+                const acceptsStringType = Array.isArray(property.type) ? property.type.includes("string") : property.type === "string";
+                if (isString(policyValue) && !acceptsStringType) {
                     try {
                         policyValue = this.parse(policyValue);
                     } catch (e) {

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(1879, "A command that returns information about context keys")),
+        description: ( localize(1956, "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(1880, "Empty context key expression"));
+const errorEmptyString = ( localize(1957, "Empty context key expression"));
 const hintEmptyString = ( localize(
-    1881,
+    1958,
     "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(1882, "'in' after 'not'."));
-const errorClosingParenthesis = ( localize(1883, "closing parenthesis ')'"));
-const errorUnexpectedToken = ( localize(1884, "Unexpected token"));
-const hintUnexpectedToken = ( localize(1885, "Did you forget to put && or || before the token?"));
-const errorUnexpectedEOF = ( localize(1886, "Unexpected end of expression"));
-const hintUnexpectedEOF = ( localize(1887, "Did you forget to put a context key?"));
+const errorNoInAfterNot = ( localize(1959, "'in' after 'not'."));
+const errorClosingParenthesis = ( localize(1960, "closing parenthesis ')'"));
+const errorUnexpectedToken = ( localize(1961, "Unexpected token"));
+const hintUnexpectedToken = ( localize(1962, "Did you forget to put && or || before the token?"));
+const errorUnexpectedEOF = ( localize(1963, "Unexpected end of expression"));
+const hintUnexpectedEOF = ( localize(1964, "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(1888, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
+        const message = ( localize(1965, "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(1889, "Unexpected token. Hint: {0}", se.additionalInfo)) : ( localize(1890, "Unexpected token.")),
+                errorMessage: se.additionalInfo ? ( localize(1966, "Unexpected token. Hint: {0}", se.additionalInfo)) : ( localize(1967, "Unexpected token.")),
                 offset: se.offset,
                 length: se.lexeme.length
             })));