@lvce-editor/extension-management-worker 4.72.1 → 4.74.0

package/dist/extensionManagementWorkerMain.js

@@ -34,12 +34,12 @@ const state$4 = {
   extensionsState: createInitialState(),
   nextApplicationGeneration: 0
 };
-const applications$1 = new Map();
+const applications$2 = new Map();
 const createApplication = (applicationId, platform, webExtensions) => {
-  if (!applicationId || applications$1.has(applicationId)) {
+  if (!applicationId || applications$2.has(applicationId)) {
     throw new Error(`Invalid or duplicate extension application: ${applicationId}`);
   }
-  applications$1.set(applicationId, {
+  applications$2.set(applicationId, {
     ...createInitialState(),
     applicationGeneration: ++state$4.nextApplicationGeneration,
     applicationId,
@@ -48,13 +48,13 @@ const createApplication = (applicationId, platform, webExtensions) => {
   });
 };
 const removeApplication = applicationId => {
-  applications$1.delete(applicationId);
+  applications$2.delete(applicationId);
 };
 const isCurrentApplication = application => {
   if (application.applicationId === undefined) {
     return true;
   }
-  const current = applications$1.get(application.applicationId);
+  const current = applications$2.get(application.applicationId);
   return current !== undefined && current.applicationGeneration === application.applicationGeneration;
 };
 const assertCurrentApplication = application => {
@@ -64,7 +64,7 @@ const assertCurrentApplication = application => {
 };
 const get$7 = applicationId => {
   if (applicationId !== undefined) {
-    const application = applications$1.get(applicationId);
+    const application = applications$2.get(applicationId);
     if (!application) {
       throw new Error(`Extension application not found: ${applicationId}`);
     }
@@ -78,7 +78,7 @@ const set$d = newState => {
     if (newState.applicationGeneration !== currentState.applicationGeneration) {
       throw new Error(`Stale extension application state: ${newState.applicationId}`);
     }
-    applications$1.set(newState.applicationId, newState);
+    applications$2.set(newState.applicationId, newState);
     return;
   }
   state$4.extensionsState = newState;
@@ -770,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 => {
@@ -1293,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
@@ -1361,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({
@@ -1436,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
@@ -1451,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);
@@ -1687,35 +1687,35 @@ const createNodeRpcMessagePort = async (extensionId, rpcId, port) => {
 };
 
 const extensionIds = new Set();
-const applications = new Map();
-const register = (extensionId, applicationId) => {
+const applications$1 = new Map();
+const register$1 = (extensionId, applicationId) => {
   if (applicationId === undefined) {
     extensionIds.add(extensionId);
     return;
   }
-  const ids = applications.get(applicationId) || new Set();
+  const ids = applications$1.get(applicationId) || new Set();
   ids.add(extensionId);
-  applications.set(applicationId, ids);
+  applications$1.set(applicationId, ids);
 };
 const unregister = (extensionId, applicationId) => {
   if (applicationId === undefined) {
     extensionIds.delete(extensionId);
     return;
   }
-  const ids = applications.get(applicationId);
+  const ids = applications$1.get(applicationId);
   ids?.delete(extensionId);
   if (ids?.size === 0) {
-    applications.delete(applicationId);
+    applications$1.delete(applicationId);
   }
 };
 const getRegisteredExtensionIds = applicationId => {
-  return [...(applicationId === undefined ? extensionIds : applications.get(applicationId) || [])];
+  return [...(applicationId === undefined ? extensionIds : applications$1.get(applicationId) || [])];
 };
 const reset = applicationId => {
   if (applicationId === undefined) {
     extensionIds.clear();
   } else {
-    applications.delete(applicationId);
+    applications$1.delete(applicationId);
   }
 };
 
@@ -1957,7 +1957,7 @@ const createExtensionCommandMap = (extensionId, invokeCommand = invokeGlobalComm
       return getSecret(extensionId, key);
     },
     'Extensions.registerFileChangeHandler'() {
-      register(extensionId);
+      register$1(extensionId);
     },
     'Extensions.sendMessagePortToElectron'(port, initialCommand) {
       if (initialCommand !== allowedElectronPortCommand) {
@@ -1986,6 +1986,269 @@ const createExtensionCommandExecutor = commandMap => {
   };
 };
 
+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 getOrigin = () => {
+  return globalThis.location?.origin || 'http://localhost';
+};
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const allowedScriptSources = new Set([`'self'`, `'unsafe-eval'`]);
+const allowedConnectSchemeSources = new Set(['https:', 'wss:']);
+const reservedDirectives = new Set(['child-src', 'connect-src', 'default-src', 'script-src', 'worker-src']);
+const nodeProcessType = 'node-process';
+const loopbackWildcardPortSourceRegex = /^(?:http|ws):\/\/(?:127\.0\.0\.1|localhost):\*$/;
+const parseDirective = directive => {
+  if (directive.includes('\n') || directive.includes('\r')) {
+    throw new Error('content security policy directives cannot contain newlines');
+  }
+  return directive.replace(/;$/, '').trim().split(/\s+/);
+};
+const getWorkerUrls = absolutePath => {
+  const applicationUrl = new URL(getOrigin());
+  const workerUrl = new URL(absolutePath, applicationUrl);
+  if (workerUrl.protocol !== 'http:' && workerUrl.protocol !== 'https:') {
+    return {
+      origin: applicationUrl.origin
+    };
+  }
+  const webSocketProtocol = applicationUrl.protocol === 'https:' ? 'wss:' : 'ws:';
+  return {
+    assetSource: new URL('./', workerUrl).href,
+    capabilitySource: `${webSocketProtocol}//${applicationUrl.host}/websocket/capability`,
+    nodeProcessSource: `${webSocketProtocol}//${applicationUrl.host}/websocket/extension-node-process`,
+    origin: applicationUrl.origin
+  };
+};
+const hasNodeProcess = rpcInfos => {
+  return rpcInfos?.some(rpcInfo => typeof rpcInfo === 'object' && rpcInfo !== null && rpcInfo.type === nodeProcessType) === true;
+};
+const validateExternalConnectSource = (source, applicationOrigin) => {
+  if (allowedConnectSchemeSources.has(source) || loopbackWildcardPortSourceRegex.test(source)) {
+    return source;
+  }
+  if (source.includes('*') || source === `'none'` || source === 'http:' || source === 'ws:') {
+    throw new Error(`invalid isolated extension connect source ${source}`);
+  }
+  let url;
+  try {
+    url = new URL(source);
+  } catch {
+    throw new Error(`isolated extension connect source must be an absolute URL. Invalid value: ${JSON.stringify(source)}`);
+  }
+  if (!['http:', 'https:', 'ws:', 'wss:'].includes(url.protocol) || !url.hostname || url.username || url.password) {
+    throw new Error(`invalid isolated extension connect source ${source}`);
+  }
+  const applicationUrl = new URL(applicationOrigin);
+  if (url.host === applicationUrl.host) {
+    throw new Error(`isolated extensions cannot allow the application origin in connect-src`);
+  }
+  return source;
+};
+const addScriptSources = (scriptSources, sources) => {
+  for (const source of sources) {
+    if (!allowedScriptSources.has(source)) {
+      throw new Error(`invalid isolated extension script source ${source}`);
+    }
+    scriptSources.add(source);
+  }
+};
+const addConnectSources = (connectSources, sources, assetSource, origin) => {
+  for (const source of sources) {
+    if (source === `'self'`) {
+      if (assetSource) {
+        connectSources.add(assetSource);
+      }
+    } else {
+      connectSources.add(validateExternalConnectSource(source, origin));
+    }
+  }
+};
+const validateDefaultSources = sources => {
+  if (sources.length !== 1 || sources[0] !== `'none'`) {
+    throw new Error(`isolated extension default-src must be 'none'`);
+  }
+};
+const applyDirective = (directive, scriptSources, connectSources, assetSource, origin) => {
+  const [name, ...sources] = parseDirective(directive);
+  if (!name) {
+    return;
+  }
+  if (name === 'default-src') {
+    validateDefaultSources(sources);
+    return;
+  }
+  if (name === 'script-src') {
+    addScriptSources(scriptSources, sources);
+    return;
+  }
+  if (name === 'connect-src') {
+    addConnectSources(connectSources, sources, assetSource, origin);
+    return;
+  }
+  if (reservedDirectives.has(name)) {
+    throw new Error(`isolated extensions cannot override ${name}`);
+  }
+};
+const getContentSecurityPolicy = (directives, absolutePath, rpcInfos) => {
+  const {
+    assetSource,
+    capabilitySource,
+    nodeProcessSource,
+    origin
+  } = getWorkerUrls(absolutePath);
+  const scriptSources = new Set([`'self'`]);
+  const connectSources = new Set();
+  if (capabilitySource) {
+    connectSources.add(capabilitySource);
+  }
+  if (assetSource) {
+    connectSources.add(assetSource);
+  }
+  if (nodeProcessSource && hasNodeProcess(rpcInfos)) {
+    connectSources.add(nodeProcessSource);
+  }
+  const manifestDirectives = directives || [];
+  for (const directive of manifestDirectives) {
+    applyDirective(directive, scriptSources, connectSources, assetSource, origin);
+  }
+  const connectDirective = connectSources.size > 0 ? [...connectSources].join(' ') : `'none'`;
+  return `default-src 'none'; script-src ${[...scriptSources].join(' ')}; worker-src 'none'; child-src 'none'; connect-src ${connectDirective};`;
+};
+
+const getUrlPrefix = (platform, extensionPath) => {
+  if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
+    return extensionPath;
+  }
+  if (platform === Web) {
+    return extensionPath;
+  }
+  if (extensionPath.startsWith('/')) {
+    return `/remote${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 Map(),
+      declarations: new Map(),
+      extensionVersions: new Map(),
+      nextChild: 0,
+      ports: new Map()
+    };
+    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,
+      extensionId: extension.id,
+      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$1 = async (application, info, port, legacy = false, extensionId) => {
+  const services = getServices(application);
+  const id = JSON.stringify([application.applicationId, application.applicationGeneration, 'child', ++services.nextChild]);
+  services.children.set(id, extensionId);
+  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);
+    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);
+    throw error;
+  }
+};
+const fileSystemMethods = new Set(['readFile', 'readDirWithFileTypes', 'stat', 'exists', 'writeFile', 'mkdir', 'remove', 'rename', 'copy', 'getBlob']);
+const createFileSystemPort = async (application, port, extensionId) => {
+  const services = getServices(application);
+  const version = extensionId === undefined ? 0 : services.extensionVersions.get(extensionId) || 0;
+  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);
+    if (extensionId !== undefined && (services.extensionVersions.get(extensionId) || 0) !== version) {
+      throw new Error('Extension was reloaded while opening its filesystem port');
+    }
+    services.ports.set(rpc, extensionId);
+  } 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.keys(), rpc => Promise.try(() => rpc.dispose())), ...Array.from(services.children.keys(), 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 disposeExtension = async (application, extensionId) => {
+  const services = applications.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);
+  const children = [...services.children].filter(([, owner]) => owner === extensionId).map(([id]) => id);
+  for (const rpc of ports) services.ports.delete(rpc);
+  for (const id of children) services.children.delete(id);
+  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 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 applicationRpcs = new Map();
 const get$3 = (extensionId, applicationId) => {
@@ -2016,6 +2279,15 @@ const set$2 = (extensionId, rpc, applicationId) => {
   rpcs$1[extensionId] = rpc;
 };
 const remove$1 = (extensionId, applicationId) => {
+  if (applicationId !== undefined) {
+    const entries = applicationRpcs.get(applicationId);
+    const rpc = entries?.get(extensionId);
+    entries?.delete(extensionId);
+    if (entries?.size === 0) {
+      applicationRpcs.delete(applicationId);
+    }
+    return rpc;
+  }
   const rpc = rpcs$1[extensionId];
   delete rpcs$1[extensionId];
   return rpc;
@@ -2053,11 +2325,17 @@ const createIsolatedExtensionHostWorker = async (extensionId, absolutePath, work
   const invokeCommand = application === undefined ? undefined : (method, ...args) => {
     assertCurrentApplication(application);
     if (method === 'Extensions.registerFileChangeHandler') {
-      return register(extensionId, application.applicationId);
+      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');
@@ -2158,135 +2436,6 @@ const activateIsolatedExtension = async (extensionId, absolutePath, workerName,
   }
 };
 
-const getOrigin = () => {
-  return globalThis.location?.origin || 'http://localhost';
-};
-
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-
-const allowedScriptSources = new Set([`'self'`, `'unsafe-eval'`]);
-const allowedConnectSchemeSources = new Set(['https:', 'wss:']);
-const reservedDirectives = new Set(['child-src', 'connect-src', 'default-src', 'script-src', 'worker-src']);
-const nodeProcessType = 'node-process';
-const loopbackWildcardPortSourceRegex = /^(?:http|ws):\/\/(?:127\.0\.0\.1|localhost):\*$/;
-const parseDirective = directive => {
-  if (directive.includes('\n') || directive.includes('\r')) {
-    throw new Error('content security policy directives cannot contain newlines');
-  }
-  return directive.replace(/;$/, '').trim().split(/\s+/);
-};
-const getWorkerUrls = absolutePath => {
-  const applicationUrl = new URL(getOrigin());
-  const workerUrl = new URL(absolutePath, applicationUrl);
-  if (workerUrl.protocol !== 'http:' && workerUrl.protocol !== 'https:') {
-    return {
-      origin: applicationUrl.origin
-    };
-  }
-  const webSocketProtocol = applicationUrl.protocol === 'https:' ? 'wss:' : 'ws:';
-  return {
-    assetSource: new URL('./', workerUrl).href,
-    capabilitySource: `${webSocketProtocol}//${applicationUrl.host}/websocket/capability`,
-    nodeProcessSource: `${webSocketProtocol}//${applicationUrl.host}/websocket/extension-node-process`,
-    origin: applicationUrl.origin
-  };
-};
-const hasNodeProcess = rpcInfos => {
-  return rpcInfos?.some(rpcInfo => typeof rpcInfo === 'object' && rpcInfo !== null && rpcInfo.type === nodeProcessType) === true;
-};
-const validateExternalConnectSource = (source, applicationOrigin) => {
-  if (allowedConnectSchemeSources.has(source) || loopbackWildcardPortSourceRegex.test(source)) {
-    return source;
-  }
-  if (source.includes('*') || source === `'none'` || source === 'http:' || source === 'ws:') {
-    throw new Error(`invalid isolated extension connect source ${source}`);
-  }
-  let url;
-  try {
-    url = new URL(source);
-  } catch {
-    throw new Error(`isolated extension connect source must be an absolute URL. Invalid value: ${JSON.stringify(source)}`);
-  }
-  if (!['http:', 'https:', 'ws:', 'wss:'].includes(url.protocol) || !url.hostname || url.username || url.password) {
-    throw new Error(`invalid isolated extension connect source ${source}`);
-  }
-  const applicationUrl = new URL(applicationOrigin);
-  if (url.host === applicationUrl.host) {
-    throw new Error(`isolated extensions cannot allow the application origin in connect-src`);
-  }
-  return source;
-};
-const addScriptSources = (scriptSources, sources) => {
-  for (const source of sources) {
-    if (!allowedScriptSources.has(source)) {
-      throw new Error(`invalid isolated extension script source ${source}`);
-    }
-    scriptSources.add(source);
-  }
-};
-const addConnectSources = (connectSources, sources, assetSource, origin) => {
-  for (const source of sources) {
-    if (source === `'self'`) {
-      if (assetSource) {
-        connectSources.add(assetSource);
-      }
-    } else {
-      connectSources.add(validateExternalConnectSource(source, origin));
-    }
-  }
-};
-const validateDefaultSources = sources => {
-  if (sources.length !== 1 || sources[0] !== `'none'`) {
-    throw new Error(`isolated extension default-src must be 'none'`);
-  }
-};
-const applyDirective = (directive, scriptSources, connectSources, assetSource, origin) => {
-  const [name, ...sources] = parseDirective(directive);
-  if (!name) {
-    return;
-  }
-  if (name === 'default-src') {
-    validateDefaultSources(sources);
-    return;
-  }
-  if (name === 'script-src') {
-    addScriptSources(scriptSources, sources);
-    return;
-  }
-  if (name === 'connect-src') {
-    addConnectSources(connectSources, sources, assetSource, origin);
-    return;
-  }
-  if (reservedDirectives.has(name)) {
-    throw new Error(`isolated extensions cannot override ${name}`);
-  }
-};
-const getContentSecurityPolicy = (directives, absolutePath, rpcInfos) => {
-  const {
-    assetSource,
-    capabilitySource,
-    nodeProcessSource,
-    origin
-  } = getWorkerUrls(absolutePath);
-  const scriptSources = new Set([`'self'`]);
-  const connectSources = new Set();
-  if (capabilitySource) {
-    connectSources.add(capabilitySource);
-  }
-  if (assetSource) {
-    connectSources.add(assetSource);
-  }
-  if (nodeProcessSource && hasNodeProcess(rpcInfos)) {
-    connectSources.add(nodeProcessSource);
-  }
-  const manifestDirectives = directives || [];
-  for (const directive of manifestDirectives) {
-    applyDirective(directive, scriptSources, connectSources, assetSource, origin);
-  }
-  const connectDirective = connectSources.size > 0 ? [...connectSources].join(' ') : `'none'`;
-  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;
@@ -2295,23 +2444,10 @@ const get$2 = id => {
   return rpcs[id];
 };
 
-const getUrlPrefix = (platform, extensionPath) => {
-  if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
-    return extensionPath;
-  }
-  if (platform === Web) {
-    return extensionPath;
-  }
-  if (extensionPath.startsWith('/')) {
-    return `/remote${extensionPath}`;
-  }
-  return `/remote/${extensionPath}`;
-};
-
 const handleRpcInfos = (extension, platform) => {
   if (extension?.applicationId !== undefined) {
     if (Array.isArray(extension.rpc) && extension.rpc.length > 0) {
-      throw new Error('Declared RPCs do not support application context');
+      register(extension, platform);
     }
     return;
   }
@@ -3088,15 +3224,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
  */
@@ -3296,7 +3423,7 @@ const disposeExtensionApplication = async applicationId => {
   clear(applicationId);
   resetAllExtensionActivations(application);
   reset(applicationId);
-  const results = await Promise.allSettled(runtimes.map(async ({
+  const results = await Promise.allSettled([dispose(application), ...runtimes.map(async ({
     id,
     rpc
   }) => {
@@ -3306,7 +3433,7 @@ const disposeExtensionApplication = async applicationId => {
     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}`);
@@ -5716,6 +5843,69 @@ const getLanguages = async (platform, assetDir) => {
   }
 };
 
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const queues = new Map();
+const replace = async (application, extensionId, extension) => {
+  assertCurrentApplication(application);
+  if (!extension || typeof extension.id !== 'string' || !extension.id || typeof extension.browser !== 'string' || extension.isolated !== true) {
+    throw new Error('Expected an isolated web extension');
+  }
+  const applicationId = application.applicationId;
+  const current = get$7(applicationId);
+  if (current.webExtensions.every(({
+    id
+  }) => id !== extensionId)) {
+    throw new Error(`Application extension not found: ${extensionId}`);
+  }
+  if (extension.id !== extensionId && current.webExtensions.some(({
+    id
+  }) => id === extension.id)) {
+    throw new Error(`Duplicate application extension: ${extension.id}`);
+  }
+  // Finish pending startup before removing its RPC, including failed activations.
+  try {
+    await waitForExtensionActivations(current);
+  } catch {
+    // Failed startup must still allow replacing the broken 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))]);
+  assertCurrentApplication(application);
+  resetExtensionActivation(extensionId, application);
+  resetExtensionRuntimeState(extensionId, applicationId);
+  const errors = results.filter(result => result.status === 'rejected').map(result => result.reason);
+  if (errors.length > 0) throw new AggregateError(errors, `Failed to reload extension ${extensionId}`);
+  update({
+    cachedExtensions: undefined,
+    webExtensions: get$7(applicationId).webExtensions.map(previous => previous.id === extensionId ? {
+      ...extension
+    } : previous)
+  }, applicationId);
+};
+const run = async (previous, application, extensionId, extension) => {
+  try {
+    await previous;
+  } catch {
+    // A later save can recover from an earlier reload failure.
+  }
+  await replace(application, extensionId, extension);
+};
+const reloadApplicationExtension = async (applicationId, extensionId, extension) => {
+  const application = get$7(applicationId);
+  const key = application.applicationGeneration;
+  const previous = queues.get(key) || Promise.resolve();
+  const operation = run(previous, application, extensionId, extension);
+  queues.set(key, operation);
+  try {
+    await operation;
+  } finally {
+    if (queues.get(key) === operation) queues.delete(key);
+  }
+};
+
 const sendMessagePortToElectron = async (port, initialCommand) => {
   await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand, EmbedsWorker);
 };
@@ -5784,10 +5974,16 @@ const invokeForApplication = async (applicationId, method, ...args) => {
       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$1(application, args[0], args[1], true);
+    case 'Extensions.createWebViewWorkerRpc2':
+      return createWorker$1(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':
@@ -5799,6 +5995,8 @@ const invokeForApplication = async (applicationId, method, ...args) => {
       }
     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}`);
   }
@@ -5897,6 +6095,7 @@ const commandMap = {
   'Extensions.invalidateExtensionsCache': invalidateExtensionsCache,
   'Extensions.invokeForApplication': invokeForApplication,
   'Extensions.readOutputChannel': wrapCommand(readOutputChannel),
+  'Extensions.reloadApplicationExtension': reloadApplicationExtension,
   'Extensions.renderViewInstance': renderViewInstance,
   'Extensions.requestViewRerender': requestViewRerender,
   'Extensions.saveViewInstanceState': saveViewInstanceState,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-management-worker",
-  "version": "4.72.1",
+  "version": "4.74.0",
   "description": "Webworker for the Extension Management functionality in Lvce Editor.",
   "keywords": [
     "web-worker"