@lvce-editor/static-server 0.113.11 → 0.113.13

package/static/{55af9e7 → edd8259}/packages/extension-management-worker/dist/extensionManagementWorkerMain.js

@@ -31,69 +31,118 @@ const createEmptyRuntimeStatus = id => {
   };
 };
 const state$4 = {
-  extensionsState: createInitialState()
+  extensionsState: createInitialState(),
+  nextApplicationGeneration: 0
+};
+const applications$2 = new Map();
+const createApplication = (applicationId, platform, webExtensions) => {
+  if (!applicationId || applications$2.has(applicationId)) {
+    throw new Error(`Invalid or duplicate extension application: ${applicationId}`);
+  }
+  applications$2.set(applicationId, {
+    ...createInitialState(),
+    applicationGeneration: ++state$4.nextApplicationGeneration,
+    applicationId,
+    platform,
+    webExtensions: [...webExtensions]
+  });
+};
+const removeApplication = applicationId => {
+  applications$2.delete(applicationId);
+};
+const isCurrentApplication = application => {
+  if (application.applicationId === undefined) {
+    return true;
+  }
+  const current = applications$2.get(application.applicationId);
+  return current !== undefined && current.applicationGeneration === application.applicationGeneration;
+};
+const assertCurrentApplication = application => {
+  if (!isCurrentApplication(application)) {
+    throw new Error(`Stale extension application: ${application.applicationId}`);
+  }
 };
-const get$7 = () => {
+const get$7 = applicationId => {
+  if (applicationId !== undefined) {
+    const application = applications$2.get(applicationId);
+    if (!application) {
+      throw new Error(`Extension application not found: ${applicationId}`);
+    }
+    return application;
+  }
   return state$4.extensionsState;
 };
 const set$d = newState => {
+  if (newState.applicationId !== undefined) {
+    const currentState = get$7(newState.applicationId);
+    if (newState.applicationGeneration !== currentState.applicationGeneration) {
+      throw new Error(`Stale extension application state: ${newState.applicationId}`);
+    }
+    applications$2.set(newState.applicationId, newState);
+    return;
+  }
   state$4.extensionsState = newState;
 };
-const update = newState => {
+const update = (newState, applicationId) => {
+  if (Object.hasOwn(newState, 'applicationId') || Object.hasOwn(newState, 'applicationGeneration')) {
+    throw new Error('Cannot change extension application identity');
+  }
+  const current = get$7(applicationId);
   set$d({
-    ...state$4.extensionsState,
+    ...current,
     ...newState
   });
 };
-const setPlatform = platform => {
+const setPlatform = (platform, applicationId) => {
   update({
     platform
-  });
+  }, applicationId);
 };
-const hasWebExtensionUri = uri => {
-  return state$4.extensionsState.webExtensions.some(extension => extension.uri === uri);
+const hasWebExtensionUri = (uri, applicationId) => {
+  return get$7(applicationId).webExtensions.some(extension => extension.uri === uri);
 };
-const addExtension$1 = extension => {
+const addExtension$1 = (extension, applicationId) => {
   update({
-    webExtensions: [...state$4.extensionsState.webExtensions, extension]
-  });
+    webExtensions: [...get$7(applicationId).webExtensions, extension]
+  }, applicationId);
 };
-const removeWebExtension = id => {
-  const webExtensions = state$4.extensionsState.webExtensions.filter(extension => extension.id !== id);
-  if (webExtensions.length === state$4.extensionsState.webExtensions.length) {
+const removeWebExtension = (id, applicationId) => {
+  const currentState = get$7(applicationId);
+  const webExtensions = currentState.webExtensions.filter(extension => extension.id !== id);
+  if (webExtensions.length === currentState.webExtensions.length) {
     return false;
   }
   update({
     cachedExtensions: undefined,
     webExtensions
-  });
+  }, applicationId);
   return true;
 };
-const clearCachedExtensions = () => {
+const clearCachedExtensions = applicationId => {
   update({
     cachedExtensions: undefined
-  });
+  }, applicationId);
 };
-const setRuntimeStatus = status => {
+const setRuntimeStatus = (status, applicationId) => {
   update({
     runtimeStatuses: {
-      ...state$4.extensionsState.runtimeStatuses,
+      ...get$7(applicationId).runtimeStatuses,
       [status.id]: {
         ...status
       }
     }
-  });
+  }, applicationId);
 };
