@lvce-editor/extension-management-worker 4.74.4 → 4.75.0

package/dist/extensionManagementWorkerMain.js

@@ -1382,7 +1382,7 @@ const waitForReconnect = async () => {
     setTimeout(resolve, reconnectDelay);
   });
 };
-const connect = async ({
+const connect$1 = async ({
   commandMap,
   wsUrl
 }) => {
@@ -1411,13 +1411,13 @@ const create$3 = async ({
   const wsUrl = getWebSocketUrl(type, host, protocol);
   let connection;
   try {
-    connection = await connect({
+    connection = await connect$1({
       commandMap,
       wsUrl
     });
   } catch {
     await waitForReconnect();
-    connection = await connect({
+    connection = await connect$1({
       commandMap,
       wsUrl
     });
@@ -1623,378 +1623,466 @@ const validateNodeProcessRpc = (extensionId, rpcId) => {
   if (rpc.type !== 'node-process') {
     throw new Error(`Rpc ${rpcId} declared by extension ${extension.id} is not a node process`);
   }
+  return rpc;
 };
 
-const isMissingRendererCommand = (error, command) => {
-  const moduleName = command.slice(0, command.indexOf('.'));
-  return error instanceof Error && (error.message.includes(command) || error.message.includes(`module ${moduleName} not found`)) && /command not found|not found/i.test(error.message);
-};
-const createUnsupportedDirectLaunchError = rpcId => {
-  return new Error(`Node process ${rpcId} requires direct renderer support`);
-};
-const createRemoteConnection = async (extensionId, rpcId) => {
-  try {
-    const connectionInfo = await invoke$4('ExtensionNodeRpc.createConnection', extensionId, rpcId);
-    return {
-      ...connectionInfo,
-      type: 'websocket'
-    };
-  } catch (error) {
-    if (isMissingRendererCommand(error, 'ExtensionNodeRpc.createConnection')) {
-      throw createUnsupportedDirectLaunchError(rpcId);
+const ContentType = 'Content-Type';
+const ContentLength = 'Content-Length';
+
+const createResponseFromData = data => {
+  const responseString = JSON.stringify(data);
+  const response = new Response(responseString, {
+    headers: {
+      [ContentLength]: String(responseString.length),
+      [ContentType]: 'application/json'
     }
-    throw error;
+  });
+  return response;
+};
+
+const cacheName$1 = 'Extensions'; // TODO
+
+const getJson$1 = async cacheKey => {
+  const response = await caches.match(cacheKey, {
+    cacheName: cacheName$1
+  });
+  if (!response) {
+    return undefined;
   }
+  const json = await response.json();
+  return json;
 };
-const createElectronConnection = async rpcId => {
+const setJson = async (cacheKey, data) => {
   try {
-    const supported = await invoke$4('ExtensionNodeRpc.supportsDirectConnection');
-    if (!supported) {
-      throw createUnsupportedDirectLaunchError(rpcId);
-    }
-    return {
-      type: 'message-port'
-    };
+    const cache = await caches.open(cacheName$1);
+    const response = createResponseFromData(data);
+    await cache.put(cacheKey, response);
   } catch (error) {
-    if (isMissingRendererCommand(error, 'ExtensionNodeRpc.supportsDirectConnection')) {
-      throw createUnsupportedDirectLaunchError(rpcId);
-    }
-    throw error;
+    throw new VError(error, `Failed to add to cache`);
   }
 };
-const createNodeRpcConnection = async (extensionId, rpcId) => {
-  validateNodeProcessRpc(extensionId, rpcId);
-  const {
-    platform
-  } = get$7();
-  if (platform !== Remote && platform !== Electron) {
-    throw new Error('Node rpc is not available on this platform');
-  }
-  if (platform === Remote) {
-    return createRemoteConnection(extensionId, rpcId);
+
+const disabledExtensionsCacheKey = '/cache/disabledExtensions.json';
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const getStringArray$2 = value => {
+  if (!Array.isArray(value)) {
+    return [];
   }
-  return createElectronConnection(rpcId);
+  return value.filter(id => typeof id === 'string');
 };
-const createNodeRpcMessagePort = async (extensionId, rpcId, port) => {
-  const {
-    platform
-  } = get$7();
-  if (platform !== Electron) {
-    throw new Error('Node rpc message ports are only available in Electron');
+const getExtensionEnablementFromData = data => {
+  return {
+    disabledIds: getStringArray$2(data?.disabledExtensions),
+    enabledIds: getStringArray$2(data?.enabledExtensions)
+  };
+};
+const getWebExtensionEnablement = async () => {
+  try {
+    const cached = await getJson$1(disabledExtensionsCacheKey);
+    return getExtensionEnablementFromData(cached);
+  } catch {
+    return getExtensionEnablementFromData(undefined);
   }
-  validateNodeProcessRpc(extensionId, rpcId);
-  await invokeAndTransfer$1('ExtensionNodeRpc.createMessagePort', port, extensionId, rpcId);
 };
-
-const extensionIds = new Set();
-const applications$1 = new Map();
-const register$1 = (extensionId, applicationId) => {
-  if (applicationId === undefined) {
-    extensionIds.add(extensionId);
-    return;
+const getRemoteExtensionEnablement = async () => {
+  try {
+    const uri = await invoke$4('WebView.compatSharedProcessInvoke', 'PlatformPaths.getDisabledExtensionsJsonUri');
+    const exists$1 = await exists(uri);
+    if (!exists$1) {
+      return getExtensionEnablementFromData(undefined);
+    }
+    const content = await readFile$1(uri);
+    return getExtensionEnablementFromData(JSON.parse(content));
+  } catch {
+    return getExtensionEnablementFromData(undefined);
   }
-  const ids = applications$1.get(applicationId) || new Set();
-  ids.add(extensionId);
-  applications$1.set(applicationId, ids);
 };
-const unregister = (extensionId, applicationId) => {
-  if (applicationId === undefined) {
-    extensionIds.delete(extensionId);
-    return;
+const getExtensionEnablement = async (extensionsState, platform) => {
+  if (platform === Test) {
+    return {
+      disabledIds: extensionsState.disabledIds,
+      enabledIds: []
+    };
   }
-  const ids = applications$1.get(applicationId);
-  ids?.delete(extensionId);
-  if (ids?.size === 0) {
-    applications$1.delete(applicationId);
+  if (platform === Web) {
+    return getWebExtensionEnablement();
   }
-};
-const getRegisteredExtensionIds = applicationId => {
-  return [...(applicationId === undefined ? extensionIds : applications$1.get(applicationId) || [])];
-};
-const reset = applicationId => {
-  if (applicationId === undefined) {
-    extensionIds.clear();
-  } else {
-    applications$1.delete(applicationId);
+  if (platform === Remote || platform === Electron) {
+    return getRemoteExtensionEnablement();
   }
+  return getExtensionEnablementFromData(undefined);
 };
 
-const prefix = '[Extension] Uncaught Error: ';
-const handleUncaughtExtensionError = async error => {
-  const prettyError = await invoke$7('Errors.prepare', error);
-  await invoke$7('Errors.print', prettyError, prefix);
-};
-
-const state$3 = {
-  nextId: 1,
-  notifications: []
-};
-const add$1 = (extensionId, type, message) => {
-  const notification = {
-    extensionId,
-    id: state$3.nextId++,
-    message,
-    type
-  };
-  state$3.notifications = [...state$3.notifications, notification];
-  return notification;
+const isMissingAssetDir = assetDir => {
+  return typeof assetDir !== 'string' || assetDir.length === 0;
 };
-const clear$1 = () => {
-  state$3.notifications = [];
+const isMissingPlatform = platform => {
+  return typeof platform !== 'number' || platform === 0;
 };
-const dismiss = id => {
-  state$3.notifications = state$3.notifications.filter(notification => notification.id !== id);
+const isStaticHttpAssetDir = assetDir => {
+  return assetDir.startsWith('/') || assetDir.startsWith('http');
 };
-const getAll$1 = () => {
-  return state$3.notifications;
+const isHttpLocation = () => {
+  return Reflect.has(globalThis, 'location') && globalThis.location.protocol.startsWith('http');
 };
-const removeByExtension = extensionId => {
-  state$3.notifications = state$3.notifications.filter(notification => notification.extensionId !== extensionId);
+const getRuntimeContext = async (assetDir, platform) => {
+  const shouldInferPlatform = isMissingPlatform(platform);
+  const resolvedAssetDir = isMissingAssetDir(assetDir) ? await invoke$4('Layout.getAssetDir') : assetDir;
+  const resolvedPlatform = shouldInferPlatform ? await invoke$4('Layout.getPlatform') : platform;
+  if (shouldInferPlatform && isHttpLocation() && isStaticHttpAssetDir(resolvedAssetDir)) {
+    return {
+      assetDir: resolvedAssetDir,
+      platform: Web
+    };
+  }
+  return {
+    assetDir: resolvedAssetDir,
+    platform: resolvedPlatform
+  };
 };
 
-const state$2 = {
-  rpc: undefined
-};
-const set$4 = value => {
-  state$2.rpc = value;
+const getResponseErrorMessage = response => {
+  return response.statusText || String(response.status) || 'Request failed';
 };
-const invoke$2 = async (method, ...params) => {
-  await state$2.rpc?.invoke(method, ...params);
+const getJson = async url => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(getResponseErrorMessage(response));
+    }
+    const json = await response.json();
+    return json;
+  } catch (error) {
+    throw new VError(error, `Failed to get json`);
+  }
 };
 
-const state$1 = {
-  rpc: undefined
-};
-const set$3 = value => {
-  state$1.rpc = value;
-};
-const invoke$1 = async (method, ...params) => {
-  await state$1.rpc?.invoke(method, ...params);
+const getWebExtensionsUrl = assetDir => {
+  return `${assetDir}/config/extensions.json`;
 };
 
-const notifyNotificationsChanged = async () => {
-  const notifications = getAll$1();
-  await Promise.all([invoke$2('NotificationCenter.handleNotificationsChanged', notifications), invoke$1('StatusBar.handleNotificationCountChanged', notifications.length)]);
+const getWebExtensions = async assetDir => {
+  try {
+    return await getJson(getWebExtensionsUrl(assetDir));
+  } catch {
+    return [];
+  }
 };
 
-const getPreference = async key => {
-  return invoke$4('Preferences.get', key);
-};
-const setPreference = async (key, value) => {
-  await invoke$4('Preferences.update', {
-    [key]: value
-  });
+const isExtensionCompatible = (extension, platform) => {
+  return platform !== Web || extension?.compatibility?.web !== false;
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-const invoke = (method, ...params) => {
-  return invoke$4(method, ...params);
-};
-const invokeAndTransfer = (method, ...params) => {
-  return invokeAndTransfer$1(method, ...params);
+const WorkspacesFolderName = 'workspaces';
+const ExtensionEnablementFileName = 'extension-enablement.json';
+const CacheKeyPrefix = '/cache/workspaces';
+const UriSchemeRegex = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+const WindowsDrivePathRegex = /^[a-zA-Z]:[\\/]/;
+const WindowsDriveSegmentRegex = /^[a-zA-Z]:$/;
+const EmptyEnablement = {
+  disabledIds: [],
+  enabledIds: [],
+  hasWorkspace: false
 };
-
-const hiddenExtensionIdsPreference = 'notifications.hiddenExtensionIds';
-const getHiddenExtensionIds = async () => {
-  const value = await getPreference(hiddenExtensionIdsPreference);
-  if (!Array.isArray(value)) {
-    return [];
+const cache$1 = new Map();
+const mutationQueues = new Map();
+const encodePathSegment = (segment, index) => {
+  if (index === 0 && WindowsDriveSegmentRegex.test(segment)) {
+    return segment;
   }
-  return value.filter(item => typeof item === 'string');
+  return encodeURIComponent(segment);
 };
-const assertType = type => {
-  if (type !== 'error' && type !== 'info' && type !== 'warning') {
-    throw new TypeError(`Invalid notification type: ${type}`);
-  }
+const encodeFilePath = path => {
+  return path.split('/').map(encodePathSegment).join('/');
 };
-const showPopup = async (type, message) => {
-  try {
-    await invoke('Notification.create', type, message);
-  } catch {
-    // Notification storage must keep working while an older renderer is connected.
+const toWorkspaceUri = workspacePath => {
+  if (WindowsDrivePathRegex.test(workspacePath)) {
+    return `file:///${encodeFilePath(workspacePath.replaceAll('\\', '/'))}`;
   }
-};
-const clearNotifications = async () => {
-  clear$1();
-  await notifyNotificationsChanged();
-};
-const createNotification = async (extensionId, type, message) => {
-  string(extensionId);
-  string(type);
-  string(message);
-  assertType(type);
-  const hiddenExtensionIds = await getHiddenExtensionIds();
-  if (hiddenExtensionIds.includes(extensionId)) {
-    return;
+  if (UriSchemeRegex.test(workspacePath)) {
+    return workspacePath;
   }
-  add$1(extensionId, type, message);
-  await Promise.all([notifyNotificationsChanged(), showPopup(type, message)]);
-};
-const dismissNotification = async id => {
-  number(id);
-  dismiss(id);
-  await notifyNotificationsChanged();
+  if (workspacePath.startsWith('/')) {
+    return `file://${encodeFilePath(workspacePath)}`;
+  }
+  return workspacePath;
 };
-const getNotificationCount = () => {
-  return getAll$1().length;
+const joinUri = (base, ...parts) => {
+  const normalizedBase = base.endsWith('/') ? base.slice(0, -1) : base;
+  return [normalizedBase, ...parts].join('/');
 };
-const getNotifications = () => {
-  return getAll$1();
+const hashWorkspaceUri = async workspaceUri => {
+  const bytes = new TextEncoder().encode(workspaceUri);
+  const digest = await crypto.subtle.digest('SHA-256', bytes);
+  return Array.from(new Uint8Array(digest), value => value.toString(16).padStart(2, '0')).join('');
 };
-const hideNotificationsFromExtension = async extensionId => {
-  string(extensionId);
-  const hiddenExtensionIds = await getHiddenExtensionIds();
-  if (!hiddenExtensionIds.includes(extensionId)) {
-    await setPreference(hiddenExtensionIdsPreference, [...hiddenExtensionIds, extensionId]);
+const getWorkspaceUri$1 = async () => {
+  let workspacePath;
+  try {
+    workspacePath = await invoke$4('Workspace.getPath');
+  } catch {
+    return '';
   }
-  removeByExtension(extensionId);
-  await notifyNotificationsChanged();
-};
-
-const cacheName$1 = 'ExtensionSecrets';
-const getRequestUrl = (extensionId, key) => {
-  return `https://secret-storage.invalid/${encodeURIComponent(extensionId)}/${encodeURIComponent(key)}`;
-};
-const isElectron = () => {
-  return get$7().platform === Electron;
+  return typeof workspacePath === 'string' ? toWorkspaceUri(workspacePath) : '';
 };
-const deleteSecret = async (extensionId, key) => {
-  string(extensionId);
-  string(key);
-  if (isElectron()) {
-    await invoke$5('SecretStorage.delete', extensionId, key);
-    return;
+const getConfigUri = async () => {
+  const configUri = await invoke$4('WebView.compatSharedProcessInvoke', 'Platform.getConfigUri');
+  if (typeof configUri !== 'string' || configUri === '') {
+    throw new Error('Config uri is not available');
   }
-  const cache = await caches.open(cacheName$1);
-  await cache.delete(getRequestUrl(extensionId, key));
+  return configUri;
 };
-const getSecret = async (extensionId, key) => {
-  string(extensionId);
-  string(key);
-  if (isElectron()) {
-    return invoke$5('SecretStorage.get', extensionId, key);
+const getStorageLocation = async workspaceUri => {
+  const workspaceHash = await hashWorkspaceUri(workspaceUri);
+  try {
+    const configUri = await getConfigUri();
+    const directoryUri = joinUri(configUri, WorkspacesFolderName, workspaceHash);
+    const uri = joinUri(directoryUri, ExtensionEnablementFileName);
+    return {
+      directoryUri,
+      key: uri,
+      type: 'file',
+      uri
+    };
+  } catch {
+    return {
+      key: joinUri(CacheKeyPrefix, workspaceHash, ExtensionEnablementFileName),
+      type: 'cache'
+    };
   }
-  const cache = await caches.open(cacheName$1);
-  const response = await cache.match(getRequestUrl(extensionId, key));
-  return response?.text();
 };
-const storeSecret = async (extensionId, key, value) => {
-  string(extensionId);
-  string(key);
-  string(value);
-  if (isElectron()) {
-    await invoke$5('SecretStorage.store', extensionId, key, value);
-    return;
+const getStringArray$1 = value => {
+  if (!Array.isArray(value)) {
+    return [];
   }
-  const cache = await caches.open(cacheName$1);
-  await cache.put(getRequestUrl(extensionId, key), new Response(value));
+  return value.filter(item => typeof item === 'string');
 };
-
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    Object.defineProperty(this, 'name', {
-      value: 'CommandNotFoundError'
-    });
+const parseEnablement = data => {
+  return {
+    disabledIds: getStringArray$1(data.disabledExtensions),
+    enabledIds: getStringArray$1(data.enabledExtensions),
+    hasWorkspace: true
+  };
+};
+const readFromLocation = async location => {
+  if (location.type === 'cache') {
+    const data = await getJson$1(location.key);
+    return parseEnablement(data || {});
   }
-}
-const allowedElectronPortCommand = 'HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess';
-const workspaceSetUriCommand = 'Workspace.setUri';
-const privilegedCommandPrefixes = ['ElectronNet.', 'ClipBoard.', 'DebugSharedProcess.', 'Developer.', 'Electron', 'Exec.', 'ExtensionNodeRpc.', 'FileSystem', 'FileWatcher.', 'IpcParent.', 'PlatformPaths.', 'PersistentFileHandle.', 'Process.', 'RebuildNodePty.', 'SearchProcess.', 'SendMessagePort', 'SharedProcess.', 'TerminalProcess.', 'Transferrable.', 'WebSocketCapability.', 'WebView.compat'];
-const invokeGlobalCommand = (method, ...params) => {
-  const command = commandMapRef[method];
-  if (!command) {
-    throw new CommandNotFoundError(method);
+  const exists$1 = await exists(location.uri);
+  if (!exists$1) {
+    return {
+      ...EmptyEnablement,
+      hasWorkspace: true
+    };
   }
-  return command(...params);
+  const content = await readFile$1(location.uri);
+  return parseEnablement(JSON.parse(content));
 };
-const executeDeferredCommand = async (invokeCommand, id, args) => {
+const readFromLocationCached = async location => {
+  const cached = cache$1.get(location.key);
+  if (cached) {
+    return cached;
+  }
+  const promise = readFromLocation(location);
+  cache$1.set(location.key, promise);
   try {
-    await invokeCommand('Extensions.executeCommand', id, ...args);
+    return await promise;
   } catch (error) {
-    await handleUncaughtExtensionError(error);
+    if (cache$1.get(location.key) === promise) {
+      cache$1.delete(location.key);
+    }
+    throw error;
   }
 };
-const executeCommand$1 = (invokeCommand, id, ...args) => {
-  if (privilegedCommandPrefixes.some(prefix => id.startsWith(prefix))) {
-    throw new Error(`Isolated extensions cannot execute privileged command ${id}`);
-  }
-  if (id === workspaceSetUriCommand) {
-    setTimeout(() => {
-      void executeDeferredCommand(invokeCommand, id, args).catch(() => {});
-    }, 0);
+const getWorkspaceAndLocation = async () => {
+  const workspaceUri = await getWorkspaceUri$1();
+  if (!workspaceUri) {
     return undefined;
   }
-  return invokeCommand('Extensions.executeCommand', id, ...args);
-};
-const createExtensionCommandMap = (extensionId, invokeCommand = invokeGlobalCommand) => {
-  const inheritedCommands = invokeCommand === invokeGlobalCommand ? commandMapRef : Object.fromEntries(Object.keys(commandMapRef).map(method => [method, (...args) => invokeCommand(method, ...args)]));
-  if (invokeCommand !== invokeGlobalCommand) {
-    // Application runtimes must not bypass the scoped router through a legacy
-    // callback (notifications, secrets, file watchers, or privileged node ports).
-    return {
-      ...inheritedCommands,
-      'Extensions.executeCommand': (id, ...args) => executeCommand$1(invokeCommand, id, ...args),
-      'Extensions.registerFileChangeHandler': () => invokeCommand('Extensions.registerFileChangeHandler'),
-      'Extensions.unregisterFileChangeHandler': () => invokeCommand('Extensions.unregisterFileChangeHandler')
-    };
-  }
+  const location = await getStorageLocation(workspaceUri);
   return {
-    ...inheritedCommands,
-    'Extensions.createNodeRpcConnection'(rpcId) {
-      return createNodeRpcConnection(extensionId, rpcId);
-    },
-    'Extensions.createNodeRpcMessagePort'(rpcId, port) {
-      return createNodeRpcMessagePort(extensionId, rpcId, port);
-    },
-    'Extensions.deleteSecret'(key) {
-      return deleteSecret(extensionId, key);
-    },
-    'Extensions.executeCommand'(id, ...args) {
-      return executeCommand$1(invokeCommand, id, ...args);
-    },
-    'Extensions.getSecret'(key) {
-      return getSecret(extensionId, key);
-    },
-    'Extensions.registerFileChangeHandler'() {
-      register$1(extensionId);
-    },
-    'Extensions.sendMessagePortToElectron'(port, initialCommand) {
-      if (initialCommand !== allowedElectronPortCommand) {
-        throw new Error(`Isolated extensions cannot send a port using ${initialCommand}`);
-      }
-      return invokeGlobalCommand('Extensions.sendMessagePortToElectron', port, initialCommand);
-    },
-    'Extensions.showNotification'(type, message) {
-      return createNotification(extensionId, type, message);
-    },
-    'Extensions.storeSecret'(key, value) {
-      return storeSecret(extensionId, key, value);
-    },
-    'Extensions.unregisterFileChangeHandler'() {
-      unregister(extensionId);
-    }
+    location,
+    workspaceUri
   };
 };
-const createExtensionCommandExecutor = commandMap => {
-  return (method, ...params) => {
-    const command = commandMap[method];
-    if (!command) {
-      throw new CommandNotFoundError(method);
-    }
-    return command(...params);
+const writeToLocation = async (location, workspaceUri, enablement) => {
+  const data = {
+    disabledExtensions: enablement.disabledIds,
+    enabledExtensions: enablement.enabledIds,
+    workspace: workspaceUri
   };
+  if (location.type === 'cache') {
+    await setJson(location.key, data);
+  } else {
+    const directoryExists = await exists(location.directoryUri);
+    if (!directoryExists) {
+      await mkdir(location.directoryUri);
+    }
+    await writeFile(location.uri, JSON.stringify(data, null, 2) + '\n');
+  }
+  cache$1.set(location.key, Promise.resolve(enablement));
 };
-
-const sourcePathMarker = '/extension-management-worker/src/';
-const getExtensionHostSubWorkerUrl = (currentUrl = import.meta.url) => {
-  const relativePath = currentUrl.includes(sourcePathMarker) ? '../../../../extension-host-sub-worker/src/extensionHostSubWorkerMain.js' : '../../extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
-  return new URL(relativePath, currentUrl).href;
-};
-const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
-
-// TODO
-
+const mutate = async (update, createIfMissing) => {
+  const workspaceAndLocation = await getWorkspaceAndLocation();
+  if (!workspaceAndLocation) {
+    throw new Error('Cannot change workspace extension enablement without an open workspace');
+  }
+  const {
+    location,
+    workspaceUri
+  } = workspaceAndLocation;
+  const previousMutation = mutationQueues.get(location.key) || Promise.resolve();
+  const runMutation = async () => {
+    try {
+      await previousMutation;
+    } catch {
+      // A failed earlier mutation must not permanently block this workspace.
+    }
+    if (!createIfMissing && location.type === 'file' && !(await exists(location.uri))) {
+      return;
+    }
+    const oldEnablement = await readFromLocation(location);
+    const newEnablement = update(oldEnablement);
+    await writeToLocation(location, workspaceUri, newEnablement);
+  };
+  const mutation = runMutation();
+  mutationQueues.set(location.key, mutation);
+  try {
+    await mutation;
+  } finally {
+    if (mutationQueues.get(location.key) === mutation) {
+      mutationQueues.delete(location.key);
+    }
+  }
+};
+const getWorkspaceExtensionEnablement = async () => {
+  const workspaceAndLocation = await getWorkspaceAndLocation();
+  if (!workspaceAndLocation) {
+    return EmptyEnablement;
+  }
+  return readFromLocationCached(workspaceAndLocation.location);
+};
+const getWorkspaceExtensionEnablementSafe = async () => {
+  try {
+    return await getWorkspaceExtensionEnablement();
+  } catch {
+    let workspaceUri = '';
+    try {
+      workspaceUri = await getWorkspaceUri$1();
+    } catch {
+      // Ignore unavailable workspace state while recovering from malformed storage.
+    }
+    return {
+      ...EmptyEnablement,
+      hasWorkspace: Boolean(workspaceUri)
+    };
+  }
+};
+const disableExtension$1 = async id => {
+  string(id);
+  await mutate(oldEnablement => ({
+    disabledIds: oldEnablement.disabledIds.includes(id) ? oldEnablement.disabledIds : [...oldEnablement.disabledIds, id],
+    enabledIds: oldEnablement.enabledIds.filter(item => item !== id),
+    hasWorkspace: true
+  }), true);
+};
+const enableExtension$1 = async id => {
+  string(id);
+  await mutate(oldEnablement => ({
+    disabledIds: oldEnablement.disabledIds.filter(item => item !== id),
+    enabledIds: oldEnablement.enabledIds.includes(id) ? oldEnablement.enabledIds : [...oldEnablement.enabledIds, id],
+    hasWorkspace: true
+  }), true);
+};
+const clearExtensionOverride = async id => {
+  string(id);
+  const workspaceAndLocation = await getWorkspaceAndLocation();
+  if (!workspaceAndLocation) {
+    return;
+  }
+  const {
+    location
+  } = workspaceAndLocation;
+  if (location.type === 'file' && !(await exists(location.uri))) {
+    return;
+  }
+  await mutate(oldEnablement => ({
+    disabledIds: oldEnablement.disabledIds.filter(item => item !== id),
+    enabledIds: oldEnablement.enabledIds.filter(item => item !== id),
+    hasWorkspace: true
+  }), false);
+};
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const withDisabledState = (extensions, disabledIds, enabledIds = []) => {
+  if (disabledIds.length === 0 && enabledIds.length === 0) {
+    return extensions;
+  }
+  const disabledIdsSet = new Set(disabledIds);
+  const enabledIdsSet = new Set(enabledIds);
+  return extensions.map(extension => {
+    if (disabledIdsSet.has(extension.id)) {
+      return {
+        ...extension,
+        disabled: true
+      };
+    }
+    if (enabledIdsSet.has(extension.id) && extension.disabled === true) {
+      return {
+        ...extension,
+        disabled: false
+      };
+    }
+    return extension;
+  });
+};
+const getExtensionsWithState = async (extensions, extensionsState, platform) => {
+  if (extensionsState.applicationId !== undefined) {
+    const byId = new Map(extensions.map(extension => [extension.id, extension]));
+    return withDisabledState(byId.values().toArray(), extensionsState.disabledIds).map(extension => ({
+      ...extension,
+      applicationGeneration: extensionsState.applicationGeneration,
+      applicationId: extensionsState.applicationId
+    }));
+  }
+  if (extensions.length === 0) {
+    return extensions;
+  }
+  const {
+    disabledIds,
+    enabledIds
+  } = await getExtensionEnablement(extensionsState, platform);
+  const extensionsWithDisabledState = withDisabledState(extensions, disabledIds, enabledIds);
+  if (platform === Test) {
+    return extensionsWithDisabledState;
+  }
+  const {
+    disabledIds: workspaceDisabledIds,
+    enabledIds: workspaceEnabledIds
+  } = await getWorkspaceExtensionEnablementSafe();
+  return withDisabledState(extensionsWithDisabledState, workspaceDisabledIds, workspaceEnabledIds);
+};
+const getAllExtensionsWithState = async (extensionsState, assetDir, platform) => {
+  const {
+    assetDir: resolvedAssetDir,
+    platform: resolvedPlatform
+  } = await getRuntimeContext(assetDir, platform);
+  string(resolvedAssetDir);
+  number(resolvedPlatform);
+  const meta = extensionsState.webExtensions;
+  if (resolvedPlatform === Web) {
+    const webExtensions = await getWebExtensions(resolvedAssetDir);
+    const compatibleExtensions = [...webExtensions, ...meta].filter(extension => isExtensionCompatible(extension, resolvedPlatform));
+    return getExtensionsWithState(compatibleExtensions, extensionsState, resolvedPlatform);
+  }
+  const local = await invoke$3('ExtensionManagement.getAllExtensions');
+  return getExtensionsWithState([...local, ...meta], extensionsState, resolvedPlatform);
+};
+
 const getOrigin = () => {
   return globalThis.location?.origin || 'http://localhost';
 };
@@ -2124,6 +2212,37 @@ const getContentSecurityPolicy = (directives, absolutePath, rpcInfos) => {
   return `default-src 'none'; script-src ${[...scriptSources].join(' ')}; worker-src 'none'; child-src 'none'; connect-src ${connectDirective};`;
 };
 
+const getExtensionAbsolutePath = (id, isWeb, isBuiltin, path, relativePath, origin, platform, assetDir) => {
+  if (path.startsWith('http')) {
+    if (path.endsWith('/')) {
+      return new URL(relativePath, path).href;
+    }
+    return new URL(relativePath, path + '/').href;
+  }
+  if (!path.startsWith('/')) {
+    path = '/' + path;
+  }
+  if (isWeb) {
+    return path + '/' + relativePath;
+  }
+  if (platform === Web) {
+    return path + '/' + relativePath;
+  }
+  if (isBuiltin) {
+    return `${assetDir}/extensions/${id}/${relativePath}`;
+  }
+  return new URL('/remote' + path + '/' + relativePath, origin).href;
+};
+
+const sourcePathMarker = '/extension-management-worker/src/';
+const getExtensionHostSubWorkerUrl = (currentUrl = import.meta.url) => {
+  const relativePath = currentUrl.includes(sourcePathMarker) ? '../../../../extension-host-sub-worker/src/extensionHostSubWorkerMain.js' : '../../extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
+  return new URL(relativePath, currentUrl).href;
+};
+const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
+
+// TODO
+
 const getUrlPrefix = (platform, extensionPath) => {
   if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
     return extensionPath;
@@ -2137,13 +2256,21 @@ const getUrlPrefix = (platform, extensionPath) => {
   return `/remote/${extensionPath}`;
 };
 
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+const invoke$2 = (method, ...params) => {
+  return invoke$4(method, ...params);
+};
+const invokeAndTransfer = (method, ...params) => {
+  return invokeAndTransfer$1(method, ...params);
+};
+
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
-const applications = new Map();
+const applications$1 = new Map();
 const getServices = application => {
   assertCurrentApplication(application);
   const generation = application.applicationGeneration;
-  let services = applications.get(generation);
+  let services = applications$1.get(generation);
   if (!services) {
     services = {
       children: new Map(),
@@ -2152,11 +2279,11 @@ const getServices = application => {
       nextChild: 0,
       ports: new Map()
     };
-    applications.set(generation, services);
+    applications$1.set(generation, services);
   }
   return services;
 };
-const register = (extension, platform) => {
+const register$1 = (extension, platform) => {
   const application = get$7(extension.applicationId);
   assertCurrentApplication(extension);
   const services = getServices(application);
@@ -2190,7 +2317,7 @@ const createWorker$1 = async (application, info, port, legacy = false, extension
     if (!services.children.has(id)) throw new Error('Extension worker was disposed during launch');
   } catch (error) {
     services.children.delete(id);
-    await invoke('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', id);
+    await invoke$2('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', id);
     throw error;
   }
 };
@@ -2208,7 +2335,7 @@ const createFileSystemPort = async (application, port, extensionId) => {
     assertCurrentApplication(application);
     const method = command.startsWith('FileSystem.') ? command.slice('FileSystem.'.length) : '';
     if (!fileSystemMethods.has(method)) throw new Error(`Unsupported application filesystem command: ${command}`);
-    const value = await invoke('Application.execute', application.applicationId, command, ...args);
+    const value = await invoke$2('Application.execute', application.applicationId, command, ...args);
     return method === 'stat' ? value.type : value;
   };
   try {
@@ -2223,10 +2350,10 @@ const createFileSystemPort = async (application, port, extensionId) => {
   }
 };
 const dispose = async application => {
-  const services = applications.get(application.applicationGeneration);
+  const services = applications$1.get(application.applicationGeneration);
   if (!services) return;
-  applications.delete(application.applicationGeneration);
-  const results = await Promise.allSettled([...Array.from(services.ports.keys(), rpc => Promise.try(() => rpc.dispose())), ...Array.from(services.children.keys(), id => invoke('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', id))]);
+  applications$1.delete(application.applicationGeneration);
+  const results = await Promise.allSettled([...Array.from(services.ports.keys(), rpc => Promise.try(() => rpc.dispose())), ...Array.from(services.children.keys(), id => invoke$2('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', id))]);
   services.ports.clear();
   services.children.clear();
   services.declarations.clear();
@@ -2234,7 +2361,7 @@ const dispose = async application => {
   if (errors.length > 0) throw new AggregateError(errors, 'Failed to dispose application services');
 };
 const disposeExtension = async (application, extensionId) => {
-  const services = applications.get(application.applicationGeneration);
+  const services = applications$1.get(application.applicationGeneration);
   if (!services) return;
   services.extensionVersions.set(extensionId, (services.extensionVersions.get(extensionId) || 0) + 1);
   const ports = [...services.ports].filter(([, owner]) => owner === extensionId).map(([rpc]) => rpc);
@@ -2244,39 +2371,94 @@ const disposeExtension = async (application, extensionId) => {
   for (const [id, info] of services.declarations) {
     if (info.extensionId === extensionId) services.declarations.delete(id);
   }
-  const results = await Promise.allSettled([...ports.map(rpc => Promise.try(() => rpc.dispose())), ...children.map(id => invoke('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', id))]);
+  const results = await Promise.allSettled([...ports.map(rpc => Promise.try(() => rpc.dispose())), ...children.map(id => invoke$2('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', id))]);
   const errors = results.filter(result => result.status === 'rejected').map(result => result.reason);
   if (errors.length > 0) throw new AggregateError(errors, `Failed to dispose extension services: ${extensionId}`);
 };
 
 const rpcs$1 = Object.create(null);
+const add$1 = (id, rpc) => {
+  rpcs$1[id] = rpc;
+};
+const get$3 = id => {
+  return rpcs$1[id];
+};
+
+const handleRpcInfos = (extension, platform) => {
+  if (extension?.applicationId !== undefined) {
+    if (Array.isArray(extension.rpc) && extension.rpc.length > 0) {
+      register$1(extension, platform);
+    }
+    return;
+  }
+  try {
+    if (!extension) {
+      return;
+    }
+    const rpcs = extension.rpc;
+    if (!rpcs) {
+      return;
+    }
+    if (!Array.isArray(rpcs)) {
+      return;
+    }
+    if (typeof extension.id === 'string') {
+      set$5({
+        ...extension,
+        rpc: rpcs.map(rpc => ({
+          ...rpc
+        }))
+      });
+    }
+    const urlPrefix = getUrlPrefix(platform, extension.path);
+    for (const rpc of rpcs) {
+      if (rpc.type === 'node' || rpc.type === 'node-process') {
+        continue;
+      }
+      rpc.url = `${urlPrefix}/${rpc.url}`;
+      add$1(rpc.id, rpc);
+    }
+  } catch (error) {
+    console.warn(`Failed to handle extension rpcs: ${error}`);
+  }
+};
+
+const NewLine = '\n';
+const Slash = '/';
+
+const interExtensionId = path => {
+  const slashIndex = path.lastIndexOf(Slash);
+  return path.slice(slashIndex + 1);
+};
+
+const rpcs = Object.create(null);
 const applicationRpcs = new Map();
-const get$3 = (extensionId, applicationId) => {
+const get$2 = (extensionId, applicationId) => {
   if (applicationId !== undefined) {
     return applicationRpcs.get(applicationId)?.get(extensionId);
   }
-  return rpcs$1[extensionId];
+  return rpcs[extensionId];
 };
-const getAll = applicationId => {
+const getAll$1 = applicationId => {
   if (applicationId !== undefined) {
     return [...(applicationRpcs.get(applicationId)?.values() || [])];
   }
-  return Object.values(rpcs$1);
+  return Object.values(rpcs);
 };
 const getIds = applicationId => {
   if (applicationId !== undefined) {
     return [...(applicationRpcs.get(applicationId)?.keys() || [])];
   }
-  return Object.keys(rpcs$1);
+  return Object.keys(rpcs);
 };
-const set$2 = (extensionId, rpc, applicationId) => {
+const set$4 = (extensionId, rpc, applicationId) => {
   if (applicationId !== undefined) {
     const entries = applicationRpcs.get(applicationId) || new Map();
     entries.set(extensionId, rpc);
     applicationRpcs.set(applicationId, entries);
     return;
   }
-  rpcs$1[extensionId] = rpc;
+  rpcs[extensionId] = rpc;
 };
 const remove$1 = (extensionId, applicationId) => {
   if (applicationId !== undefined) {
@@ -2288,720 +2470,669 @@ const remove$1 = (extensionId, applicationId) => {
     }
     return rpc;
   }
-  const rpc = rpcs$1[extensionId];
-  delete rpcs$1[extensionId];
+  const rpc = rpcs[extensionId];
+  delete rpcs[extensionId];
   return rpc;
 };
-const clear = applicationId => {
+const clear$1 = applicationId => {
   if (applicationId !== undefined) {
     applicationRpcs.delete(applicationId);
     return;
   }
-  for (const key of Object.keys(rpcs$1)) {
-    delete rpcs$1[key];
+  for (const key of Object.keys(rpcs)) {
+    delete rpcs[key];
   }
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+const notifyRunningExtensionsChanged = applicationId => {
+  setTimeout(() => {
+    const notification = applicationId === undefined ? invoke$4('Layout.handleExtensionsChanged') : invoke$4('Application.execute', applicationId, 'Layout.handleExtensionsChanged');
+    void Promise.resolve(notification).catch(() => {});
+  }, 0);
+};
 
-const pendingRpcs = Object.create(null);
-const getPendingExtensionIds = application => {
-  return Object.keys(pendingRpcs).flatMap(key => {
-    const [applicationId, generation, extensionId] = JSON.parse(key);
-    return applicationId === application.applicationId && generation === application.applicationGeneration ? [extensionId] : [];
-  });
+const getExtensionId$3 = extension => {
+  return extension.id || interExtensionId(extension.uri || extension.path || '');
 };
-const getRuntimeId = (extensionId, application) => {
-  return application?.applicationId === undefined ? extensionId : JSON.stringify([application.applicationId, application.applicationGeneration, extensionId]);
+const getAbsolutePath$1 = (extension, assetDir, platform) => {
+  return getExtensionAbsolutePath(getExtensionId$3(extension), extension.isWeb === true, extension.builtin === true, extension.path || extension.uri || '', extension.browser || '', getOrigin(), platform, assetDir);
 };
-const bindCommandMap = (rpc, commandMap) => {
-  if (rpc.ipc) {
-    rpc.ipc.execute = createExtensionCommandExecutor(commandMap);
+const getRpc$1 = async (extension, assetDir, platform, activationEvent = '', getOrCreate = getOrCreateIsolatedExtensionHostWorker, notify = notifyRunningExtensionsChanged) => {
+  if (extension.applicationId !== undefined) {
+    assertCurrentApplication(extension);
+  }
+  const extensionId = getExtensionId$3(extension);
+  const existingRpc = get$2(extensionId, extension.applicationId);
+  if (existingRpc) {
+    return existingRpc;
+  }
+  handleRpcInfos(extension, platform);
+  const absolutePath = getAbsolutePath$1(extension, assetDir, platform);
+  const contentSecurityPolicy = getContentSecurityPolicy(extension.contentSecurityPolicy, absolutePath, extension.rpc);
+  const rpc = await activateIsolatedExtension(extensionId, absolutePath, extension.workerName || '', contentSecurityPolicy, activationEvent, getOrCreate, extension.applicationId);
+  if (extension.applicationId === undefined) {
+    notify();
+  } else {
+    notify(extension.applicationId);
   }
   return rpc;
 };
-const createIsolatedExtensionHostWorker = async (extensionId, absolutePath, workerName, contentSecurityPolicy, createRpc, invokeAndTransfer, application) => {
-  const runtimeId = getRuntimeId(extensionId, application);
-  const invokeCommand = application === undefined ? undefined : (method, ...args) => {
-    assertCurrentApplication(application);
-    if (method === 'Extensions.registerFileChangeHandler') {
-      return register$1(extensionId, application.applicationId);
-    }
-    if (method === 'Extensions.unregisterFileChangeHandler') {
-      return unregister(extensionId, application.applicationId);
-    }
-    if (method === 'Extensions.sendMessagePortToFileSystemWorker') {
-      return createFileSystemPort(application, args[0], extensionId);
-    }
-    if (method === 'Extensions.createWebViewWorkerRpc' || method === 'Extensions.createWebViewWorkerRpc2') {
-      return createWorker$1(application, args[0], args[1], method === 'Extensions.createWebViewWorkerRpc', extensionId);
-    }
-    const invokeApplication = commandMapRef['Extensions.invokeForApplication'];
-    if (!invokeApplication) {
-      throw new Error('Application extension command routing is not initialized');
-    }
-    return invokeApplication(application.applicationId, method, ...args);
+
+const getWorkspaceUri = async () => {
+  const uri = await invoke$4('Workspace.getUri');
+  return typeof uri === 'string' ? uri : '';
+};
+const isRemoteUri = uri => /^[a-z][a-z0-9+.-]*:\/\//i.test(uri) && !uri.startsWith('file://');
+const getRemoteWorkspaceUri = async () => {
+  const uri = await getWorkspaceUri();
+  return isRemoteUri(uri) ? uri : '';
+};
+const findTransport = async workspaceUri => {
+  const extensionsState = get$7();
+  const {
+    assetDir,
+    platform
+  } = await getRuntimeContext('', extensionsState.platform);
+  const extensions = await getAllExtensionsWithState(extensionsState, assetDir, platform);
+  const scheme = new URL(workspaceUri).protocol.slice(0, -1);
+  const extension = extensions.find(candidate => !candidate.disabled && candidate.isolated === true && candidate.workspaceTransport?.scheme === scheme);
+  return {
+    assetDir,
+    extension,
+    platform
   };
-  const commandMap = createExtensionCommandMap(runtimeId, invokeCommand);
-  const rpc = await createRpc({
-    // PlainMessagePortRpc registers this map process-wide. Bind the restricted
-    // callbacks to this port below, never to the shared host command table.
-    commandMap: {},
-    isMessagePortOpen: true,
-    send(port) {
-      return invokeAndTransfer('LaunchIsolatedExtensionHostWorker.launchIsolatedExtensionHostWorker', port, runtimeId, absolutePath, workerName, contentSecurityPolicy);
-    }
-  });
-  return bindCommandMap(rpc, commandMap);
 };
-const createWorker = (extensionId, absolutePath, workerName, contentSecurityPolicy, application) => {
-  return createIsolatedExtensionHostWorker(extensionId, absolutePath, workerName, contentSecurityPolicy, create$6, invokeAndTransfer, application);
+const getWorkspaceTransportUri = async () => {
+  const uri = await getRemoteWorkspaceUri();
+  if (!uri) {
+    return '';
+  }
+  const {
+    extension
+  } = await findTransport(uri);
+  return extension?.workspaceTransport?.command ? uri : '';
 };
-const createAndStoreRpc = async (extensionId, absolutePath, workerName, contentSecurityPolicy, create, application) => {
+const getTransport = async workspaceUri => {
+  const {
+    assetDir,
+    extension,
+    platform
+  } = await findTransport(workspaceUri);
+  if (!extension?.workspaceTransport?.command) {
+    throw new Error(`No workspace transport for ${new URL(workspaceUri).protocol}`);
+  }
+  const rpc = await getRpc$1(extension, assetDir, platform);
+  return {
+    command: extension.workspaceTransport.command,
+    rpc
+  };
+};
+const connect = async (workspaceUri, type, port, params = {}) => {
   try {
-    const rpc = application === undefined ? await create(extensionId, absolutePath, workerName, contentSecurityPolicy) : await create(extensionId, absolutePath, workerName, contentSecurityPolicy, application);
-    if (application !== undefined) {
-      try {
-        assertCurrentApplication(application);
-      } catch (error) {
-        await Promise.allSettled([rpc.dispose(), invoke('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', getRuntimeId(extensionId, application))]);
-        throw error;
-      }
+    if (!isRemoteUri(workspaceUri)) {
+      throw new Error('A remote workspace is required');
     }
-    set$2(extensionId, rpc, application?.applicationId);
-    return rpc;
+    const {
+      command,
+      rpc
+    } = await getTransport(workspaceUri);
+    if (workspaceUri !== (await getWorkspaceUri())) {
+      throw new Error('Workspace changed while connecting the remote process');
+    }
+    await rpc.invokeAndTransfer('ExtensionApi.executeCommand', command, workspaceUri, type, port, params);
   } catch (error) {
-    console.error(`[extension-management-worker] ${extensionId} failed to activate`, error);
+    port.close();
     throw error;
   }
 };
-const getOrCreateIsolatedExtensionHostWorker = async (extensionId, absolutePath, workerName = '', contentSecurityPolicy = '', create = createWorker, applicationId) => {
-  const application = applicationId === undefined ? undefined : get$7(applicationId);
-  const existingRpc = get$3(extensionId, applicationId);
-  if (existingRpc) {
-    return existingRpc;
-  }
-  const key = JSON.stringify([applicationId ?? null, application?.applicationGeneration ?? null, extensionId]);
-  const pendingRpc = pendingRpcs[key];
-  if (pendingRpc !== undefined) {
-    return pendingRpc;
+const connectTerminal = async (workspaceUri, port) => {
+  await connect(workspaceUri, 'terminal-process', port);
+};
+const request = async (workspaceUri, type, ...args) => {
+  if (!isRemoteUri(workspaceUri) || !['text-search', 'file-search', 'terminal-options'].includes(type)) {
+    throw new Error('Unsupported workspace request');
   }
-  const newRpc = createAndStoreRpc(extensionId, absolutePath, workerName, contentSecurityPolicy, create, application);
-  pendingRpcs[key] = newRpc;
-  try {
-    return await newRpc;
-  } finally {
-    if (pendingRpcs[key] === newRpc) {
-      delete pendingRpcs[key];
-    }
+  const {
+    assetDir,
+    extension,
+    platform
+  } = await findTransport(workspaceUri);
+  const command = extension?.workspaceTransport?.requestCommand;
+  if (!extension || !command) {
+    throw new Error('Workspace transport does not support requests');
   }
+  const rpc = await getRpc$1(extension, assetDir, platform);
+  return rpc.invoke('ExtensionApi.executeCommand', command, workspaceUri, type, ...args);
 };
 
-const activateIsolatedExtension = async (extensionId, absolutePath, workerName, contentSecurityPolicy, activationEvent, getOrCreate = getOrCreateIsolatedExtensionHostWorker, applicationId) => {
-  const application = applicationId === undefined ? undefined : get$7(applicationId);
-  const updateStatus = status => {
-    if (applicationId === undefined) {
-      updateRuntimeStatus(extensionId, status);
-      return;
-    }
-    const current = get$7(applicationId);
-    if (current.applicationGeneration !== application?.applicationGeneration) {
-      throw new Error(`Stale extension application: ${applicationId}`);
-    }
-    updateRuntimeStatus(extensionId, status, applicationId);
-  };
-  const startTime = performance.now();
-  updateStatus({
-    activationEvent,
-    activationStartTime: startTime,
-    status: Activating
-  });
+const isMissingRendererCommand = (error, command) => {
+  const moduleName = command.slice(0, command.indexOf('.'));
+  return error instanceof Error && (error.message.includes(command) || error.message.includes(`module ${moduleName} not found`)) && /command not found|not found/i.test(error.message);
+};
+const createUnsupportedDirectLaunchError = rpcId => {
+  return new Error(`Node process ${rpcId} requires direct renderer support`);
+};
+const createRemoteConnection = async (extensionId, rpcId) => {
   try {
-    const rpc = applicationId === undefined ? await getOrCreate(extensionId, absolutePath, workerName, contentSecurityPolicy) : await getOrCreate(extensionId, absolutePath, workerName, contentSecurityPolicy, undefined, applicationId);
-    const endTime = performance.now();
-    updateStatus({
-      activationEndTime: endTime,
-      activationTime: endTime - startTime,
-      status: Activated
-    });
-    return rpc;
+    const connectionInfo = await invoke$4('ExtensionNodeRpc.createConnection', extensionId, rpcId);
+    return {
+      ...connectionInfo,
+      type: 'websocket'
+    };
   } catch (error) {
-    if (application === undefined || isCurrentApplication(application)) {
-      updateStatus({
-        error: getErrorMessage(error),
-        status: Error$1
-      });
+    if (isMissingRendererCommand(error, 'ExtensionNodeRpc.createConnection')) {
+      throw createUnsupportedDirectLaunchError(rpcId);
     }
     throw error;
   }
 };
-
-const rpcs = Object.create(null);
-const add = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$2 = id => {
-  return rpcs[id];
-};
-
-const handleRpcInfos = (extension, platform) => {
-  if (extension?.applicationId !== undefined) {
-    if (Array.isArray(extension.rpc) && extension.rpc.length > 0) {
-      register(extension, platform);
-    }
-    return;
-  }
+const createElectronConnection = async rpcId => {
   try {
-    if (!extension) {
-      return;
-    }
-    const rpcs = extension.rpc;
-    if (!rpcs) {
-      return;
-    }
-    if (!Array.isArray(rpcs)) {
-      return;
-    }
-    if (typeof extension.id === 'string') {
-      set$5({
-        ...extension,
-        rpc: rpcs.map(rpc => ({
-          ...rpc
-        }))
-      });
-    }
-    const urlPrefix = getUrlPrefix(platform, extension.path);
-    for (const rpc of rpcs) {
-      if (rpc.type === 'node' || rpc.type === 'node-process') {
-        continue;
-      }
-      rpc.url = `${urlPrefix}/${rpc.url}`;
-      add(rpc.id, rpc);
+    const supported = await invoke$4('ExtensionNodeRpc.supportsDirectConnection');
+    if (!supported) {
+      throw createUnsupportedDirectLaunchError(rpcId);
     }
+    return {
+      type: 'message-port'
+    };
   } catch (error) {
-    console.warn(`Failed to handle extension rpcs: ${error}`);
+    if (isMissingRendererCommand(error, 'ExtensionNodeRpc.supportsDirectConnection')) {
+      throw createUnsupportedDirectLaunchError(rpcId);
+    }
+    throw error;
   }
 };
-
-const NewLine = '\n';
-const Slash = '/';
-
-const interExtensionId = path => {
-  const slashIndex = path.lastIndexOf(Slash);
-  return path.slice(slashIndex + 1);
-};
-
-const isExtensionIsolated = extension => {
-  return extension?.isolated === true;
-};
-
-const activateExtension3 = async (extension, absolutePath, activationEvent, platform) => {
-  if (extension.applicationId !== undefined) {
-    assertCurrentApplication(extension);
+const createNodeRpcConnection = async (extensionId, rpcId) => {
+  const declaration = validateNodeProcessRpc(extensionId, rpcId);
+  if (declaration.onRemote === 'runOnRemote' && (await getRemoteWorkspaceUri())) {
+    return {
+      type: 'message-port'
+    };
   }
-  const extensionId = extension.id || interExtensionId(extension.uri);
-  if (!isExtensionIsolated(extension)) {
-    throw new Error(`Extension ${extensionId} does not use the isolated extension API`);
+  const {
+    platform
+  } = get$7();
+  if (platform !== Remote && platform !== Electron) {
+    throw new Error('Node rpc is not available on this platform');
   }
-  handleRpcInfos(extension, platform);
-  const contentSecurityPolicy = getContentSecurityPolicy(extension.contentSecurityPolicy, absolutePath, extension.rpc);
-  if (extension.applicationId === undefined) {
-    await activateIsolatedExtension(extensionId, absolutePath, extension.workerName || '', contentSecurityPolicy, activationEvent);
-  } else {
-    await activateIsolatedExtension(extensionId, absolutePath, extension.workerName || '', contentSecurityPolicy, activationEvent, undefined, extension.applicationId);
+  if (platform === Remote) {
+    return createRemoteConnection(extensionId, rpcId);
   }
+  return createElectronConnection(rpcId);
 };
-
-const ContentType = 'Content-Type';
-const ContentLength = 'Content-Length';
-
-const createResponseFromData = data => {
-  const responseString = JSON.stringify(data);
-  const response = new Response(responseString, {
-    headers: {
-      [ContentLength]: String(responseString.length),
-      [ContentType]: 'application/json'
+const createNodeRpcMessagePort = async (extensionId, rpcId, port) => {
+  const declaration = validateNodeProcessRpc(extensionId, rpcId);
+  if (declaration.onRemote === 'runOnRemote') {
+    const workspaceUri = await getRemoteWorkspaceUri();
+    if (workspaceUri) {
+      await connect(workspaceUri, 'extension-node-process', port, {
+        extensionId,
+        rpcId
+      });
+      return;
     }
-  });
-  return response;
-};
-
-const cacheName = 'Extensions'; // TODO
-
-const getJson$1 = async cacheKey => {
-  const response = await caches.match(cacheKey, {
-    cacheName
-  });
-  if (!response) {
-    return undefined;
   }
-  const json = await response.json();
-  return json;
-};
-const setJson = async (cacheKey, data) => {
-  try {
-    const cache = await caches.open(cacheName);
-    const response = createResponseFromData(data);
-    await cache.put(cacheKey, response);
-  } catch (error) {
-    throw new VError(error, `Failed to add to cache`);
+  const {
+    platform
+  } = get$7();
+  if (platform !== Electron) {
+    throw new Error('Node rpc message ports are only available in Electron');
   }
+  validateNodeProcessRpc(extensionId, rpcId);
+  await invokeAndTransfer$1('ExtensionNodeRpc.createMessagePort', port, extensionId, rpcId);
 };
 
-const disabledExtensionsCacheKey = '/cache/disabledExtensions.json';
-
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-
-const getStringArray$2 = value => {
-  if (!Array.isArray(value)) {
-    return [];
+const extensionIds = new Set();
+const applications = new Map();
+const register = (extensionId, applicationId) => {
+  if (applicationId === undefined) {
+    extensionIds.add(extensionId);
+    return;
   }
-  return value.filter(id => typeof id === 'string');
-};
-const getExtensionEnablementFromData = data => {
-  return {
-    disabledIds: getStringArray$2(data?.disabledExtensions),
-    enabledIds: getStringArray$2(data?.enabledExtensions)
-  };
+  const ids = applications.get(applicationId) || new Set();
+  ids.add(extensionId);
+  applications.set(applicationId, ids);
 };
-const getWebExtensionEnablement = async () => {
-  try {
-    const cached = await getJson$1(disabledExtensionsCacheKey);
-    return getExtensionEnablementFromData(cached);
-  } catch {
-    return getExtensionEnablementFromData(undefined);
+const unregister = (extensionId, applicationId) => {
+  if (applicationId === undefined) {
+    extensionIds.delete(extensionId);
+    return;
   }
-};
-const getRemoteExtensionEnablement = async () => {
-  try {
-    const uri = await invoke$4('WebView.compatSharedProcessInvoke', 'PlatformPaths.getDisabledExtensionsJsonUri');
-    const exists$1 = await exists(uri);
-    if (!exists$1) {
-      return getExtensionEnablementFromData(undefined);
-    }
-    const content = await readFile$1(uri);
-    return getExtensionEnablementFromData(JSON.parse(content));
-  } catch {
-    return getExtensionEnablementFromData(undefined);
+  const ids = applications.get(applicationId);
+  ids?.delete(extensionId);
+  if (ids?.size === 0) {
+    applications.delete(applicationId);
   }
 };
-const getExtensionEnablement = async (extensionsState, platform) => {
-  if (platform === Test) {
-    return {
-      disabledIds: extensionsState.disabledIds,
-      enabledIds: []
-    };
-  }
-  if (platform === Web) {
-    return getWebExtensionEnablement();
-  }
-  if (platform === Remote || platform === Electron) {
-    return getRemoteExtensionEnablement();
+const getRegisteredExtensionIds = applicationId => {
+  return [...(applicationId === undefined ? extensionIds : applications.get(applicationId) || [])];
+};
+const reset = applicationId => {
+  if (applicationId === undefined) {
+    extensionIds.clear();
+  } else {
+    applications.delete(applicationId);
   }
-  return getExtensionEnablementFromData(undefined);
 };
 
-const isMissingAssetDir = assetDir => {
-  return typeof assetDir !== 'string' || assetDir.length === 0;
+const prefix = '[Extension] Uncaught Error: ';
+const handleUncaughtExtensionError = async error => {
+  const prettyError = await invoke$7('Errors.prepare', error);
+  await invoke$7('Errors.print', prettyError, prefix);
 };
-const isMissingPlatform = platform => {
-  return typeof platform !== 'number' || platform === 0;
+
+const state$3 = {
+  nextId: 1,
+  notifications: []
 };
-const isStaticHttpAssetDir = assetDir => {
-  return assetDir.startsWith('/') || assetDir.startsWith('http');
+const add = (extensionId, type, message) => {
+  const notification = {
+    extensionId,
+    id: state$3.nextId++,
+    message,
+    type
+  };
+  state$3.notifications = [...state$3.notifications, notification];
+  return notification;
 };
-const isHttpLocation = () => {
-  return Reflect.has(globalThis, 'location') && globalThis.location.protocol.startsWith('http');
+const clear = () => {
+  state$3.notifications = [];
 };
-const getRuntimeContext = async (assetDir, platform) => {
-  const shouldInferPlatform = isMissingPlatform(platform);
-  const resolvedAssetDir = isMissingAssetDir(assetDir) ? await invoke$4('Layout.getAssetDir') : assetDir;
-  const resolvedPlatform = shouldInferPlatform ? await invoke$4('Layout.getPlatform') : platform;
-  if (shouldInferPlatform && isHttpLocation() && isStaticHttpAssetDir(resolvedAssetDir)) {
-    return {
-      assetDir: resolvedAssetDir,
-      platform: Web
-    };
-  }
-  return {
-    assetDir: resolvedAssetDir,
-    platform: resolvedPlatform
-  };
+const dismiss = id => {
+  state$3.notifications = state$3.notifications.filter(notification => notification.id !== id);
 };
-
-const getResponseErrorMessage = response => {
-  return response.statusText || String(response.status) || 'Request failed';
+const getAll = () => {
+  return state$3.notifications;
 };
-const getJson = async url => {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(getResponseErrorMessage(response));
-    }
-    const json = await response.json();
-    return json;
-  } catch (error) {
-    throw new VError(error, `Failed to get json`);
-  }
+const removeByExtension = extensionId => {
+  state$3.notifications = state$3.notifications.filter(notification => notification.extensionId !== extensionId);
 };
 
-const getWebExtensionsUrl = assetDir => {
-  return `${assetDir}/config/extensions.json`;
+const state$2 = {
+  rpc: undefined
 };
-
-const getWebExtensions = async assetDir => {
-  try {
-    return await getJson(getWebExtensionsUrl(assetDir));
-  } catch {
-    return [];
-  }
+const set$3 = value => {
+  state$2.rpc = value;
 };
-
-const isExtensionCompatible = (extension, platform) => {
-  return platform !== Web || extension?.compatibility?.web !== false;
+const invoke$1 = async (method, ...params) => {
+  await state$2.rpc?.invoke(method, ...params);
 };
 
-const WorkspacesFolderName = 'workspaces';
-const ExtensionEnablementFileName = 'extension-enablement.json';
-const CacheKeyPrefix = '/cache/workspaces';
-const UriSchemeRegex = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
-const WindowsDrivePathRegex = /^[a-zA-Z]:[\\/]/;
-const WindowsDriveSegmentRegex = /^[a-zA-Z]:$/;
-const EmptyEnablement = {
-  disabledIds: [],
-  enabledIds: [],
-  hasWorkspace: false
+const state$1 = {
+  rpc: undefined
 };
-const cache$1 = new Map();
-const mutationQueues = new Map();
-const encodePathSegment = (segment, index) => {
-  if (index === 0 && WindowsDriveSegmentRegex.test(segment)) {
-    return segment;
-  }
-  return encodeURIComponent(segment);
+const set$2 = value => {
+  state$1.rpc = value;
 };
-const encodeFilePath = path => {
-  return path.split('/').map(encodePathSegment).join('/');
+const invoke = async (method, ...params) => {
+  await state$1.rpc?.invoke(method, ...params);
 };
-const toWorkspaceUri = workspacePath => {
-  if (WindowsDrivePathRegex.test(workspacePath)) {
-    return `file:///${encodeFilePath(workspacePath.replaceAll('\\', '/'))}`;
-  }
-  if (UriSchemeRegex.test(workspacePath)) {
-    return workspacePath;
-  }
-  if (workspacePath.startsWith('/')) {
-    return `file://${encodeFilePath(workspacePath)}`;
-  }
-  return workspacePath;
+
+const notifyNotificationsChanged = async () => {
+  const notifications = getAll();
+  await Promise.all([invoke$1('NotificationCenter.handleNotificationsChanged', notifications), invoke('StatusBar.handleNotificationCountChanged', notifications.length)]);
 };
-const joinUri = (base, ...parts) => {
-  const normalizedBase = base.endsWith('/') ? base.slice(0, -1) : base;
-  return [normalizedBase, ...parts].join('/');
+
+const getPreference = async key => {
+  return invoke$4('Preferences.get', key);
 };
-const hashWorkspaceUri = async workspaceUri => {
-  const bytes = new TextEncoder().encode(workspaceUri);
-  const digest = await crypto.subtle.digest('SHA-256', bytes);
-  return Array.from(new Uint8Array(digest), value => value.toString(16).padStart(2, '0')).join('');
+const setPreference = async (key, value) => {
+  await invoke$4('Preferences.update', {
+    [key]: value
+  });
 };
-const getWorkspaceUri = async () => {
-  let workspacePath;
-  try {
-    workspacePath = await invoke$4('Workspace.getPath');
-  } catch {
-    return '';
+
+const hiddenExtensionIdsPreference = 'notifications.hiddenExtensionIds';
+const getHiddenExtensionIds = async () => {
+  const value = await getPreference(hiddenExtensionIdsPreference);
+  if (!Array.isArray(value)) {
+    return [];
   }
-  return typeof workspacePath === 'string' ? toWorkspaceUri(workspacePath) : '';
+  return value.filter(item => typeof item === 'string');
 };
-const getConfigUri = async () => {
-  const configUri = await invoke$4('WebView.compatSharedProcessInvoke', 'Platform.getConfigUri');
-  if (typeof configUri !== 'string' || configUri === '') {
-    throw new Error('Config uri is not available');
+const assertType = type => {
+  if (type !== 'error' && type !== 'info' && type !== 'warning') {
+    throw new TypeError(`Invalid notification type: ${type}`);
   }
-  return configUri;
 };
-const getStorageLocation = async workspaceUri => {
-  const workspaceHash = await hashWorkspaceUri(workspaceUri);
+const showPopup = async (type, message) => {
   try {
-    const configUri = await getConfigUri();
-    const directoryUri = joinUri(configUri, WorkspacesFolderName, workspaceHash);
-    const uri = joinUri(directoryUri, ExtensionEnablementFileName);
-    return {
-      directoryUri,
-      key: uri,
-      type: 'file',
-      uri
-    };
+    await invoke$2('Notification.create', type, message);
   } catch {
-    return {
-      key: joinUri(CacheKeyPrefix, workspaceHash, ExtensionEnablementFileName),
-      type: 'cache'
-    };
+    // Notification storage must keep working while an older renderer is connected.
   }
 };
-const getStringArray$1 = value => {
-  if (!Array.isArray(value)) {
-    return [];
+const clearNotifications = async () => {
+  clear();
+  await notifyNotificationsChanged();
+};
+const createNotification = async (extensionId, type, message) => {
+  string(extensionId);
+  string(type);
+  string(message);
+  assertType(type);
+  const hiddenExtensionIds = await getHiddenExtensionIds();
+  if (hiddenExtensionIds.includes(extensionId)) {
+    return;
   }
-  return value.filter(item => typeof item === 'string');
+  add(extensionId, type, message);
+  await Promise.all([notifyNotificationsChanged(), showPopup(type, message)]);
 };
-const parseEnablement = data => {
-  return {
-    disabledIds: getStringArray$1(data.disabledExtensions),
-    enabledIds: getStringArray$1(data.enabledExtensions),
-    hasWorkspace: true
-  };
+const dismissNotification = async id => {
+  number(id);
+  dismiss(id);
+  await notifyNotificationsChanged();
 };
-const readFromLocation = async location => {
-  if (location.type === 'cache') {
-    const data = await getJson$1(location.key);
-    return parseEnablement(data || {});
-  }
-  const exists$1 = await exists(location.uri);
-  if (!exists$1) {
-    return {
-      ...EmptyEnablement,
-      hasWorkspace: true
-    };
-  }
-  const content = await readFile$1(location.uri);
-  return parseEnablement(JSON.parse(content));
+const getNotificationCount = () => {
+  return getAll().length;
 };
-const readFromLocationCached = async location => {
-  const cached = cache$1.get(location.key);
-  if (cached) {
-    return cached;
+const getNotifications = () => {
+  return getAll();
+};
+const hideNotificationsFromExtension = async extensionId => {
+  string(extensionId);
+  const hiddenExtensionIds = await getHiddenExtensionIds();
+  if (!hiddenExtensionIds.includes(extensionId)) {
+    await setPreference(hiddenExtensionIdsPreference, [...hiddenExtensionIds, extensionId]);
   }
-  const promise = readFromLocation(location);
-  cache$1.set(location.key, promise);
-  try {
-    return await promise;
-  } catch (error) {
-    if (cache$1.get(location.key) === promise) {
-      cache$1.delete(location.key);
-    }
-    throw error;
+  removeByExtension(extensionId);
+  await notifyNotificationsChanged();
+};
+
+const cacheName = 'ExtensionSecrets';
+const getRequestUrl = (extensionId, key) => {
+  return `https://secret-storage.invalid/${encodeURIComponent(extensionId)}/${encodeURIComponent(key)}`;
+};
+const isElectron = () => {
+  return get$7().platform === Electron;
+};
+const deleteSecret = async (extensionId, key) => {
+  string(extensionId);
+  string(key);
+  if (isElectron()) {
+    await invoke$5('SecretStorage.delete', extensionId, key);
+    return;
   }
+  const cache = await caches.open(cacheName);
+  await cache.delete(getRequestUrl(extensionId, key));
 };
-const getWorkspaceAndLocation = async () => {
-  const workspaceUri = await getWorkspaceUri();
-  if (!workspaceUri) {
-    return undefined;
+const getSecret = async (extensionId, key) => {
+  string(extensionId);
+  string(key);
+  if (isElectron()) {
+    return invoke$5('SecretStorage.get', extensionId, key);
   }
-  const location = await getStorageLocation(workspaceUri);
-  return {
-    location,
-    workspaceUri
-  };
+  const cache = await caches.open(cacheName);
+  const response = await cache.match(getRequestUrl(extensionId, key));
+  return response?.text();
 };
-const writeToLocation = async (location, workspaceUri, enablement) => {
-  const data = {
-    disabledExtensions: enablement.disabledIds,
-    enabledExtensions: enablement.enabledIds,
-    workspace: workspaceUri
-  };
-  if (location.type === 'cache') {
-    await setJson(location.key, data);
-  } else {
-    const directoryExists = await exists(location.directoryUri);
-    if (!directoryExists) {
-      await mkdir(location.directoryUri);
-    }
-    await writeFile(location.uri, JSON.stringify(data, null, 2) + '\n');
+const storeSecret = async (extensionId, key, value) => {
+  string(extensionId);
+  string(key);
+  string(value);
+  if (isElectron()) {
+    await invoke$5('SecretStorage.store', extensionId, key, value);
+    return;
   }
-  cache$1.set(location.key, Promise.resolve(enablement));
+  const cache = await caches.open(cacheName);
+  await cache.put(getRequestUrl(extensionId, key), new Response(value));
 };
-const mutate = async (update, createIfMissing) => {
-  const workspaceAndLocation = await getWorkspaceAndLocation();
-  if (!workspaceAndLocation) {
-    throw new Error('Cannot change workspace extension enablement without an open workspace');
+
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    Object.defineProperty(this, 'name', {
+      value: 'CommandNotFoundError'
+    });
   }
-  const {
-    location,
-    workspaceUri
-  } = workspaceAndLocation;
-  const previousMutation = mutationQueues.get(location.key) || Promise.resolve();
-  const runMutation = async () => {
-    try {
-      await previousMutation;
-    } catch {
-      // A failed earlier mutation must not permanently block this workspace.
-    }
-    if (!createIfMissing && location.type === 'file' && !(await exists(location.uri))) {
-      return;
-    }
-    const oldEnablement = await readFromLocation(location);
-    const newEnablement = update(oldEnablement);
-    await writeToLocation(location, workspaceUri, newEnablement);
-  };
-  const mutation = runMutation();
-  mutationQueues.set(location.key, mutation);
+}
+const allowedElectronPortCommand = 'HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess';
+const workspaceSetUriCommand = 'Workspace.setUri';
+const privilegedCommandPrefixes = ['ElectronNet.', 'ClipBoard.', 'DebugSharedProcess.', 'Developer.', 'Electron', 'Exec.', 'ExtensionNodeRpc.', 'FileSystem', 'FileWatcher.', 'IpcParent.', 'PlatformPaths.', 'PersistentFileHandle.', 'Process.', 'RebuildNodePty.', 'SearchProcess.', 'SendMessagePort', 'SharedProcess.', 'TerminalProcess.', 'Transferrable.', 'WebSocketCapability.', 'WebView.compat'];
+const invokeGlobalCommand = (method, ...params) => {
+  const command = commandMapRef[method];
+  if (!command) {
+    throw new CommandNotFoundError(method);
+  }
+  return command(...params);
+};
+const executeDeferredCommand = async (invokeCommand, id, args) => {
   try {
-    await mutation;
-  } finally {
-    if (mutationQueues.get(location.key) === mutation) {
-      mutationQueues.delete(location.key);
-    }
+    await invokeCommand('Extensions.executeCommand', id, ...args);
+  } catch (error) {
+    await handleUncaughtExtensionError(error);
   }
 };
-const getWorkspaceExtensionEnablement = async () => {
-  const workspaceAndLocation = await getWorkspaceAndLocation();
-  if (!workspaceAndLocation) {
-    return EmptyEnablement;
+const executeCommand$1 = (invokeCommand, id, ...args) => {
+  if (privilegedCommandPrefixes.some(prefix => id.startsWith(prefix))) {
+    throw new Error(`Isolated extensions cannot execute privileged command ${id}`);
   }
-  return readFromLocationCached(workspaceAndLocation.location);
+  if (id === workspaceSetUriCommand) {
+    setTimeout(() => {
+      void executeDeferredCommand(invokeCommand, id, args).catch(() => {});
+    }, 0);
+    return undefined;
+  }
+  return invokeCommand('Extensions.executeCommand', id, ...args);
 };
-const getWorkspaceExtensionEnablementSafe = async () => {
-  try {
-    return await getWorkspaceExtensionEnablement();
-  } catch {
-    let workspaceUri = '';
-    try {
-      workspaceUri = await getWorkspaceUri();
-    } catch {
-      // Ignore unavailable workspace state while recovering from malformed storage.
-    }
+const createExtensionCommandMap = (extensionId, invokeCommand = invokeGlobalCommand) => {
+  const inheritedCommands = invokeCommand === invokeGlobalCommand ? commandMapRef : Object.fromEntries(Object.keys(commandMapRef).map(method => [method, (...args) => invokeCommand(method, ...args)]));
+  if (invokeCommand !== invokeGlobalCommand) {
+    // Application runtimes must not bypass the scoped router through a legacy
+    // callback (notifications, secrets, file watchers, or privileged node ports).
     return {
-      ...EmptyEnablement,
-      hasWorkspace: Boolean(workspaceUri)
+      ...inheritedCommands,
+      'Extensions.executeCommand': (id, ...args) => executeCommand$1(invokeCommand, id, ...args),
+      'Extensions.registerFileChangeHandler': () => invokeCommand('Extensions.registerFileChangeHandler'),
+      'Extensions.unregisterFileChangeHandler': () => invokeCommand('Extensions.unregisterFileChangeHandler')
     };
   }
+  return {
+    ...inheritedCommands,
+    'Extensions.createNodeRpcConnection'(rpcId) {
+      return createNodeRpcConnection(extensionId, rpcId);
+    },
+    'Extensions.createNodeRpcMessagePort'(rpcId, port) {
+      return createNodeRpcMessagePort(extensionId, rpcId, port);
+    },
+    'Extensions.deleteSecret'(key) {
+      return deleteSecret(extensionId, key);
+    },
+    'Extensions.executeCommand'(id, ...args) {
+      return executeCommand$1(invokeCommand, id, ...args);
+    },
+    'Extensions.getSecret'(key) {
+      return getSecret(extensionId, key);
+    },
+    'Extensions.registerFileChangeHandler'() {
+      register(extensionId);
+    },
+    'Extensions.sendMessagePortToElectron'(port, initialCommand) {
+      if (initialCommand !== allowedElectronPortCommand) {
+        throw new Error(`Isolated extensions cannot send a port using ${initialCommand}`);
+      }
+      return invokeGlobalCommand('Extensions.sendMessagePortToElectron', port, initialCommand);
+    },
+    'Extensions.showNotification'(type, message) {
+      return createNotification(extensionId, type, message);
+    },
+    'Extensions.storeSecret'(key, value) {
+      return storeSecret(extensionId, key, value);
+    },
+    'Extensions.unregisterFileChangeHandler'() {
+      unregister(extensionId);
+    }
+  };
 };
-const disableExtension$1 = async id => {
-  string(id);
-  await mutate(oldEnablement => ({
-    disabledIds: oldEnablement.disabledIds.includes(id) ? oldEnablement.disabledIds : [...oldEnablement.disabledIds, id],
-    enabledIds: oldEnablement.enabledIds.filter(item => item !== id),
-    hasWorkspace: true
-  }), true);
-};
-const enableExtension$1 = async id => {
-  string(id);
-  await mutate(oldEnablement => ({
-    disabledIds: oldEnablement.disabledIds.filter(item => item !== id),
-    enabledIds: oldEnablement.enabledIds.includes(id) ? oldEnablement.enabledIds : [...oldEnablement.enabledIds, id],
-    hasWorkspace: true
-  }), true);
-};
-const clearExtensionOverride = async id => {
-  string(id);
-  const workspaceAndLocation = await getWorkspaceAndLocation();
-  if (!workspaceAndLocation) {
-    return;
-  }
-  const {
-    location
-  } = workspaceAndLocation;
-  if (location.type === 'file' && !(await exists(location.uri))) {
-    return;
-  }
-  await mutate(oldEnablement => ({
-    disabledIds: oldEnablement.disabledIds.filter(item => item !== id),
-    enabledIds: oldEnablement.enabledIds.filter(item => item !== id),
-    hasWorkspace: true
-  }), false);
+const createExtensionCommandExecutor = commandMap => {
+  return (method, ...params) => {
+    const command = commandMap[method];
+    if (!command) {
+      throw new CommandNotFoundError(method);
+    }
+    return command(...params);
+  };
 };
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
-const withDisabledState = (extensions, disabledIds, enabledIds = []) => {
-  if (disabledIds.length === 0 && enabledIds.length === 0) {
-    return extensions;
+const pendingRpcs = Object.create(null);
+const getPendingExtensionIds = application => {
+  return Object.keys(pendingRpcs).flatMap(key => {
+    const [applicationId, generation, extensionId] = JSON.parse(key);
+    return applicationId === application.applicationId && generation === application.applicationGeneration ? [extensionId] : [];
+  });
+};
+const getRuntimeId = (extensionId, application) => {
+  return application?.applicationId === undefined ? extensionId : JSON.stringify([application.applicationId, application.applicationGeneration, extensionId]);
+};
+const bindCommandMap = (rpc, commandMap) => {
+  if (rpc.ipc) {
+    rpc.ipc.execute = createExtensionCommandExecutor(commandMap);
   }
-  const disabledIdsSet = new Set(disabledIds);
-  const enabledIdsSet = new Set(enabledIds);
-  return extensions.map(extension => {
-    if (disabledIdsSet.has(extension.id)) {
-      return {
-        ...extension,
-        disabled: true
-      };
+  return rpc;
+};
+const createIsolatedExtensionHostWorker = async (extensionId, absolutePath, workerName, contentSecurityPolicy, createRpc, invokeAndTransfer, application) => {
+  const runtimeId = getRuntimeId(extensionId, application);
+  const invokeCommand = application === undefined ? undefined : (method, ...args) => {
+    assertCurrentApplication(application);
+    if (method === 'Extensions.registerFileChangeHandler') {
+      return register(extensionId, application.applicationId);
     }
-    if (enabledIdsSet.has(extension.id) && extension.disabled === true) {
-      return {
-        ...extension,
-        disabled: false
-      };
+    if (method === 'Extensions.unregisterFileChangeHandler') {
+      return unregister(extensionId, application.applicationId);
+    }
+    if (method === 'Extensions.sendMessagePortToFileSystemWorker') {
+      return createFileSystemPort(application, args[0], extensionId);
+    }
+    if (method === 'Extensions.createWebViewWorkerRpc' || method === 'Extensions.createWebViewWorkerRpc2') {
+      return createWorker$1(application, args[0], args[1], method === 'Extensions.createWebViewWorkerRpc', extensionId);
+    }
+    const invokeApplication = commandMapRef['Extensions.invokeForApplication'];
+    if (!invokeApplication) {
+      throw new Error('Application extension command routing is not initialized');
+    }
+    return invokeApplication(application.applicationId, method, ...args);
+  };
+  const commandMap = createExtensionCommandMap(runtimeId, invokeCommand);
+  const rpc = await createRpc({
+    // PlainMessagePortRpc registers this map process-wide. Bind the restricted
+    // callbacks to this port below, never to the shared host command table.
+    commandMap: {},
+    isMessagePortOpen: true,
+    send(port) {
+      return invokeAndTransfer('LaunchIsolatedExtensionHostWorker.launchIsolatedExtensionHostWorker', port, runtimeId, absolutePath, workerName, contentSecurityPolicy);
     }
-    return extension;
   });
+  return bindCommandMap(rpc, commandMap);
 };
-const getExtensionsWithState = async (extensions, extensionsState, platform) => {
-  if (extensionsState.applicationId !== undefined) {
-    const byId = new Map(extensions.map(extension => [extension.id, extension]));
-    return withDisabledState(byId.values().toArray(), extensionsState.disabledIds).map(extension => ({
-      ...extension,
-      applicationGeneration: extensionsState.applicationGeneration,
-      applicationId: extensionsState.applicationId
-    }));
+const createWorker = (extensionId, absolutePath, workerName, contentSecurityPolicy, application) => {
+  return createIsolatedExtensionHostWorker(extensionId, absolutePath, workerName, contentSecurityPolicy, create$6, invokeAndTransfer, application);
+};
+const createAndStoreRpc = async (extensionId, absolutePath, workerName, contentSecurityPolicy, create, application) => {
+  try {
+    const rpc = application === undefined ? await create(extensionId, absolutePath, workerName, contentSecurityPolicy) : await create(extensionId, absolutePath, workerName, contentSecurityPolicy, application);
+    if (application !== undefined) {
+      try {
+        assertCurrentApplication(application);
+      } catch (error) {
+        await Promise.allSettled([rpc.dispose(), invoke$2('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', getRuntimeId(extensionId, application))]);
+        throw error;
+      }
+    }
+    set$4(extensionId, rpc, application?.applicationId);
+    return rpc;
+  } catch (error) {
+    console.error(`[extension-management-worker] ${extensionId} failed to activate`, error);
+    throw error;
   }
-  if (extensions.length === 0) {
-    return extensions;
+};
+const getOrCreateIsolatedExtensionHostWorker = async (extensionId, absolutePath, workerName = '', contentSecurityPolicy = '', create = createWorker, applicationId) => {
+  const application = applicationId === undefined ? undefined : get$7(applicationId);
+  const existingRpc = get$2(extensionId, applicationId);
+  if (existingRpc) {
+    return existingRpc;
   }
-  const {
-    disabledIds,
-    enabledIds
-  } = await getExtensionEnablement(extensionsState, platform);
-  const extensionsWithDisabledState = withDisabledState(extensions, disabledIds, enabledIds);
-  if (platform === Test) {
-    return extensionsWithDisabledState;
+  const key = JSON.stringify([applicationId ?? null, application?.applicationGeneration ?? null, extensionId]);
+  const pendingRpc = pendingRpcs[key];
+  if (pendingRpc !== undefined) {
+    return pendingRpc;
   }
-  const {
-    disabledIds: workspaceDisabledIds,
-    enabledIds: workspaceEnabledIds
-  } = await getWorkspaceExtensionEnablementSafe();
-  return withDisabledState(extensionsWithDisabledState, workspaceDisabledIds, workspaceEnabledIds);
-};
-const getAllExtensionsWithState = async (extensionsState, assetDir, platform) => {
-  const {
-    assetDir: resolvedAssetDir,
-    platform: resolvedPlatform
-  } = await getRuntimeContext(assetDir, platform);
-  string(resolvedAssetDir);
-  number(resolvedPlatform);
-  const meta = extensionsState.webExtensions;
-  if (resolvedPlatform === Web) {
-    const webExtensions = await getWebExtensions(resolvedAssetDir);
-    const compatibleExtensions = [...webExtensions, ...meta].filter(extension => isExtensionCompatible(extension, resolvedPlatform));
-    return getExtensionsWithState(compatibleExtensions, extensionsState, resolvedPlatform);
+  const newRpc = createAndStoreRpc(extensionId, absolutePath, workerName, contentSecurityPolicy, create, application);
+  pendingRpcs[key] = newRpc;
+  try {
+    return await newRpc;
+  } finally {
+    if (pendingRpcs[key] === newRpc) {
+      delete pendingRpcs[key];
+    }
   }
-  const local = await invoke$3('ExtensionManagement.getAllExtensions');
-  return getExtensionsWithState([...local, ...meta], extensionsState, resolvedPlatform);
 };
 
-const getExtensionAbsolutePath = (id, isWeb, isBuiltin, path, relativePath, origin, platform, assetDir) => {
-  if (path.startsWith('http')) {
-    if (path.endsWith('/')) {
-      return new URL(relativePath, path).href;
+const activateIsolatedExtension = async (extensionId, absolutePath, workerName, contentSecurityPolicy, activationEvent, getOrCreate = getOrCreateIsolatedExtensionHostWorker, applicationId) => {
+  const application = applicationId === undefined ? undefined : get$7(applicationId);
+  const updateStatus = status => {
+    if (applicationId === undefined) {
+      updateRuntimeStatus(extensionId, status);
+      return;
     }
-    return new URL(relativePath, path + '/').href;
-  }
-  if (!path.startsWith('/')) {
-    path = '/' + path;
+    const current = get$7(applicationId);
+    if (current.applicationGeneration !== application?.applicationGeneration) {
+      throw new Error(`Stale extension application: ${applicationId}`);
+    }
+    updateRuntimeStatus(extensionId, status, applicationId);
+  };
+  const startTime = performance.now();
+  updateStatus({
+    activationEvent,
+    activationStartTime: startTime,
+    status: Activating
+  });
+  try {
+    const rpc = applicationId === undefined ? await getOrCreate(extensionId, absolutePath, workerName, contentSecurityPolicy) : await getOrCreate(extensionId, absolutePath, workerName, contentSecurityPolicy, undefined, applicationId);
+    const endTime = performance.now();
+    updateStatus({
+      activationEndTime: endTime,
+      activationTime: endTime - startTime,
+      status: Activated
+    });
+    return rpc;
+  } catch (error) {
+    if (application === undefined || isCurrentApplication(application)) {
+      updateStatus({
+        error: getErrorMessage(error),
+        status: Error$1
+      });
+    }
+    throw error;
   }
-  if (isWeb) {
-    return path + '/' + relativePath;
+};
+
+const isExtensionIsolated = extension => {
+  return extension?.isolated === true;
+};
+
+const activateExtension3 = async (extension, absolutePath, activationEvent, platform) => {
+  if (extension.applicationId !== undefined) {
+    assertCurrentApplication(extension);
   }
-  if (platform === Web) {
-    return path + '/' + relativePath;
+  const extensionId = extension.id || interExtensionId(extension.uri);
+  if (!isExtensionIsolated(extension)) {
+    throw new Error(`Extension ${extensionId} does not use the isolated extension API`);
   }
-  if (isBuiltin) {
-    return `${assetDir}/extensions/${id}/${relativePath}`;
+  handleRpcInfos(extension, platform);
+  const contentSecurityPolicy = getContentSecurityPolicy(extension.contentSecurityPolicy, absolutePath, extension.rpc);
+  if (extension.applicationId === undefined) {
+    await activateIsolatedExtension(extensionId, absolutePath, extension.workerName || '', contentSecurityPolicy, activationEvent);
+  } else {
+    await activateIsolatedExtension(extensionId, absolutePath, extension.workerName || '', contentSecurityPolicy, activationEvent, undefined, extension.applicationId);
   }
-  return new URL('/remote' + path + '/' + relativePath, origin).href;
 };
 
 const getAllExtensions = async (assetDir, platform) => {
   return getAllExtensionsWithState(get$7(), assetDir, platform);
 };
 
-const notifyRunningExtensionsChanged = applicationId => {
-  setTimeout(() => {
-    const notification = applicationId === undefined ? invoke$4('Layout.handleExtensionsChanged') : invoke$4('Application.execute', applicationId, 'Layout.handleExtensionsChanged');
-    void Promise.resolve(notification).catch(() => {});
-  }, 0);
-};
-
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
 const activatingExtensions = Object.create(null);
@@ -3057,10 +3188,10 @@ const waitForExtensionActivations = async application => {
 const matchesEvent$1 = (extension, event) => {
   return !extension.disabled && isExtensionIsolated(extension) && Array.isArray(extension.activation) && extension.activation.includes(event);
 };
-const getExtensionId$3 = extension => {
+const getExtensionId$2 = extension => {
   return extension.id;
 };
-const getAbsolutePath$1 = (extension, assetDir, platform) => {
+const getAbsolutePath = (extension, assetDir, platform) => {
   return getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path || extension.uri, extension.browser, globalThis.location.origin, platform, assetDir);
 };
 const doActivateExtension = async (extension, absolutePath, event, platform, activation) => {
@@ -3068,7 +3199,7 @@ const doActivateExtension = async (extension, absolutePath, event, platform, act
     activatingExtensions,
     runningExtensions
   } = activation;
-  const extensionId = getExtensionId$3(extension);
+  const extensionId = getExtensionId$2(extension);
   try {
     await activateExtension3(extension, absolutePath, event, platform);
     runningExtensions[extensionId] = true;
@@ -3086,12 +3217,12 @@ const activateExtension = async (extension, event, assetDir, platform, activatio
     activatingExtensions,
     runningExtensions
   } = activation;
-  const extensionId = getExtensionId$3(extension);
+  const extensionId = getExtensionId$2(extension);
   if (runningExtensions[extensionId]) {
     return;
   }
   if (!Object.hasOwn(activatingExtensions, extensionId)) {
-    const absolutePath = getAbsolutePath$1(extension, assetDir, platform);
+    const absolutePath = getAbsolutePath(extension, assetDir, platform);
     activatingExtensions[extensionId] = doActivateExtension(extension, absolutePath, event, platform, activation);
   }
   await activatingExtensions[extensionId];
@@ -3152,7 +3283,7 @@ const handleChange = async _id => {
   if (!statusBarVisible) {
     return;
   }
-  await invoke$1('StatusBar.handleChange');
+  await invoke('StatusBar.handleChange');
 };
 
 const hasStatusBarItems = extension => {
@@ -3210,7 +3341,7 @@ const createWebViewWorkerRpc2 = async (rpcInfo, port) => {
   if (rpcInfo.contentSecurityPolicy) {
     const pathName = new URL(rpcInfo.url, 'http://localhost').pathname;
     const contentSecurityPolicy = getContentSecurityPolicy(rpcInfo.contentSecurityPolicy, rpcInfo.url);
-    await invoke('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
+    await invoke$2('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
   }
   await invokeAndTransfer('IpcParent.create', {
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
@@ -3247,7 +3378,7 @@ const createWebViewWorkerRpc = async (rpcInfo, port) => {
   });
 };
 
-const disposeIsolatedExtensionHostWorker = async (extensionId, invoke$1 = invoke) => {
+const disposeIsolatedExtensionHostWorker = async (extensionId, invoke = invoke$2) => {
   unregister(extensionId);
   const rpc = remove$1(extensionId);
   if (!rpc) {
@@ -3256,7 +3387,7 @@ const disposeIsolatedExtensionHostWorker = async (extensionId, invoke$1 = invoke
   resetExtensionActivation(extensionId);
   resetExtensionRuntimeState(extensionId);
   try {
-    await invoke$1('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', extensionId);
+    await invoke('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', extensionId);
   } catch {
     // Older renderer workers only support disposing the extension RPC.
   }
@@ -3416,11 +3547,11 @@ const disposeExtensionApplication = async applicationId => {
   const ids = new Set([...getIds(applicationId), ...getPendingExtensionIds(application)]);
   const runtimes = ids.values().map(id => ({
     id,
-    rpc: get$3(id, applicationId)
+    rpc: get$2(id, applicationId)
   })).toArray();
   // Invalidate pending activations and extension callbacks before awaiting teardown.
   removeApplication(applicationId);
-  clear(applicationId);
+  clear$1(applicationId);
   resetAllExtensionActivations(application);
   reset(applicationId);
   const results = await Promise.allSettled([dispose(application), ...runtimes.map(async ({
@@ -3428,7 +3559,7 @@ const disposeExtensionApplication = async applicationId => {
     rpc
   }) => {
     const runtimeId = getRuntimeId(id, application);
-    const disposal = await Promise.allSettled([Promise.try(() => rpc?.dispose()), invoke('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', runtimeId)]);
+    const disposal = await Promise.allSettled([Promise.try(() => rpc?.dispose()), invoke$2('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', runtimeId)]);
     const errors = disposal.filter(result => result.status === 'rejected').map(result => result.reason);
     if (errors.length > 0) {
       throw new AggregateError(errors, `Failed to dispose extension ${id}`);
@@ -3463,7 +3594,7 @@ const enableWorkspaceExtension = async id => {
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
-const getExtensionId$2 = extension => {
+const getExtensionId$1 = extension => {
   return extension.id || interExtensionId(extension.uri || extension.path || '');
 };
 const contributesCommand = (extension, id) => {
@@ -3478,8 +3609,11 @@ const getRpcForCommand = async (extensionsState, id, platform) => {
   if (!extension) {
     return undefined;
   }
-  const extensionId = getExtensionId$2(extension);
-  const existingRpc = get$3(extensionId, extensionsState.applicationId);
+  if (extension.workspaceTransport?.command === id) {
+    throw new Error('Workspace transports can only be called by extension management');
+  }
+  const extensionId = getExtensionId$1(extension);
+  const existingRpc = get$2(extensionId, extensionsState.applicationId);
   if (existingRpc) {
     return existingRpc;
   }
@@ -3488,7 +3622,7 @@ const getRpcForCommand = async (extensionsState, id, platform) => {
   } else {
     await activateByEvent(`onCommand:${id}`, '', platform, extensionsState);
   }
-  return get$3(extensionId, extensionsState.applicationId);
+  return get$2(extensionId, extensionsState.applicationId);
 };
 const executeRendererCommand = (id, args, applicationId) => {
   if (applicationId !== undefined) {
@@ -3623,33 +3757,6 @@ const executeLanguageServerCompletion = async (rpc, extension, textDocument, off
   return result.map(sanitizeCompletionItem).filter(item => item !== undefined);
 };
 
-const getExtensionId$1 = extension => {
-  return extension.id || interExtensionId(extension.uri || extension.path || '');
-};
-const getAbsolutePath = (extension, assetDir, platform) => {
-  return getExtensionAbsolutePath(getExtensionId$1(extension), extension.isWeb === true, extension.builtin === true, extension.path || extension.uri || '', extension.browser || '', getOrigin(), platform, assetDir);
-};
-const getRpc$1 = async (extension, assetDir, platform, activationEvent = '', getOrCreate = getOrCreateIsolatedExtensionHostWorker, notify = notifyRunningExtensionsChanged) => {
-  if (extension.applicationId !== undefined) {
-    assertCurrentApplication(extension);
-  }
-  const extensionId = getExtensionId$1(extension);
-  const existingRpc = get$3(extensionId, extension.applicationId);
-  if (existingRpc) {
-    return existingRpc;
-  }
-  handleRpcInfos(extension, platform);
-  const absolutePath = getAbsolutePath(extension, assetDir, platform);
-  const contentSecurityPolicy = getContentSecurityPolicy(extension.contentSecurityPolicy, absolutePath, extension.rpc);
-  const rpc = await activateIsolatedExtension(extensionId, absolutePath, extension.workerName || '', contentSecurityPolicy, activationEvent, getOrCreate, extension.applicationId);
-  if (extension.applicationId === undefined) {
-    notify();
-  } else {
-    notify(extension.applicationId);
-  }
-  return rpc;
-};
-
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
 const contributesCompletionProvider = (extension, languageId) => {
@@ -4538,7 +4645,7 @@ const getRegisteredOutputChannelIds = snapshot => {
   return new Set(snapshot.outputChannels.map(outputChannel => outputChannel.id).filter(id => typeof id === 'string'));
 };
 const getExtensionOutputChannelProviders = async (extension, assetDir, platform) => {
-  const extensionId = getExtensionId$1(extension);
+  const extensionId = getExtensionId$3(extension);
   const rpc = await getRpc$1(extension, assetDir, platform);
   let snapshot;
   try {
@@ -4590,7 +4697,7 @@ const resolveOutputChannel = async (extensionsState, uri) => {
     platform
   } = await getRuntimeContext('', extensionsState.platform);
   const extensions = await getAllExtensionsWithState(extensionsState, assetDir, platform);
-  const extension = extensions.find(candidate => getExtensionId$1(candidate) === extensionId && hasOutputChannels(candidate));
+  const extension = extensions.find(candidate => getExtensionId$3(candidate) === extensionId && hasOutputChannels(candidate));
   const isContributed = extension?.outputChannels?.some(outputChannel => outputChannel.id === outputChannelId);
   if (!extension || !isContributed) {
     throw new Error(`Output channel ${outputChannelId} is not contributed by extension ${extensionId}`);
@@ -4676,7 +4783,7 @@ const disposeViewOnlyExtensionWorker = async (extensionId, rpc) => {
   if (hasOtherViewInstances(rpc)) {
     return;
   }
-  if (get$3(extensionId) !== rpc) {
+  if (get$2(extensionId) !== rpc) {
     return;
   }
   await disposeIsolatedExtensionHostWorker(extensionId);
@@ -4695,8 +4802,8 @@ const getRpcForView = async (viewId, assetDir, platform, applicationId) => {
     platform: resolvedPlatform
   } = await getRuntimeContext(assetDir, platform);
   const extension = await getExtensionForView(viewId, resolvedAssetDir, resolvedPlatform, applicationId);
-  const extensionId = getExtensionId$1(extension);
-  const existingRpc = get$3(extensionId, applicationId);
+  const extensionId = getExtensionId$3(extension);
+  const existingRpc = get$2(extensionId, applicationId);
   // Application teardown and reload own application workers; global view-only disposal does not.
   if (existingRpc) {
     return {
@@ -5253,13 +5360,13 @@ const getRemoteUrlForWebView = async (uri, options = {}) => {
   if (!webView) {
     throw new Error(`webview ${options.webViewId} not found`);
   }
-  const [rpc, blob] = await Promise.all([createWebViewIpc(webView), invoke('FileSystem.getBlob', uri)]);
+  const [rpc, blob] = await Promise.all([createWebViewIpc(webView), invoke$2('FileSystem.getBlob', uri)]);
   const objectUrl = await rpc.invoke('createObjectUrl', blob);
   return objectUrl;
 };
 
 const getRpcInfo = rpcId => {
-  const info = get$2(rpcId);
+  const info = get$3(rpcId);
   if (!info) {
     throw new Error(`Rpc not found ${rpcId}`);
   }
@@ -5280,7 +5387,7 @@ const getIcon = (extension, manifestView, assetDir, platform) => {
     if (isAbsoluteIcon(manifestIcon) || !isRelativeIconPath(manifestIcon)) {
       return manifestIcon;
     }
-    return getAbsolutePath({
+    return getAbsolutePath$1({
       ...extension,
       browser: manifestIcon
     }, assetDir, platform);
@@ -5341,7 +5448,7 @@ const waitForTimeout = async (timeout, sleep) => {
 const isResponsive = async (rpc, timeout, sleep) => {
   return Promise.race([invokePing(rpc), waitForTimeout(timeout, sleep)]);
 };
-const updateTerminatedExtensionStatuses = async (runtimeStatuses, getRpc = get$3, timeout = 250, sleep$1 = sleep) => {
+const updateTerminatedExtensionStatuses = async (runtimeStatuses, getRpc = get$2, timeout = 250, sleep$1 = sleep) => {
   const activatedStatuses = Object.values(runtimeStatuses).filter(status => status.status === Activated);
   await Promise.all(activatedStatuses.map(async status => {
     const rpc = getRpc(status.id);
@@ -5403,7 +5510,7 @@ const getItems = async rpc => {
   return rpc.invoke('ExtensionApi.getStatusBarItems');
 };
 const getStatusBarItems = async applicationId => {
-  const rpcs = getAll(applicationId);
+  const rpcs = getAll$1(applicationId);
   const results = await Promise.all(rpcs.map(getItems));
   return results.flat();
 };
@@ -5413,7 +5520,7 @@ const getCss = (extension, manifestView, assetDir, platform) => {
   if (typeof css !== 'string' || css.length === 0) {
     return '';
   }
-  return getAbsolutePath({
+  return getAbsolutePath$1({
     ...extension,
     browser: css
   }, assetDir, platform);
@@ -5428,7 +5535,7 @@ const getIframe = (extension, manifestView, assetDir, platform) => {
     credentialless: iframe.credentialless !== false,
     csp: iframe.csp || '',
     sandbox: Array.isArray(iframe.sandbox) ? iframe.sandbox.filter(item => typeof item === 'string') : ['allow-scripts'],
-    src: getAbsolutePath({
+    src: getAbsolutePath$1({
       ...extension,
       browser: iframe.path
     }, assetDir, platform)
@@ -5459,7 +5566,7 @@ const toView = (extension, manifestView, assetDir, platform) => {
     ...(type && {
       type
     }),
-    extensionId: getExtensionId$1(extension),
+    extensionId: getExtensionId$3(extension),
     icon: getIcon(extension, manifestView, assetDir, platform),
     id,
     iframe: getIframe(extension, manifestView, assetDir, platform),
@@ -5489,7 +5596,7 @@ const shouldLoadViews = extension => {
     return false;
   }
   if (!isExtensionIsolated(extension)) {
-    warn(`Extension "${getExtensionId$1(extension)}" contributes activity bar views but is not isolated. The views will not be shown. Add "isolated": true to extension.json to enable them.`);
+    warn(`Extension "${getExtensionId$3(extension)}" contributes activity bar views but is not isolated. The views will not be shown. Add "isolated": true to extension.json to enable them.`);
     return false;
   }
   return true;
@@ -5512,7 +5619,7 @@ const getViews = async (assetDir, platform) => {
 const handleData = () => {};
 
 const invokeHandler = async (extensionId, changes, applicationId) => {
-  const rpc = get$3(extensionId, applicationId);
+  const rpc = get$2(extensionId, applicationId);
   if (!rpc) {
     unregister(extensionId, applicationId);
     return;
@@ -5533,9 +5640,9 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId === StatusBarWorker) {
-    set$3(rpc);
+    set$2(rpc);
   } else if (rpcId === NotificationCenterWorker) {
-    set$4(rpc);
+    set$3(rpc);
   }
 };
 
@@ -5626,7 +5733,7 @@ const defaultDependencies$2 = {
   activateByEvent: activateByEvent,
   createViewInstance: createViewInstance,
   disposeExtensionRuntime,
-  getRpc: get$3,
+  getRpc: get$2,
   getRuntimeStatus: getRuntimeStatus$1,
   getViewEntries: getEntries,
   removeViewInstance: remove,
@@ -5873,7 +5980,7 @@ const replace = async (application, extensionId, extension) => {
   assertCurrentApplication(application);
   const rpc = remove$1(extensionId, applicationId);
   unregister(extensionId, applicationId);
-  const results = await Promise.allSettled([disposeExtension(application, extensionId), Promise.try(() => rpc?.dispose()), invoke('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', getRuntimeId(extensionId, application))]);
+  const results = await Promise.allSettled([disposeExtension(application, extensionId), Promise.try(() => rpc?.dispose()), invoke$2('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', getRuntimeId(extensionId, application))]);
   assertCurrentApplication(application);
   resetExtensionActivation(extensionId, application);
   resetExtensionRuntimeState(extensionId, applicationId);
@@ -5972,10 +6079,10 @@ const invokeForApplication = async (applicationId, method, ...args) => {
   }
   switch (method) {
     case 'ExtensionApi.readFile':
-      return invoke('Application.execute', applicationId, 'FileSystem.readFile', ...args);
+      return invoke$2('Application.execute', applicationId, 'FileSystem.readFile', ...args);
     case 'ExtensionHostQuickPick.showQuickInput':
     case 'ExtensionHostQuickPick.showQuickPick':
-      return invoke('Application.execute', applicationId, method, ...args);
+      return invoke$2('Application.execute', applicationId, method, ...args);
     case 'Extensions.activateByEvent':
       return activateByEvent(args[0], args[1], args[2] ?? application.platform, application);
     case 'Extensions.createWebViewWorkerRpc':
@@ -6002,7 +6109,7 @@ const invokeForApplication = async (applicationId, method, ...args) => {
     case 'Extensions.sendMessagePortToFileSystemWorker':
       return createFileSystemPort(application, args[0]);
     case 'Extensions.showNotification':
-      return invoke('Application.execute', applicationId, 'Notification.create', ...args);
+      return invoke$2('Application.execute', applicationId, 'Notification.create', ...args);
     default:
       throw new Error(`Extension command does not support application context: ${method}`);
   }
@@ -6029,6 +6136,7 @@ const commandMap = {
   'Extensions.addWebExtension': addWebExtension,
   'Extensions.clearNotifications': clearNotifications,
   'Extensions.clearOutputChannel': wrapCommand(clearOutputChannel),
+  'Extensions.connectWorkspaceTerminal': connectTerminal,
   'Extensions.createApplication': createApplication,
   'Extensions.createViewInstance': createViewInstance,
   'Extensions.createWebViewWorkerRpc': createWebViewWorkerRpc,
@@ -6064,6 +6172,7 @@ const commandMap = {
   'Extensions.executeResolveCompletionItemProvider': wrapCommand(executeResolveCompletionItemProvider),
   'Extensions.executeSignatureHelpProvider': wrapCommand(executeSignatureHelpProvider),
   'Extensions.executeSourceControlProvider': wrapCommand(executeSourceControlProvider),
+  'Extensions.executeWorkspaceRequest': request,
   'Extensions.getAccessToken': getAccessToken,
   'Extensions.getAllExtensions': getAllExtensions,
   'Extensions.getColorThemeCss': getColorThemeCss,
@@ -6089,6 +6198,7 @@ const commandMap = {
   'Extensions.getViewInstanceState': getViewInstanceState,
   'Extensions.getViewMenuEntries': getViewMenuEntries,
   'Extensions.getViews': getViews,
+  'Extensions.getWorkspaceTransportUri': getWorkspaceTransportUri,
   'Extensions.handleData': handleData,
   'Extensions.handleFileChanges': handleFileChanges,
   'Extensions.handleLinkedExtensionChange': handleLinkedExtensionChange,