-const updateRuntimeStatus = (id, statusUpdate) => {
-  const previousStatus = state$4.extensionsState.runtimeStatuses[id] || createEmptyRuntimeStatus(id);
+const updateRuntimeStatus = (id, statusUpdate, applicationId) => {
+  const previousStatus = get$7(applicationId).runtimeStatuses[id] || createEmptyRuntimeStatus(id);
   setRuntimeStatus({
     ...previousStatus,
     ...statusUpdate,
     id
-  });
+  }, applicationId);
 };
-const getRuntimeStatus$1 = extensionId => {
-  return state$4.extensionsState.runtimeStatuses[extensionId];
+const getRuntimeStatus$1 = (extensionId, applicationId) => {
+  return get$7(applicationId).runtimeStatuses[extensionId];
 };
 const omit = (record, id) => {
   const result = {
@@ -102,19 +151,20 @@ const omit = (record, id) => {
   delete result[id];
   return result;
 };
-const resetExtensionRuntimeState = extensionId => {
+const resetExtensionRuntimeState = (extensionId, applicationId) => {
+  const currentState = get$7(applicationId);
   update({
-    activatedExtensions: omit(state$4.extensionsState.activatedExtensions, extensionId),
-    cachedActivationEvents: omit(state$4.extensionsState.cachedActivationEvents, extensionId),
-    runtimeStatuses: omit(state$4.extensionsState.runtimeStatuses, extensionId)
-  });
+    activatedExtensions: omit(currentState.activatedExtensions, extensionId),
+    cachedActivationEvents: omit(currentState.cachedActivationEvents, extensionId),
+    runtimeStatuses: omit(currentState.runtimeStatuses, extensionId)
+  }, applicationId);
 };
-const resetRuntimeState = () => {
+const resetRuntimeState = applicationId => {
   update({
     activatedExtensions: Object.create(null),
     cachedActivationEvents: Object.create(null),
     runtimeStatuses: Object.create(null)
-  });
+  }, applicationId);
 };
 
 const getErrorMessage = error => {
@@ -720,7 +770,7 @@ let CommandNotFoundError$1 = class CommandNotFoundError extends Error {
   }
 };
 const commands = Object.create(null);
-const register$1 = commandMap => {
+const register$2 = commandMap => {
   Object.assign(commands, commandMap);
 };
 const getCommand = key => {
@@ -1243,7 +1293,7 @@ const create$7 = async ({
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register$2(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
     isMessagePortOpen,
     messagePort
@@ -1311,7 +1361,7 @@ const create$4 = async ({
   webSocket
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register$2(commandMap);
   let rawIpc;
   try {
     rawIpc = await IpcParentWithWebSocket$1.create({
@@ -1386,7 +1436,7 @@ const create$2 = async ({
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register$2(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
     isMessagePortOpen,
     messagePort
@@ -1401,7 +1451,7 @@ const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register$2(commandMap);
   const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
@@ -1637,17 +1687,36 @@ const createNodeRpcMessagePort = async (extensionId, rpcId, port) => {
 };
 
 const extensionIds = new Set();
-const register = extensionId => {
-  extensionIds.add(extensionId);
+const applications$1 = new Map();
+const register$1 = (extensionId, applicationId) => {
+  if (applicationId === undefined) {
+    extensionIds.add(extensionId);
+    return;
+  }
+  const ids = applications$1.get(applicationId) || new Set();
+  ids.add(extensionId);
+  applications$1.set(applicationId, ids);
 };
-const unregister = extensionId => {
-  extensionIds.delete(extensionId);
+const unregister = (extensionId, applicationId) => {
+  if (applicationId === undefined) {
+    extensionIds.delete(extensionId);
+    return;
+  }
+  const ids = applications$1.get(applicationId);
+  ids?.delete(extensionId);
+  if (ids?.size === 0) {
+    applications$1.delete(applicationId);
+  }
 };
-const getRegisteredExtensionIds = () => {
-  return [...extensionIds];
+const getRegisteredExtensionIds = applicationId => {
+  return [...(applicationId === undefined ? extensionIds : applications$1.get(applicationId) || [])];
 };
-const reset = () => {
-  extensionIds.clear();
+const reset = applicationId => {
+  if (applicationId === undefined) {
+    extensionIds.clear();
+  } else {
+    applications$1.delete(applicationId);
+  }
 };
 
 const prefix = '[Extension] Uncaught Error: ';
@@ -1670,7 +1739,7 @@ const add$1 = (extensionId, type, message) => {
   state$3.notifications = [...state$3.notifications, notification];
   return notification;
 };
-const clear = () => {
+const clear$1 = () => {
   state$3.notifications = [];
 };
 const dismiss = id => {
@@ -1746,7 +1815,7 @@ const showPopup = async (type, message) => {
   }
 };
 const clearNotifications = async () => {
-  clear();
+  clear$1();
   await notifyNotificationsChanged();
 };
 const createNotification = async (extensionId, type, message) => {
@@ -1839,28 +1908,39 @@ const invokeGlobalCommand = (method, ...params) => {
   }
   return command(...params);
 };
-const executeDeferredCommand = async (id, args) => {
+const executeDeferredCommand = async (invokeCommand, id, args) => {
   try {
-    await invokeGlobalCommand('Extensions.executeCommand', id, ...args);
+    await invokeCommand('Extensions.executeCommand', id, ...args);
   } catch (error) {
     await handleUncaughtExtensionError(error);
   }
 };
-const executeCommand$1 = (id, ...args) => {
+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(id, args).catch(() => {});
+      void executeDeferredCommand(invokeCommand, id, args).catch(() => {});
     }, 0);
     return undefined;
   }
-  return invokeGlobalCommand('Extensions.executeCommand', id, ...args);
+  return invokeCommand('Extensions.executeCommand', id, ...args);
 };
-const createExtensionCommandMap = extensionId => {
+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')
+    };
+  }
   return {
-    ...commandMapRef,
+    ...inheritedCommands,
     'Extensions.createNodeRpcConnection'(rpcId) {
       return createNodeRpcConnection(extensionId, rpcId);
     },
@@ -1870,12 +1950,14 @@ const createExtensionCommandMap = extensionId => {
     'Extensions.deleteSecret'(key) {
       return deleteSecret(extensionId, key);
     },
-    'Extensions.executeCommand': executeCommand$1,
+    'Extensions.executeCommand'(id, ...args) {
+      return executeCommand$1(invokeCommand, id, ...args);
+    },
     'Extensions.getSecret'(key) {
       return getSecret(extensionId, key);
     },
     'Extensions.registerFileChangeHandler'() {
-      register(extensionId);
+      register$1(extensionId);
     },
     'Extensions.sendMessagePortToElectron'(port, initialCommand) {
       if (initialCommand !== allowedElectronPortCommand) {
@@ -1905,96 +1987,173 @@ const createExtensionCommandExecutor = commandMap => {
 };
 
 const rpcs$1 = Object.create(null);
-const get$3 = extensionId => {
+const applicationRpcs = new Map();
+const get$3 = (extensionId, applicationId) => {
+  if (applicationId !== undefined) {
+    return applicationRpcs.get(applicationId)?.get(extensionId);
+  }
   return rpcs$1[extensionId];
 };
-const getAll = () => {
+const getAll = applicationId => {
+  if (applicationId !== undefined) {
+    return [...(applicationRpcs.get(applicationId)?.values() || [])];
+  }
   return Object.values(rpcs$1);
 };
-const getIds = () => {
+const getIds = applicationId => {
+  if (applicationId !== undefined) {
+    return [...(applicationRpcs.get(applicationId)?.keys() || [])];
+  }
   return Object.keys(rpcs$1);
 };
-const set$2 = (extensionId, rpc) => {
+const set$2 = (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;
 };
-const remove$1 = extensionId => {
+const remove$1 = (extensionId, applicationId) => {
   const rpc = rpcs$1[extensionId];
   delete rpcs$1[extensionId];
   return rpc;
 };
+const clear = applicationId => {
+  if (applicationId !== undefined) {
+    applicationRpcs.delete(applicationId);
+    return;
+  }
+  for (const key of Object.keys(rpcs$1)) {
+    delete rpcs$1[key];
+  }
+};
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
 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);
   }
   return rpc;
 };
-const createIsolatedExtensionHostWorker = async (extensionId, absolutePath, workerName, contentSecurityPolicy, createRpc, invokeAndTransfer) => {
-  const commandMap = createExtensionCommandMap(extensionId);
+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);
+    }
+    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({
-    commandMap,
+    // 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, extensionId, absolutePath, workerName, contentSecurityPolicy);
+      return invokeAndTransfer('LaunchIsolatedExtensionHostWorker.launchIsolatedExtensionHostWorker', port, runtimeId, absolutePath, workerName, contentSecurityPolicy);
     }
   });
   return bindCommandMap(rpc, commandMap);
 };
-const createWorker = (extensionId, absolutePath, workerName, contentSecurityPolicy) => {
-  return createIsolatedExtensionHostWorker(extensionId, absolutePath, workerName, contentSecurityPolicy, create$6, invokeAndTransfer);
+const createWorker$1 = (extensionId, absolutePath, workerName, contentSecurityPolicy, application) => {
+  return createIsolatedExtensionHostWorker(extensionId, absolutePath, workerName, contentSecurityPolicy, create$6, invokeAndTransfer, application);
 };
-const createAndStoreRpc = async (extensionId, absolutePath, workerName, contentSecurityPolicy, create) => {
+const createAndStoreRpc = async (extensionId, absolutePath, workerName, contentSecurityPolicy, create, application) => {
   try {
-    const rpc = await create(extensionId, absolutePath, workerName, contentSecurityPolicy);
-    set$2(extensionId, rpc);
+    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;
+      }
+    }
+    set$2(extensionId, rpc, application?.applicationId);
     return rpc;
   } catch (error) {
     console.error(`[extension-management-worker] ${extensionId} failed to activate`, error);
     throw error;
   }
 };
-const getOrCreateIsolatedExtensionHostWorker = async (extensionId, absolutePath, workerName = '', contentSecurityPolicy = '', create = createWorker) => {
-  const existingRpc = get$3(extensionId);
+const getOrCreateIsolatedExtensionHostWorker = async (extensionId, absolutePath, workerName = '', contentSecurityPolicy = '', create = createWorker$1, applicationId) => {
+  const application = applicationId === undefined ? undefined : get$7(applicationId);
+  const existingRpc = get$3(extensionId, applicationId);
   if (existingRpc) {
     return existingRpc;
   }
-  const pendingRpc = pendingRpcs[extensionId];
+  const key = JSON.stringify([applicationId ?? null, application?.applicationGeneration ?? null, extensionId]);
+  const pendingRpc = pendingRpcs[key];
   if (pendingRpc !== undefined) {
     return pendingRpc;
   }
-  const newRpc = createAndStoreRpc(extensionId, absolutePath, workerName, contentSecurityPolicy, create);
-  pendingRpcs[extensionId] = newRpc;
+  const newRpc = createAndStoreRpc(extensionId, absolutePath, workerName, contentSecurityPolicy, create, application);
+  pendingRpcs[key] = newRpc;
   try {
     return await newRpc;
   } finally {
-    delete pendingRpcs[extensionId];
+    if (pendingRpcs[key] === newRpc) {
+      delete pendingRpcs[key];
+    }
   }
 };
 
-const activateIsolatedExtension = async (extensionId, absolutePath, workerName, contentSecurityPolicy, activationEvent, getOrCreate = getOrCreateIsolatedExtensionHostWorker) => {
+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();
-  updateRuntimeStatus(extensionId, {
+  updateStatus({
     activationEvent,
     activationStartTime: startTime,
     status: Activating
   });
   try {
-    const rpc = await getOrCreate(extensionId, absolutePath, workerName, contentSecurityPolicy);
+    const rpc = applicationId === undefined ? await getOrCreate(extensionId, absolutePath, workerName, contentSecurityPolicy) : await getOrCreate(extensionId, absolutePath, workerName, contentSecurityPolicy, undefined, applicationId);
     const endTime = performance.now();
-    updateRuntimeStatus(extensionId, {
+    updateStatus({
       activationEndTime: endTime,
       activationTime: endTime - startTime,
       status: Activated
     });
     return rpc;
   } catch (error) {
-    updateRuntimeStatus(extensionId, {
-      error: getErrorMessage(error),
-      status: Error$1
-    });
+    if (application === undefined || isCurrentApplication(application)) {
+      updateStatus({
+        error: getErrorMessage(error),
+        status: Error$1
+      });
+    }
     throw error;
   }
 };
@@ -2128,13 +2287,14 @@ const getContentSecurityPolicy = (directives, absolutePath, rpcInfos) => {
   return `default-src 'none'; script-src ${[...scriptSources].join(' ')}; worker-src 'none'; child-src 'none'; connect-src ${connectDirective};`;
 };
 
-const rpcs = Object.create(null);
-const add = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$2 = id => {
-  return rpcs[id];
+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://')) {
@@ -2149,7 +2309,111 @@ const getUrlPrefix = (platform, extensionPath) => {
   return `/remote/${extensionPath}`;
 };
 
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const applications = new Map();
+const getServices = application => {
+  assertCurrentApplication(application);
+  const generation = application.applicationGeneration;
+  let services = applications.get(generation);
+  if (!services) {
+    services = {
+      children: new Set(),
+      declarations: new Map(),
+      nextChild: 0,
+      ports: new Set()
+    };
+    applications.set(generation, services);
+  }
+  return services;
+};
+const register = (extension, platform) => {
+  const application = get$7(extension.applicationId);
+  assertCurrentApplication(extension);
+  const services = getServices(application);
+  const prefix = getUrlPrefix(platform, extension.path);
+  const declarations = extension.rpc || [];
+  for (const info of declarations) {
+    if (info.type !== 'web-worker') {
+      throw new Error('Application extensions only support web-worker RPCs');
+    }
+    services.declarations.set(info.id, {
+      ...info,
+      url: `${prefix}/${info.url}`
+    });
+  }
+};
+const getRpcInfo$1 = (application, id) => {
+  const info = getServices(application).declarations.get(id);
+  if (!info) throw new Error(`Rpc not found ${id}`);
+  return info;
+};
+const createWorker = async (application, info, port, legacy = false) => {
+  const services = getServices(application);
+  const id = JSON.stringify([application.applicationId, application.applicationGeneration, 'child', ++services.nextChild]);
+  services.children.add(id);
+  const url = legacy ? extensionHostSubWorkerUrl : info.url;
+  try {
+    const policy = getContentSecurityPolicy(info.contentSecurityPolicy || [], url);
+    await invokeAndTransfer('LaunchIsolatedExtensionHostWorker.launchIsolatedExtensionHostWorker', port, id, url, info.name || '', policy);
+    assertCurrentApplication(application);
+  } catch (error) {
+    services.children.delete(id);
+    await invoke('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', id);
+    throw error;
+  }
+};
+const fileSystemMethods = new Set(['readFile', 'readDirWithFileTypes', 'stat', 'exists', 'writeFile', 'mkdir', 'remove', 'rename', 'copy', 'getBlob']);
+const createFileSystemPort = async (application, port) => {
+  const services = getServices(application);
+  const rpc = await create$7({
+    commandMap: {},
+    messagePort: port
+  });
+  // Bind only this connection: registering callbacks globally would let the
+  // second IDE replace the first IDE's filesystem routing.
+  rpc.ipc.execute = async (command, ...args) => {
+    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);
+    return method === 'stat' ? value.type : value;
+  };
+  try {
+    assertCurrentApplication(application);
+    services.ports.add(rpc);
+  } catch (error) {
+    await rpc.dispose();
+    throw error;
+  }
+};
+const dispose = async application => {
+  const services = applications.get(application.applicationGeneration);
+  if (!services) return;
+  applications.delete(application.applicationGeneration);
+  const results = await Promise.allSettled([...Array.from(services.ports, rpc => Promise.try(() => rpc.dispose())), ...Array.from(services.children, id => invoke('LaunchIsolatedExtensionHostWorker.disposeIsolatedExtensionHostWorker', id))]);
+  services.ports.clear();
+  services.children.clear();
+  services.declarations.clear();
+  const errors = results.filter(result => result.status === 'rejected').map(result => result.reason);
+  if (errors.length > 0) throw new AggregateError(errors, 'Failed to dispose application services');
+};
+
+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;
+  }
   try {
     if (!extension) {
       return;
@@ -2195,35 +2459,20 @@ const isExtensionIsolated = extension => {
 };
 
 const activateExtension3 = async (extension, absolutePath, activationEvent, platform) => {
+  if (extension.applicationId !== undefined) {
+    assertCurrentApplication(extension);
+  }
   const extensionId = extension.id || interExtensionId(extension.uri);
   if (!isExtensionIsolated(extension)) {
     throw new Error(`Extension ${extensionId} does not use the isolated extension API`);
   }
   handleRpcInfos(extension, platform);
   const contentSecurityPolicy = getContentSecurityPolicy(extension.contentSecurityPolicy, absolutePath, extension.rpc);
-  await activateIsolatedExtension(extensionId, absolutePath, extension.workerName || '', contentSecurityPolicy, activationEvent);
-};
-
-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}`;
+  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 ContentType = 'Content-Type';
@@ -2641,6 +2890,14 @@ const withDisabledState = (extensions, disabledIds, enabledIds = []) => {
   });
 };
 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;
   }
@@ -2675,31 +2932,89 @@ const getAllExtensionsWithState = async (extensionsState, assetDir, platform) =>
   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;
+    }
+    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 getAllExtensions = async (assetDir, platform) => {
   return getAllExtensionsWithState(get$7(), assetDir, platform);
 };
 
-const notifyRunningExtensionsChanged = () => {
+const notifyRunningExtensionsChanged = applicationId => {
   setTimeout(() => {
-    void invoke$4('Layout.handleExtensionsChanged');
+    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);
 const runningExtensions = Object.create(null);
-const resetExtensionActivation = extensionId => {
+const applicationActivations = new Map();
+const getActivationState = application => {
+  if (application?.applicationId === undefined) {
+    return {
+      activatingExtensions,
+      runningExtensions
+    };
+  }
+  const key = JSON.stringify([application.applicationId, application.applicationGeneration]);
+  let activation = applicationActivations.get(key);
+  if (!activation) {
+    activation = {
+      activatingExtensions: Object.create(null),
+      runningExtensions: Object.create(null)
+    };
+    applicationActivations.set(key, activation);
+  }
+  return activation;
+};
+const resetExtensionActivation = (extensionId, application) => {
+  const {
+    activatingExtensions,
+    runningExtensions
+  } = getActivationState(application);
   delete activatingExtensions[extensionId];
   delete runningExtensions[extensionId];
 };
-const resetAllExtensionActivations = () => {
+const resetAllExtensionActivations = application => {
+  const {
+    activatingExtensions,
+    runningExtensions
+  } = getActivationState(application);
   for (const extensionId of Object.keys(activatingExtensions)) {
     delete activatingExtensions[extensionId];
   }
   for (const extensionId of Object.keys(runningExtensions)) {
     delete runningExtensions[extensionId];
   }
+  if (application?.applicationId !== undefined) {
+    applicationActivations.delete(JSON.stringify([application.applicationId, application.applicationGeneration]));
+  }
 };
-const waitForExtensionActivations = async () => {
+const waitForExtensionActivations = async application => {
+  const {
+    activatingExtensions
+  } = getActivationState(application);
   await Promise.all(Object.values(activatingExtensions));
 };
 const matchesEvent$1 = (extension, event) => {
@@ -2711,28 +3026,44 @@ const getExtensionId$3 = extension => {
 const getAbsolutePath$1 = (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) => {
+const doActivateExtension = async (extension, absolutePath, event, platform, activation) => {
+  const {
+    activatingExtensions,
+    runningExtensions
+  } = activation;
   const extensionId = getExtensionId$3(extension);
   try {
     await activateExtension3(extension, absolutePath, event, platform);
     runningExtensions[extensionId] = true;
-    notifyRunningExtensionsChanged();
+    if (extension.applicationId === undefined) {
+      notifyRunningExtensionsChanged();
+    } else {
+      notifyRunningExtensionsChanged(extension.applicationId);
+    }
   } finally {
     delete activatingExtensions[extensionId];
   }
 };
-const activateExtension = async (extension, event, assetDir, platform) => {
+const activateExtension = async (extension, event, assetDir, platform, activation) => {
+  const {
+    activatingExtensions,
+    runningExtensions
+  } = activation;
   const extensionId = getExtensionId$3(extension);
   if (runningExtensions[extensionId]) {
     return;
   }
   if (!Object.hasOwn(activatingExtensions, extensionId)) {
     const absolutePath = getAbsolutePath$1(extension, assetDir, platform);
-    activatingExtensions[extensionId] = doActivateExtension(extension, absolutePath, event, platform);
+    activatingExtensions[extensionId] = doActivateExtension(extension, absolutePath, event, platform, activation);
   }
   await activatingExtensions[extensionId];
 };
-const activateByEvent = async (event, assetDir, platform) => {
+const activateByEvent = async (event, assetDir, platform, application) => {
+  const activation = getActivationState(application);
+  const {
+    activatingExtensions
+  } = activation;
   try {
     if (event === 'none') {
       await Promise.all(Object.values(activatingExtensions));
@@ -2745,10 +3076,10 @@ const activateByEvent = async (event, assetDir, platform) => {
       assetDir: resolvedAssetDir,
       platform: resolvedPlatform
     } = await getRuntimeContext(assetDir, platform);
-    const extensions = await getAllExtensions(resolvedAssetDir, resolvedPlatform);
+    const extensions = application?.applicationId === undefined ? await getAllExtensions(resolvedAssetDir, resolvedPlatform) : await getAllExtensionsWithState(application, resolvedAssetDir, resolvedPlatform);
     const matchingExtensions = extensions.filter(extension => matchesEvent$1(extension, event));
     for (const extension of matchingExtensions) {
-      await activateExtension(extension, event, resolvedAssetDir, resolvedPlatform);
+      await activateExtension(extension, event, resolvedAssetDir, resolvedPlatform, activation);
     }
     return {
       error: undefined,
@@ -2856,15 +3187,6 @@ const createWebViewWorkerRpc2 = async (rpcInfo, port) => {
   });
 };
 
-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
-
 /**
  * @deprecated use createWebViewWorkerRpc2 which passes the worker url as a parameter
  */
@@ -3050,6 +3372,37 @@ const disposeAllExtensionRuntimes = async (getExtensions = getAllExtensions) =>
   }
 };
 
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const disposeExtensionApplication = async applicationId => {
+  const application = get$7(applicationId);
+  const ids = new Set([...getIds(applicationId), ...getPendingExtensionIds(application)]);
+  const runtimes = ids.values().map(id => ({
+    id,
+    rpc: get$3(id, applicationId)
+  })).toArray();
+  // Invalidate pending activations and extension callbacks before awaiting teardown.
+  removeApplication(applicationId);
+  clear(applicationId);
+  resetAllExtensionActivations(application);
+  reset(applicationId);
+  const results = await Promise.allSettled([dispose(application), ...runtimes.map(async ({
+    id,
+    rpc
+  }) => {
+    const runtimeId = getRuntimeId(id, application);
+    const disposal = await Promise.allSettled([Promise.try(() => rpc?.dispose()), invoke('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}`);
+    }
+  })]);
+  const errors = results.filter(result => result.status === 'rejected').map(result => result.reason);
+  if (errors.length > 0) {
+    throw new AggregateError(errors, `Failed to dispose extension application ${applicationId}`);
+  }
+};
+
 const enableExtension2 = async (id, platform) => {
   string(id);
   number(platform);
@@ -3089,14 +3442,21 @@ const getRpcForCommand = async (extensionsState, id, platform) => {
     return undefined;
   }
   const extensionId = getExtensionId$2(extension);
-  const existingRpc = get$3(extensionId);
+  const existingRpc = get$3(extensionId, extensionsState.applicationId);
   if (existingRpc) {
     return existingRpc;
   }
-  await activateByEvent(`onCommand:${id}`, '', platform);
-  return get$3(extensionId);
+  if (extensionsState.applicationId === undefined) {
+    await activateByEvent(`onCommand:${id}`, '', platform);
+  } else {
+    await activateByEvent(`onCommand:${id}`, '', platform, extensionsState);
+  }
+  return get$3(extensionId, extensionsState.applicationId);
 };
-const executeRendererCommand = (id, args) => {
+const executeRendererCommand = (id, args, applicationId) => {
+  if (applicationId !== undefined) {
+    return invoke$4('Application.execute', applicationId, id, ...args);
+  }
   return invoke$4(id, ...args);
 };
 const executeCommand = async (extensionsState, id, ...args) => {
@@ -3107,7 +3467,7 @@ const executeCommand = async (extensionsState, id, ...args) => {
   if (wasFound) {
     return result;
   }
-  return executeRendererCommand(id, args);
+  return executeRendererCommand(id, args, extensionsState.applicationId);
 };
 const executeExtensionCommand = async (extensionsState, id, ...args) => {
   const {
@@ -3233,16 +3593,23 @@ 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);
+  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);
-  notify();
+  const rpc = await activateIsolatedExtension(extensionId, absolutePath, extension.workerName || '', contentSecurityPolicy, activationEvent, getOrCreate, extension.applicationId);
+  if (extension.applicationId === undefined) {
+    notify();
+  } else {
+    notify(extension.applicationId);
+  }
   return rpc;
 };
 
@@ -4997,8 +5364,8 @@ const getRuntimeStatus = async (extensionId, get = getMemoryUsage) => {
 const getItems = async rpc => {
   return rpc.invoke('ExtensionApi.getStatusBarItems');
 };
-const getStatusBarItems = async () => {
-  const rpcs = getAll();
+const getStatusBarItems = async applicationId => {
+  const rpcs = getAll(applicationId);
   const results = await Promise.all(rpcs.map(getItems));
   return results.flat();
 };
@@ -5106,17 +5473,17 @@ const getViews = async (assetDir, platform) => {
 
 const handleData = () => {};
 
-const invokeHandler = async (extensionId, changes) => {
-  const rpc = get$3(extensionId);
+const invokeHandler = async (extensionId, changes, applicationId) => {
+  const rpc = get$3(extensionId, applicationId);
   if (!rpc) {
-    unregister(extensionId);
+    unregister(extensionId, applicationId);
     return;
   }
   await rpc.invoke('ExtensionApi.handleFileChanges', changes);
 };
-const handleFileChanges = async (changes = {}) => {
-  const extensionIds = getRegisteredExtensionIds();
-  await Promise.allSettled(extensionIds.map(async extensionId => invokeHandler(extensionId, changes)));
+const handleFileChanges = async (changes = {}, applicationId) => {
+  const extensionIds = getRegisteredExtensionIds(applicationId);
+  await Promise.allSettled(extensionIds.map(async extensionId => invokeHandler(extensionId, changes, applicationId)));
 };
 
 const StatusBarWorker = 200;
@@ -5480,15 +5847,60 @@ const readMicLevels = async options => {
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
 const wrapCommand = command => {
-  return (...args) => {
+  const wrapped = (...args) => {
     return command(get$7(), ...args);
   };
+  return Object.assign(wrapped, {
+    withState: command
+  });
 };
 const wrapSourceControlProviderCommand = methodName => {
   return wrapCommand((extensionsState, providerId, ...args) => {
     return executeRequiredSourceControlProvider(extensionsState, providerId, methodName, ...args);
   });
 };
+const sharedApplicationCommands = new Set(['Extensions.getColorThemeCss', 'Extensions.getColorThemeCssFromJson', 'Extensions.getColorThemeJson', 'Extensions.getColorThemeNames', 'Extensions.getPreference', 'Extensions.setPreference']);
+const invokeForApplication = async (applicationId, method, ...args) => {
+  const application = get$7(applicationId);
+  const command = commandMap[method];
+  if (command?.withState) {
+    return command.withState(application, ...args);
+  }
+  if (command && sharedApplicationCommands.has(method)) {
+    return command(...args);
+  }
+  switch (method) {
+    case 'ExtensionApi.readFile':
+      return invoke('Application.execute', applicationId, 'FileSystem.readFile', ...args);
+    case 'Extensions.activateByEvent':
+      return activateByEvent(args[0], args[1], args[2] ?? application.platform, application);
+    case 'Extensions.createWebViewWorkerRpc':
+      return createWorker(application, args[0], args[1], true);
+    case 'Extensions.createWebViewWorkerRpc2':
+      return createWorker(application, args[0], args[1]);
+    case 'Extensions.getAllExtensions':
+      return getAllExtensionsWithState(application, args[0] || '', args[1] ?? application.platform);
+    case 'Extensions.getDynamicWebExtensions':
+      return application.webExtensions;
+    case 'Extensions.getRpcInfo':
+      return getRpcInfo$1(application, args[0]);
+    case 'Extensions.getRuntimeStatus':
+      return getRuntimeStatus$1(args[0], applicationId);
+    case 'Extensions.getStatusBarItems':
+      return getStatusBarItems(applicationId);
+    case 'Extensions.getViews':
+      {
+        const extensions = await getAllExtensionsWithState(application, args[0] || '', args[1] ?? application.platform);
+        return getViewsFromExtensions(extensions, args[0] || '', args[1] ?? application.platform);
+      }
+    case 'Extensions.handleFileChanges':
+      return handleFileChanges(args[0], applicationId);
+    case 'Extensions.sendMessagePortToFileSystemWorker':
+      return createFileSystemPort(application, args[0]);
+    default:
+      throw new Error(`Extension command does not support application context: ${method}`);
+  }
+};
 const commandMap = {
   'ExtensionApi.readFile': readFile,
   'ExtensionHost.sourceControlGetChangedFiles': wrapSourceControlProviderCommand('executeSourceControlGetChangedFiles'),
@@ -5511,6 +5923,7 @@ const commandMap = {
   'Extensions.addWebExtension': addWebExtension,
   'Extensions.clearNotifications': clearNotifications,
   'Extensions.clearOutputChannel': wrapCommand(clearOutputChannel),
+  'Extensions.createApplication': createApplication,
   'Extensions.createViewInstance': createViewInstance,
   'Extensions.createWebViewWorkerRpc': createWebViewWorkerRpc,
   'Extensions.createWebViewWorkerRpc2': createWebViewWorkerRpc2,
@@ -5520,6 +5933,7 @@ const commandMap = {
   'Extensions.dismissNotification': dismissNotification,
   'Extensions.dispatchViewEvent': dispatchViewEvent,
   'Extensions.disposeAllRuntimes': disposeAllExtensionRuntimes,
+  'Extensions.disposeApplication': disposeExtensionApplication,
   'Extensions.disposeViewInstance': disposeViewInstance,
   'Extensions.enable': enableExtension,
   'Extensions.enable2': enableExtension2,
@@ -5579,6 +5993,7 @@ const commandMap = {
   'Extensions.initialize': initialize,
   'Extensions.install': installExtension,
   'Extensions.invalidateExtensionsCache': invalidateExtensionsCache,
+  'Extensions.invokeForApplication': invokeForApplication,
   'Extensions.readOutputChannel': wrapCommand(readOutputChannel),
   'Extensions.renderViewInstance': renderViewInstance,
   'Extensions.requestViewRerender': requestViewRerender,