@lvce-editor/static-server 0.113.24 → 0.114.0

package/static/{4d1244a → c766415}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -309,7 +309,7 @@ const getAssetDir$2 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/4d1244a';
+    return '/c766415';
   }
 };
 const assetDir = getAssetDir$2();
@@ -843,7 +843,7 @@ const register$2 = (commandId, listener) => {
   state$K.commands[commandId] = listener;
 };
 const hasThrown = new Set();
-const execute$6 = (command, ...args) => {
+const execute$7 = (command, ...args) => {
   if (command in state$K.commands) {
     const fn = state$K.commands[command];
     if (typeof fn !== 'function') {
@@ -861,7 +861,7 @@ const execute$6 = (command, ...args) => {
       hasThrown.add(command);
       throw new CommandNotFoundError$1(command);
     }
-    return execute$6(command, ...args);
+    return execute$7(command, ...args);
   });
 };
 const setLoad = load => {
@@ -908,7 +908,7 @@ const handleJsonRpcMessage$1 = async (ipc, message, execute, resolve, source) =>
 };
 
 const handleMessage$1 = event => {
-  return handleJsonRpcMessage$1(event.target, event.data, execute$6, resolve$1, 'process');
+  return handleJsonRpcMessage$1(event.target, event.data, execute$7, resolve$1, 'process');
 };
 
 const handleIpc$1 = ipc => {
@@ -1139,7 +1139,7 @@ const handleError = async (error, notify = true, prefix = '') => {
   try {
     const prettyError = await logError$1(error, prefix);
     if (notify) {
-      await execute$6(/* Notification.create */'Notification.create', /* type */'error', /* text */getMessage$3(prettyError));
+      await execute$7(/* Notification.create */'Notification.create', /* type */'error', /* text */getMessage$3(prettyError));
     }
   } catch (otherError) {
     console.warn('ErrorHandling error');
@@ -1153,7 +1153,7 @@ const showErrorDialog = async error => {
     if (prettyError && prettyError.type === 'Object') {
       prettyError.type = 'Error';
     }
-    await execute$6(/* Dialog.showMessage */'Dialog.showMessage', /* message */prettyError);
+    await execute$7(/* Dialog.showMessage */'Dialog.showMessage', /* message */prettyError);
   } catch {
     // ignore
   }
@@ -1302,9 +1302,9 @@ const getPath$5 = (protocol, uri) => {
 const notifyFileSystemChanged = async (changes = {}, refreshWorkspaceViews = true) => {
   const effects = [];
   if (refreshWorkspaceViews) {
-    effects.push(execute$6('Layout.handleWorkspaceRefresh', changes));
+    effects.push(execute$7('Layout.handleWorkspaceRefresh', changes));
   }
-  effects.push(execute$6('Layout.refreshSourceControlBadgeCount'));
+  effects.push(execute$7('Layout.refreshSourceControlBadgeCount'));
   await Promise.allSettled(effects);
 };
 const readFile$g = async (uri, encoding = Utf8) => {
@@ -1512,7 +1512,7 @@ const parse = content => {
 };
 
 const openUri$1 = async (path, focus = true, props = {}) => {
-  await execute$6(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
+  await execute$7(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
 const state$G = {
@@ -1561,12 +1561,12 @@ const openKeyBindingsJson = async () => {
 
 const getPreferencesJson = async () => {
   if (getPlatform$4() === Web$1) {
-    const cachedPreferences = await execute$6(/* LocalStorage.getJson */'LocalStorage.getJson', /* key */'settings');
+    const cachedPreferences = await execute$7(/* LocalStorage.getJson */'LocalStorage.getJson', /* key */'settings');
     if (cachedPreferences) {
       return cachedPreferences;
     }
     const url = `${assetDir}/config/defaultSettings.json`;
-    return execute$6(/* Ajax.getJson */'Ajax.getJson', /* url */url);
+    return execute$7(/* Ajax.getJson */'Ajax.getJson', /* url */url);
   }
   return invoke$M(PreferencesGetAll);
 };
@@ -1616,7 +1616,7 @@ const set$h = async (key, value) => {
       ...getAll$3(),
       [key]: value
     };
-    await execute$6(/* LocalStorage.setJson */'LocalStorage.setJson', /* key */'preferences', /* value */preferences);
+    await execute$7(/* LocalStorage.setJson */'LocalStorage.setJson', /* key */'preferences', /* value */preferences);
     return;
   }
   const content = stringify(getAll$3());
@@ -1864,17 +1864,56 @@ const providerMethods = {
   rename: 'Rename',
   writeFile: 'WriteFile'
 };
+const getFileHashes = async (id, uris) => {
+  if (!Array.isArray(uris)) {
+    throw new TypeError('uris must be an array');
+  }
+  for (const uri of uris) {
+    if (typeof uri !== 'string') {
+      throw new TypeError('Application filesystem requires a URI');
+    }
+  }
+  const hashes = Array.from({
+    length: uris.length
+  }, () => null);
+  let nextIndex = 0;
+  const hashNext = async () => {
+    while (nextIndex < uris.length) {
+      const index = nextIndex++;
+      try {
+        const content = await execute$6(id, 'readFile', uris[index]);
+        const bytes = new TextEncoder().encode(content);
+        const digest = await crypto.subtle.digest('SHA-256', bytes);
+        hashes[index] = Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('');
+      } catch {
+        // An unreadable file is a cache miss, without failing the other hashes.
+        hashes[index] = null;
+      }
+    }
+  };
+  await Promise.all(Array.from({
+    length: Math.min(32, uris.length)
+  }, hashNext));
+  return hashes;
+};
 
 // Memory storage and extension providers are owned by the application. Only
 // immutable HTTP assets use the shared filesystem; never fall back to another
 // application's provider when a scheme is unknown.
-const execute$5 = async (id, method, ...args) => {
+const execute$6 = async (id, method, ...args) => {
+  if (method === 'getFileHashes') {
+    return getFileHashes(id, args[0]);
+  }
   const [uri] = args;
   if (typeof uri !== 'string') {
     throw new TypeError('Application filesystem requires a URI');
   }
   if (method === 'readJson') {
-    return JSON.parse(await execute$5(id, 'readFile', ...args));
+    return JSON.parse(await execute$6(id, 'readFile', ...args));
+  }
+  if (uri.startsWith('live-component-state:')) {
+    const ComponentStateFileSystem = await Promise.resolve().then(function () { return ApplicationComponentStateFileSystem; });
+    return ComponentStateFileSystem.execute(id, method, uri, ...args.slice(1));
   }
   if (uri.startsWith('untitled:') && method === 'readFile') {
     return '';
@@ -2148,7 +2187,7 @@ const getLanguageConfigurationFromWebExtension = async languageId => {
   if (!languageConfigurationPath) {
     return undefined;
   }
-  const json = await execute$6('Ajax.getJson', languageConfigurationPath);
+  const json = await execute$7('Ajax.getJson', languageConfigurationPath);
   return json;
 };
 const getLanguageConfiguration$3 = async languageId => {
@@ -2421,7 +2460,7 @@ const addWebExtension = async path => {
   }
   await invoke$L('Extensions.addExtension', manifest);
   {
-    await execute$6(`Layout.handleExtensionsChanged`);
+    await execute$7(`Layout.handleExtensionsChanged`);
   }
   // TODO avoid side effect here
   if (manifest.languages) {
@@ -3297,7 +3336,7 @@ const register$1 = commandMap => {
 const getCommand$2 = key => {
   return commands[key];
 };
-const execute$4 = (command, ...args) => {
+const execute$5 = (command, ...args) => {
   const fn = getCommand$2(command);
   if (!fn) {
     throw new CommandNotFoundError(command);
@@ -3400,7 +3439,7 @@ const logError = () => {
 };
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute$4;
+  const actualExecute = event?.target?.execute || execute$5;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
@@ -3436,6 +3475,10 @@ const create$6$1 = async ({
   messagePort.start();
   return rpc;
 };
+const PlainMessagePortRpc = {
+  __proto__: null,
+  create: create$6$1
+};
 const create$5$2 = async ({
   commandMap,
   messagePort
@@ -3543,6 +3586,7 @@ const state$B = {
   pendingFrame: undefined,
   /** @type {any} */
   rpc: undefined,
+  /** @type {Promise<any>} */
   tail: Promise.resolve()
 };
 const enqueue = operation => {
@@ -3685,6 +3729,28 @@ const invokeAndTransfer$N = (method, ...params) => {
   return invokeAndTransfer$O(method, ...params);
 };
 
+// Establish recording before any workspace worker can transfer a direct renderer port.
+const configureSessionReplay = async options => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  try {
+    const rpc = await PlainMessagePortRpc.create({
+      commandMap: commandMapRef,
+      messagePort: port1
+    });
+    const id = await invokeAndTransfer$N('SessionReplay.configureProxy', options, port2);
+    state$A.rpc = rpc;
+    reset$3(rpc);
+    return id;
+  } catch (error) {
+    port1.close();
+    port2.close();
+    throw error;
+  }
+};
+
 const requestPermission = async (handle, options) => {
   // query permission, but from renderer process
   // because handle.requestPermission is not implemented
@@ -3731,7 +3797,7 @@ const addHandle$1 = async (uri, handle) => {
   try {
     // TODO save handle in indexeddb
     handles[uri] = handle;
-    await execute$6('IndexedDb.addHandle', uri, handle);
+    await execute$7('IndexedDb.addHandle', uri, handle);
   } catch (error) {
     throw new VError$1(error, 'Failed to add handle');
   }
@@ -3764,11 +3830,11 @@ const getHandle$1 = async uri => {
     if (uri in handles) {
       return handles[uri];
     }
-    let handle = await execute$6('IndexedDb.getHandle', uri);
+    let handle = await execute$7('IndexedDb.getHandle', uri);
     if (!handle) {
       const legacyKeys = getLegacyHtmlKeys(uri);
       for (const legacyKey of legacyKeys) {
-        handle = await execute$6('IndexedDb.getHandle', legacyKey);
+        handle = await execute$7('IndexedDb.getHandle', legacyKey);
         if (handle) {
           await addHandle$1(uri, handle);
           handles[legacyKey] = handle;
@@ -4147,7 +4213,7 @@ const show$c = async picks => {
     resolve,
     promise
   } = withResolvers();
-  await execute$6('QuickPick.showCustom', picks, resolve);
+  await execute$7('QuickPick.showCustom', picks, resolve);
   return promise;
 };
 const showQuickPick = (options, applicationId) => {
@@ -4308,8 +4374,8 @@ const shouldTrace = (selectors, traceId) => {
   return selectors.has('*') || Boolean(traceId && selectors.has(traceId));
 };
 
-const version = '0.113.24';
-const commit$1 = '4d1244a';
+const version = '0.114.0';
+const commit$1 = 'c766415';
 const productNameLong$1 = 'Lvce Editor - OSS';
 const getPid = () => {
   return invoke$M('Process.getPid');
@@ -5287,7 +5353,7 @@ const updateDiagnosticsWithCommand = async executeCommand => {
   await executeCommand('Viewlet.executeViewletCommand', instance.state.id, 'updateDiagnostics');
 };
 const updateDiagnostics$2 = async () => {
-  await updateDiagnosticsWithCommand(execute$6);
+  await updateDiagnosticsWithCommand(execute$7);
 };
 const setSelectionsWithCommand = async (executeCommand, selections) => {
   const instance = getInstance$1(EditorText);
@@ -5297,7 +5363,7 @@ const setSelectionsWithCommand = async (executeCommand, selections) => {
   await executeCommand('Viewlet.executeViewletCommand', instance.state.id, 'setSelections', new Uint32Array(selections));
 };
 const setSelections = async selections => {
-  await setSelectionsWithCommand(execute$6, selections);
+  await setSelectionsWithCommand(execute$7, selections);
 };
 const updateAllDiagnosticsWithCommand = async invoke => {
   await invoke('Editor.updateDiagnosticsAll');
@@ -5413,7 +5479,7 @@ const dispatch = (key, command) => (...args) => {
   const event = pendingEvent.then(() => {
     const browserViewId = command === 'handleContextMenu' ? args[0]?.browserViewId : args[0];
     const instance = getValues().find(item => item.moduleId === 'SimpleBrowser' && item.state.tabs.some(tab => tab.browserViewId === browserViewId));
-    if (instance) return execute$6('Viewlet.executeViewletCommand', instance.state.uid, command, ...args);
+    if (instance) return execute$7('Viewlet.executeViewletCommand', instance.state.uid, command, ...args);
     return emitEvent(key, ...args);
   });
   pendingEvent = event.catch(() => {});
@@ -7016,7 +7082,7 @@ const isValid$1 = resolvedRoot => {
   return resolvedRoot && typeof resolvedRoot.path === 'string' && typeof resolvedRoot.uri === 'string' && typeof resolvedRoot.homeDir === 'string' && typeof resolvedRoot.pathSeparator === 'string';
 };
 const getResolveRootFromSessionStorage = async () => {
-  const resolvedRoot = await execute$6(/* SessionStorage.getJson */'SessionStorage.getJson', /* key */'workspace');
+  const resolvedRoot = await execute$7(/* SessionStorage.getJson */'SessionStorage.getJson', /* key */'workspace');
   if (!isValid$1(resolvedRoot)) {
     return undefined;
   }
@@ -7354,7 +7420,7 @@ const handleRemoteCliOpenRequest = async request => {
     workspacePath: resolved.workspacePath
   });
   if (resolved.fileUri) {
-    await execute$6('Main.openUri', resolved.fileUri);
+    await execute$7('Main.openUri', resolved.fileUri);
   }
 };
 const getPath$3 = () => {
@@ -7365,8 +7431,8 @@ const getUri$1 = () => {
 };
 const supportsConnectionCommand = () => true;
 const close$4 = async () => {
-  await execute$6('Main.closeAllEditorsAndSave');
-  const hasDirtyTabs = await execute$6('Main.hasDirtyTabs');
+  await execute$7('Main.closeAllEditorsAndSave');
+  const hasDirtyTabs = await execute$7('Main.hasDirtyTabs');
   if (hasDirtyTabs) {
     return;
   }
@@ -7619,7 +7685,7 @@ const run$2 = async (method, overlayId) => {
       continue;
     }
     try {
-      await execute$6('Viewlet.executeViewletCommand', instance.state.uid, method, overlayId);
+      await execute$7('Viewlet.executeViewletCommand', instance.state.uid, method, overlayId);
     } catch (error) {
       console.error(`[renderer-worker] Failed to ${method} for Simple Browser`, error);
     }
@@ -8870,7 +8936,7 @@ const loadInternal = async (viewlet, focus, restore, restoreState) => {
       setFocusedInstanceByType(viewletUid, moduleId);
     }
     if (newState.badgeCount) {
-      await execute$6('Layout.handleBadgeCountChange');
+      await execute$7('Layout.handleBadgeCountChange');
     }
     if (module.hasFunctionalRootRender) {
       if (module.hasDirectRender) {
@@ -9512,7 +9578,7 @@ const handleKeyBinding$1 = async identifier => {
   if (!keyBinding) {
     throw new Error(`keybinding not found for identifier ${identifier}`);
   }
-  await execute$6(/* command */keyBinding.command,
+  await execute$7(/* command */keyBinding.command,
   // TODO should args always be defined? (probably yes -> monomorphism & simpler code since all objects are the same)
   ...(keyBinding.args || []));
   // TODO
@@ -9937,7 +10003,7 @@ const openWidgetForApplication = (applicationId, moduleId, ...args) => {
   return openWidgetWithLayout(getState$2(Layout, applicationId), moduleId, ...args);
 };
 const openWidgetWithLayout = async (layout, moduleId, ...args) => {
-  const applicationId = moduleId === QuickPick ? layout?.applicationId : undefined;
+  const applicationId = moduleId === QuickPick || moduleId === Dialog ? layout?.applicationId : undefined;
   const existingInstance = getInstance$1(moduleId, applicationId);
   const type = args[0];
   const isOwnedWidget = moduleId === DefineKeyBinding && typeof args[0] === 'number';
@@ -10174,7 +10240,7 @@ const disposeWidgetWithValue = async (id, value) => {
 
 const show$a = async (...args) => {
   // TODO show custom quickpick
-  await execute$6('Viewlet.openWidget', QuickPick, ...args);
+  await execute$7('Viewlet.openWidget', QuickPick, ...args);
   return undefined;
 };
 const showFile = () => {
@@ -10221,7 +10287,7 @@ const waitForHost = () => hostReady.promise;
 const initialize$3 = async (options, layoutUid) => {
   await invoke$L('Extensions.createApplication', options.id, getPlatform$4(), options.extensions || []);
   for (const [uri, content] of Object.entries(options.files || {})) {
-    await execute$5(options.id, 'writeFile', uri, content);
+    await execute$6(options.id, 'writeFile', uri, content);
   }
   const commands = await load$7({
     applicationId: options.id,
@@ -10276,7 +10342,7 @@ const create$1c = async options => {
     throw error;
   }
 };
-const execute$3 = (applicationId, command, ...args) => {
+const execute$4 = (applicationId, command, ...args) => {
   const application = assertOpen(applicationId);
   if (command === 'Main.openInput' && application.textFileExtensions?.length) {
     const [options] = args;
@@ -10311,7 +10377,7 @@ const execute$3 = (applicationId, command, ...args) => {
   if (command.startsWith('FileSystem.')) {
     return track(applicationId, async () => {
       const method = command.slice('FileSystem.'.length);
-      const result = await execute$5(applicationId, method, ...args);
+      const result = await execute$6(applicationId, method, ...args);
       if (method === 'writeFile' || method === 'remove' || method === 'rename' || method === 'mkdir' || method === 'createFile' || method === 'copy') {
         const changes = method === 'remove' ? {
           deleted: [args[0]]
@@ -10331,6 +10397,15 @@ const execute$3 = (applicationId, command, ...args) => {
     });
   }
   switch (command) {
+    case 'Notification.create':
+      return track(applicationId, () => invoke$I('Notification.create', args[0], args[1], application.layoutUid));
+    case 'Dialog.show':
+      return track(applicationId, () => openWidgetForApplication(applicationId, Dialog, args[0]));
+    case 'Dialog.showWarning':
+      return track(applicationId, () => openWidgetForApplication(applicationId, Dialog, {
+        ...args[0],
+        type: 'warning'
+      }));
     case 'Viewlet.openWidget':
       return track(applicationId, () => openWidgetForApplication(applicationId, args[0], ...args.slice(1)));
     case 'QuickPick.showCustom':
@@ -10350,7 +10425,7 @@ const execute$3 = (applicationId, command, ...args) => {
         await invoke$L('Extensions.reloadApplicationExtension', applicationId, ...args);
         for (const uid of getUids(applicationId)) {
           const instance = getByUid(uid);
-          if (instance?.moduleId === EditorText) {
+          if (instance?.moduleId === EditorText || instance?.moduleId === ExtensionView$1) {
             await executeViewletCommand(uid, 'loadContent', undefined, {
               preserveFocus: true
             });
@@ -10378,7 +10453,7 @@ const execute$3 = (applicationId, command, ...args) => {
       return Promise.resolve(application.href);
     case 'Preferences.get':
     case 'Preferences.update':
-      return Promise.resolve(execute$6(command, ...args));
+      return Promise.resolve(execute$7(command, ...args));
     default:
       return track(applicationId, () => executeForApplication(applicationId, command, ...args));
   }
@@ -10395,9 +10470,9 @@ const executeForView = (uid, command, ...args) => {
     if (!getByUid(uid)) {
       return Promise.reject(new Error(`Component not found: ${uid}`));
     }
-    return Promise.resolve(execute$6(command, ...args));
+    return Promise.resolve(execute$7(command, ...args));
   }
-  return execute$3(applicationId, command, ...args);
+  return execute$4(applicationId, command, ...args);
 };
 const resize$I = (applicationId, width, height) => {
   if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
@@ -10407,7 +10482,7 @@ const resize$I = (applicationId, width, height) => {
     const {
       layoutUid
     } = get$j(applicationId);
-    await execute$3(applicationId, 'Layout.handleResize', width, height);
+    await execute$4(applicationId, 'Layout.handleResize', width, height);
     await invoke$I('Viewlet.setBounds', layoutUid, 0, 0, width, height);
   });
 };
@@ -10559,7 +10634,7 @@ const setColorTheme = async colorThemeId => {
   }
   // TODO should preferences throw errors or should it call handleError directly?
   await set$h('workbench.colorTheme', colorThemeId);
-  await execute$6('Layout.handleColorThemeChanged', colorThemeId);
+  await execute$7('Layout.handleColorThemeChanged', colorThemeId);
   return undefined;
 };
 const watch$3 = async id => {
@@ -11209,7 +11284,7 @@ const launchTestWorker = async () => {
   }
 };
 
-const execute$2 = async href => {
+const execute$3 = async href => {
   const ipc = await launchTestWorker();
   await invoke$O(ipc, 'Test.execute', href, getPlatform$4(), assetDir);
 };
@@ -11272,7 +11347,7 @@ const executeCurrentTest = async (platform, initData) => {
     return;
   }
   const jsPath = await getTestFilePath(platform, href);
-  await execute$2(jsPath);
+  await execute$3(jsPath);
 };
 
 const map$1 = {
@@ -11725,7 +11800,7 @@ const openInitialUri = async href => {
   if (!uri) {
     return;
   }
-  await execute$6('Main.openUri', uri);
+  await execute$7('Main.openUri', uri);
 };
 
 /**
@@ -11792,7 +11867,7 @@ const getResponse = async (url, options) => {
 };
 
 const defaultDependencies$4 = {
-  executeCommand: execute$6,
+  executeCommand: execute$7,
   getJson: getJson$1
 };
 const getOnLoadCommands = async (assetDir, getJson = getJson$1) => {
@@ -11802,7 +11877,7 @@ const getOnLoadCommands = async (assetDir, getJson = getJson$1) => {
   }
   return commands;
 };
-const executeOnLoadCommands = async (commands, executeCommand = execute$6) => {
+const executeOnLoadCommands = async (commands, executeCommand = execute$7) => {
   for (const item of commands) {
     const {
       args = [],
@@ -12275,7 +12350,7 @@ const run = async (promptOrOptions, authState) => {
     }
     fileSystemAccess = getFileSystemAccess(options);
     const commandArguments = getCommandArguments(prompt, fileSystemAccess, accessToken);
-    result = await execute$6('ExtensionHost.executeCommand', 'chat2.runPrompt', ...commandArguments);
+    result = await execute$7('ExtensionHost.executeCommand', 'chat2.runPrompt', ...commandArguments);
     if (result?.status !== 'completed') {
       throw new Error(result?.error || 'Chat task failed without an error message');
     }
@@ -12405,14 +12480,16 @@ const state$c = {
   configuration: '',
   pending: Promise.resolve()
 };
-const startRecording$1 = async authState => {
+const startRecording$1 = async (authState, startup = false) => {
   const local = get$l('sessionReplay.enabled') === true;
   const upload = get$l('sessionReplay.uploadEnabled') === true;
   if (!state$c.configuration && !local && !upload) return;
   const backendUrl = get$l('layout.backendUrl') || getBackendUrl$1();
   const endpoint = new URL('/session-replay', backendUrl);
   const href = await getHref$1();
-  if (new URL(href).searchParams.get('allowAnonymous') === 'true') endpoint.searchParams.set('allowAnonymous', 'true');
+  if (get$l('sessionReplay.allowAnonymousUploads') === true || new URL(href).searchParams.get('allowAnonymous') === 'true') {
+    endpoint.searchParams.set('allowAnonymous', 'true');
+  }
   const options = {
     local,
     upload,
@@ -12421,21 +12498,33 @@ const startRecording$1 = async authState => {
   };
   const configuration = JSON.stringify(options);
   if (configuration === state$c.configuration) return;
-  const id = await invoke$I('SessionReplay.configure', options);
+  if (startup && (local || upload)) {
+    state$d.sessionId = await configureSessionReplay(options);
+    state$c.configuration = configuration;
+    return;
+  }
+  await invoke$I('SessionReplay.configure', {
+    ...options,
+    local: false,
+    upload: false
+  });
   state$c.configuration = configuration;
-  state$d.sessionId = id;
+  state$d.sessionId = '';
+  if (local || upload) {
+    await execute$7('Notification.create', 'info', 'Reload the window to start session replay');
+  }
 };
 const getSessionContent = async () => JSON.stringify(await invoke$I('SessionReplay.getSession'));
 const downloadSession = async () => {
   const session = await invoke$I('SessionReplay.getSession');
-  await execute$6('Download.downloadJson', session, `${session.id}.json`);
+  await execute$7('Download.downloadJson', session, `${session.id}.json`);
 };
 const replaySession = async sessionId => {
   const url = new URL(await getHref$1());
   url.search = '';
   url.hash = '';
   url.searchParams.set('replayId', sessionId);
-  await execute$6('Open.openUrl', url.href);
+  await execute$7('Open.openUrl', url.href);
 };
 const replayCurrentSession = async () => {
   const sessionId = state$d.sessionId;
@@ -12446,7 +12535,7 @@ const openSession = async () => {
   const url = new URL(await getHref$1());
   url.search = '?sessionReplay=true';
   url.hash = '';
-  await execute$6('Open.openUrl', url.href);
+  await execute$7('Open.openUrl', url.href);
 };
 const handlePreferencesChanged = () => {
   state$c.pending = state$c.pending.catch(() => {}).then(() => startRecording$1(state$c.authState));
@@ -12455,7 +12544,8 @@ const handlePreferencesChanged = () => {
 const initialize$1 = async authState => {
   state$c.authState = authState;
   addListener$2('preferences.changed', handlePreferencesChanged);
-  await handlePreferencesChanged();
+  state$c.pending = startRecording$1(authState, true);
+  await state$c.pending;
 };
 
 const shouldInitializeAuth = (hasAuthCallback, isPromptMode) => {
@@ -12652,7 +12742,7 @@ const refresh$1 = async () => {
   if (deleted.length > 0) {
     changes.deleted = deleted;
   }
-  await Promise.allSettled([execute$6('Layout.handleWorkspaceRefresh', changes), execute$6('Layout.refreshSourceControlBadgeCount')]);
+  await Promise.allSettled([execute$7('Layout.handleWorkspaceRefresh', changes), execute$7('Layout.refreshSourceControlBadgeCount')]);
 };
 const scheduleRefresh = event => {
   if (isDeleteEvent(event.eventName)) {
@@ -12692,7 +12782,7 @@ const watchWorkspace = async workspaceUri => {
 };
 const handleWorkspaceChange$1 = async () => {
   await watchWorkspace(getWorkspaceUri());
-  await execute$6('Layout.refreshSourceControlBadgeCount');
+  await execute$7('Layout.refreshSourceControlBadgeCount');
 };
 const hydrate$1 = async () => {
   if (get$l('files.workspaceWatcher.enabled') !== true) {
@@ -12704,31 +12794,31 @@ const hydrate$1 = async () => {
 
 const actions$1 = [async () => {
   mark(WillLoadMain);
-  await execute$6('Layout.loadMainIfVisible');
+  await execute$7('Layout.loadMainIfVisible');
   mark(DidLoadMain);
 }, async () => {
   mark$1(Six);
   mark$1(Seven);
   mark(WillLoadSideBar);
-  await Promise.all([execute$6('Layout.loadSideBarIfVisible'), execute$6('Layout.loadSecondarySideBarIfVisible')]);
+  await Promise.all([execute$7('Layout.loadSideBarIfVisible'), execute$7('Layout.loadSecondarySideBarIfVisible')]);
   mark(DidLoadSideBar);
 }, async () => {
   mark$1(Eight);
   mark(WillLoadPanel);
-  await execute$6('Layout.loadPanelIfVisible');
+  await execute$7('Layout.loadPanelIfVisible');
   mark(DidLoadPanel);
 }, async () => {
   mark$1(Nine);
   mark(WillLoadActivityBar);
-  await execute$6('Layout.loadActivityBarIfVisible');
+  await execute$7('Layout.loadActivityBarIfVisible');
   mark(DidLoadActivityBar);
 }, async () => {
   mark$1(Ten);
   mark(WillLoadStatusBar);
-  await execute$6('Layout.loadStatusBarIfVisible');
+  await execute$7('Layout.loadStatusBarIfVisible');
   mark(DidLoadStatusBar);
 }, async () => {
-  await Promise.all([execute$6('Layout.loadPreviewIfVisible'), execute$6('Layout.loadSecondaryPreviewIfVisible')]);
+  await Promise.all([execute$7('Layout.loadPreviewIfVisible'), execute$7('Layout.loadSecondaryPreviewIfVisible')]);
 }, async (platform, assetDir) => {
   mark$1(Eleven);
   mark(WillLoadIconTheme);
@@ -12740,7 +12830,7 @@ const actions$1 = [async () => {
   mark$1(Thirteen);
   mark$1(Fourteen);
   mark(WillLoadTitleBar);
-  await execute$6('Layout.loadTitleBarIfVisible');
+  await execute$7('Layout.loadTitleBarIfVisible');
   mark(DidLoadTitleBar);
 }];
 
@@ -12794,7 +12884,7 @@ const startup = async (platform, assetDir) => {
   mark(DidOpenWorkspace);
   if (promptOptions !== undefined) {
     await initialize$2(initData);
-    await execute$6('Layout.setAuthState', authState);
+    await execute$7('Layout.setAuthState', authState);
     await run(promptOptions, authState);
     return;
   }
@@ -12840,7 +12930,7 @@ const startup = async (platform, assetDir) => {
   commands.push(['Viewlet.appendToBody', layout.uid]);
   await invoke$I('Viewlet.executeCommands', commands);
   if (authState) {
-    await execute$6('Layout.setAuthState', authState);
+    await execute$7('Layout.setAuthState', authState);
   }
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
@@ -12885,7 +12975,7 @@ const startup = async (platform, assetDir) => {
   const supportsAutoUpdate = platform === Electron$1; // TODO also check if auto update is supported on this platform, e.g. windows
   if (autoUpdate && autoUpdate !== 'none' && supportsAutoUpdate) {
     try {
-      await execute$6('AutoUpdater.checkForUpdates', autoUpdate);
+      await execute$7('AutoUpdater.checkForUpdates', autoUpdate);
     } catch {
       // ignore
     }
@@ -12895,7 +12985,7 @@ const startup = async (platform, assetDir) => {
 
 const lazy = key => async (...args) => {
   await loadCommand(key);
-  return execute$6(key, ...args);
+  return execute$7(key, ...args);
 };
 const commandMap = {
   'PortProvider.getPorts': async workspaceUri => (await Promise.resolve().then(function () { return PortProvider; })).getPorts(workspaceUri),
@@ -13999,6 +14089,403 @@ const IpcParentWithNodeAlternate = {
   wrap
 };
 
+// Compare the JSON representation exposed by live state files, ignoring schema metadata.
+const serializeComponentState = state => {
+  const {
+    $schema,
+    ...componentState
+  } = state;
+  return JSON.stringify(Array.isArray(state) ? state : componentState, (_key, value) => {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      return Object.fromEntries(Object.keys(value).sort().map(key => [key, value[key]]));
+    }
+    return value;
+  });
+};
+
+const liveComponentStatePattern = /^live-component-state:\/\/\/(?:dom\/)?(\d+(?:\.\d+)?)\.json$/;
+const virtualDomTypes = new Set(Object.values(VirtualDomElements));
+const domEditorUids = new Set();
+const editorUidsByComponentUid = new Map();
+const componentUidByEditorUid = new Map();
+const mainEditorUidsAwaitingInitialRefresh = new Set();
+const refreshes = new Map();
+const getUid = instance => instance.state?.uid ?? instance.renderedState?.uid;
+const getLiveComponentUid = instance => {
+  const uri = instance.state?.uri;
+  if (typeof uri !== 'string') {
+    return undefined;
+  }
+  const match = liveComponentStatePattern.exec(uri);
+  return match ? Number(match[1]) : undefined;
+};
+const subscribe$1 = instance => {
+  const componentUid = getLiveComponentUid(instance);
+  const editorUid = getUid(instance);
+  if (componentUid === undefined || typeof editorUid !== 'number') {
+    return;
+  }
+  editorUidsByComponentUid.set(componentUid, editorUidsByComponentUid.get(componentUid)?.add(editorUid) || new Set([editorUid]));
+  componentUidByEditorUid.set(editorUid, componentUid);
+  if (instance.state.uri.startsWith('live-component-state:///dom/')) {
+    domEditorUids.add(editorUid);
+  }
+  if (getByUid(componentUid)?.moduleId === 'Main') {
+    mainEditorUidsAwaitingInitialRefresh.add(editorUid);
+  }
+};
+const unsubscribeEditor = editorUid => {
+  const componentUid = componentUidByEditorUid.get(editorUid);
+  if (componentUid === undefined) {
+    return;
+  }
+  componentUidByEditorUid.delete(editorUid);
+  mainEditorUidsAwaitingInitialRefresh.delete(editorUid);
+  domEditorUids.delete(editorUid);
+  const editorUids = editorUidsByComponentUid.get(componentUid);
+  editorUids?.delete(editorUid);
+  if (editorUids?.size === 0) {
+    editorUidsByComponentUid.delete(componentUid);
+  }
+};
+const unsubscribeComponent = componentUid => {
+  const editorUids = editorUidsByComponentUid.get(componentUid);
+  if (!editorUids) {
+    return;
+  }
+  editorUidsByComponentUid.delete(componentUid);
+  for (const editorUid of editorUids) {
+    componentUidByEditorUid.delete(editorUid);
+    domEditorUids.delete(editorUid);
+    mainEditorUidsAwaitingInitialRefresh.delete(editorUid);
+  }
+};
+const getEditorTabStates = async componentUid => {
+  const mainInstance = getInstance$1('Main', getOwner(componentUid));
+  if (!mainInstance || typeof mainInstance.factory.getComponentState !== 'function') {
+    return new Map();
+  }
+  const mainState = await mainInstance.factory.getComponentState(mainInstance.state);
+  const groups = mainState?.layout?.groups;
+  if (!Array.isArray(groups)) {
+    return new Map();
+  }
+  const editorTabStates = new Map();
+  for (const group of groups) {
+    for (const tab of group.tabs || []) {
+      if (typeof tab.editorUid === 'number') {
+        editorTabStates.set(tab.editorUid, {
+          active: Boolean(group.focused && group.activeTabId === tab.id),
+          dirty: Boolean(tab.isDirty)
+        });
+      }
+    }
+  }
+  return editorTabStates;
+};
+const refreshEditorIfContentChanged = async (editorUid, content) => {
+  try {
+    const currentContent = await actualInvoke('Editor.getText', editorUid);
+    if (serializeComponentState(JSON.parse(currentContent)) === content) {
+      return;
+    }
+  } catch {
+    // Refresh in place when the current editor content cannot be read.
+  }
+  await executeViewletCommand(editorUid, 'loadContent', undefined, {
+    preserveFocus: true
+  });
+};
+const runRefreshes = async (componentUid, refresh) => {
+  try {
+    while (refresh.pending) {
+      refresh.pending = false;
+      const editorUids = [...(editorUidsByComponentUid.get(componentUid) || [])];
+      const editorTabStates = await getEditorTabStates(componentUid);
+      const isMainComponent = getByUid(componentUid)?.moduleId === 'Main';
+      const editorUidsToRefresh = editorUids.filter(editorUid => {
+        if (mainEditorUidsAwaitingInitialRefresh.has(editorUid)) {
+          return true;
+        }
+        const tabState = editorTabStates.get(editorUid);
+        return !tabState?.dirty && !(isMainComponent && tabState?.active);
+      });
+      if (editorUidsToRefresh.length === 0) {
+        continue;
+      }
+      const contents = new Map();
+      const getContent = isDom => {
+        if (!contents.has(isDom)) {
+          const read = isDom ? getDom$2 : getState;
+          contents.set(isDom, read(componentUid).then(serializeComponentState).catch(() => undefined));
+        }
+        return contents.get(isDom);
+      };
+      await Promise.allSettled(editorUidsToRefresh.map(async editorUid => {
+        const content = await getContent(domEditorUids.has(editorUid));
+        if (content === undefined) {
+          await executeViewletCommand(editorUid, 'loadContent', undefined, {
+            preserveFocus: true
+          });
+        } else {
+          await refreshEditorIfContentChanged(editorUid, content);
+        }
+      }));
+      for (const editorUid of editorUidsToRefresh) {
+        mainEditorUidsAwaitingInitialRefresh.delete(editorUid);
+      }
+    }
+  } finally {
+    refreshes.delete(componentUid);
+  }
+};
+const refreshOpenEditors = componentUid => {
+  const existingRefresh = refreshes.get(componentUid);
+  if (existingRefresh) {
+    existingRefresh.pending = true;
+    return existingRefresh.promise;
+  }
+  const refresh = {
+    pending: true,
+    promise: Promise.resolve()
+  };
+  refreshes.set(componentUid, refresh);
+  refresh.promise = runRefreshes(componentUid, refresh);
+  return refresh.promise;
+};
+const handleViewletStateChange = (type, instance) => {
+  const uid = getUid(instance);
+  if (typeof uid !== 'number') {
+    return;
+  }
+  if (type === 'add') {
+    subscribe$1(instance);
+    return;
+  }
+  if (type === 'remove') {
+    unsubscribeEditor(uid);
+    unsubscribeComponent(uid);
+    return;
+  }
+  if (type === 'render' && editorUidsByComponentUid.has(uid)) {
+    void refreshOpenEditors(uid);
+  }
+};
+addListener(handleViewletStateChange);
+for (const instance of getValues()) {
+  subscribe$1(instance);
+}
+const isWorkerBacked = instance => Boolean(instance.factory?.hasFunctionalRender);
+const isEditable = instance => {
+  if (!isWorkerBacked(instance)) {
+    return true;
+  }
+  if (typeof instance.factory.isComponentStateAvailable === 'function') {
+    return instance.factory.isComponentStateAvailable(instance.state);
+  }
+  return typeof instance.factory.getComponentState === 'function' && typeof instance.factory.setComponentState === 'function';
+};
+const getInstance = uid => {
+  const instance = getByUid(uid);
+  if (!instance) {
+    throw new Error(`Component not found: ${uid}`);
+  }
+  return instance;
+};
+
+/**
+ * @param {number=} viewUid
+ */
+const getComponents = (viewUid = undefined) => {
+  const applicationId = viewUid === undefined ? undefined : getOwner(viewUid);
+  const seen = new Set();
+  const components = [];
+  for (const instance of getValues()) {
+    const uid = getUid(instance);
+    if (typeof uid !== 'number' || seen.has(uid) || viewUid !== undefined && getOwner(uid) !== applicationId) {
+      continue;
+    }
+    seen.add(uid);
+    const moduleId = instance.moduleId || instance.factory?.name || 'Unknown';
+    const displayName = moduleId === 'ExtensionView' ? `${instance.state?.title || instance.state?.viewId || moduleId} (extension)` : moduleId;
+    components.push({
+      displayName,
+      domAvailable: typeof instance.factory.getComponentDom === 'function',
+      editable: isEditable(instance),
+      moduleId,
+      uid
+    });
+  }
+  return components.sort((a, b) => a.displayName.localeCompare(b.displayName) || a.uid - b.uid);
+};
+const getState = async uid => {
+  const instance = getInstance(uid);
+  if (isWorkerBacked(instance)) {
+    if (typeof instance.factory.getComponentState !== 'function') {
+      throw new Error(`Component state API not available: ${instance.moduleId}`);
+    }
+    return instance.factory.getComponentState(instance.state);
+  }
+  return instance.state;
+};
+const getDom$2 = async uid => {
+  const instance = getInstance(uid);
+  if (typeof instance.factory.getComponentDom !== 'function') {
+    throw new Error(`Component DOM API not available: ${instance.moduleId}`);
+  }
+  const preview = await invoke$I('Viewlet.getComponentDom', uid);
+  return preview ?? instance.factory.getComponentDom(instance.state);
+};
+const validateState = (uid, oldState, newState) => {
+  if (!newState || typeof newState !== 'object' || Array.isArray(newState)) {
+    throw new TypeError('Component state must be an object');
+  }
+  if (typeof oldState.uid === 'number' && newState.uid !== oldState.uid) {
+    throw new Error(`Component state uid must remain ${uid}`);
+  }
+};
+const renderState = async (instance, uid, newState) => {
+  const commands = filterFocusCommands(render$V(instance.factory, instance.renderedState, newState, uid, newState.parentUid));
+  setRenderedState(uid, newState);
+  if (commands.length > 0) {
+    await invoke$I('Viewlet.sendMultiple', commands);
+  }
+};
+const setState = async (uid, newComponentState) => {
+  const instance = getInstance(uid);
+  const oldComponentState = await getState(uid);
+  validateState(uid, oldComponentState, newComponentState);
+  if (serializeComponentState(oldComponentState) === serializeComponentState(newComponentState)) {
+    return;
+  }
+  if (isWorkerBacked(instance)) {
+    if (typeof instance.factory.setComponentState !== 'function') {
+      throw new Error(`Component state API not available: ${instance.moduleId}`);
+    }
+    const newRendererState = await instance.factory.setComponentState(instance.state, newComponentState);
+    await renderState(instance, uid, newRendererState);
+    return;
+  }
+  await renderState(instance, uid, newComponentState);
+};
+const setDom = async (uid, dom) => {
+  const instance = getInstance(uid);
+  if (typeof instance.factory.getComponentDom !== 'function') {
+    throw new Error(`Component DOM API not available: ${instance.moduleId}`);
+  }
+  if (!Array.isArray(dom) || dom.length === 0) {
+    throw new TypeError('Component DOM must be a non-empty array');
+  }
+  if (dom[0]?.type === Text$1 || dom[0]?.type === Reference$1) {
+    throw new TypeError('Component DOM must have an element root');
+  }
+  let remaining = 1;
+  for (const node of dom) {
+    if (!node || typeof node !== 'object' || !virtualDomTypes.has(node.type) || (node.type === Text$1 || node.type === Reference$1) && node.childCount !== 0 || !Number.isInteger(node.childCount) || node.childCount < 0 || remaining === 0) {
+      throw new TypeError('Component DOM must contain one complete tree');
+    }
+    remaining += node.childCount - 1;
+  }
+  if (remaining !== 0) {
+    throw new TypeError('Component DOM must contain one complete tree');
+  }
+  const currentDom = await getDom$2(uid);
+  if (serializeComponentState(currentDom) === serializeComponentState(dom)) {
+    return;
+  }
+  await invoke$I('Viewlet.setComponentDom', uid, dom);
+  await refreshOpenEditors(uid);
+};
+
+const componentStateWorkerUrl = `${assetDir}/packages/component-state-worker/dist/componentStateWorkerMain.js`;
+
+const launchComponentStateWorker = async () => {
+  const ipc = await create$1n({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name: 'Component State Worker',
+    url: getConfiguredWorkerUrl$1('develop.componentStateWorkerPath', componentStateWorkerUrl)
+  });
+  handleIpc$1(ipc);
+  return ipc;
+};
+
+const {
+  invoke: invoke$y,
+  invokeAndTransfer: invokeAndTransfer$D,
+  restart: restart$m
+} = getOrCreateWorker(launchComponentStateWorker);
+
+const ComponentStateWorker = {
+  __proto__: null,
+  invoke: invoke$y,
+  invokeAndTransfer: invokeAndTransfer$D,
+  restart: restart$m
+};
+
+const name$2H = 'ComponentState';
+const readFile$c = uri => invoke$y('ComponentState.readFile', uri);
+const writeFile$c = (uri, content) => invoke$y('ComponentState.writeFile', uri, content);
+const readDirWithFileTypes$6 = uri => invoke$y('ComponentState.readDirWithFileTypes', uri);
+const exists$1 = uri => invoke$y('ComponentState.exists', uri);
+const stat = async uri => ({
+  exists: await exists$1(uri),
+  type: File$1
+});
+const isReadonly$6 = uri => invoke$y('ComponentState.isReadonly', uri);
+const canBeRestored$3 = true;
+const rename$5 = async () => {
+  throw new Error('Renaming component state is not allowed');
+};
+const remove$7 = async () => {
+  throw new Error('Removing component state is not allowed');
+};
+const mkdir$6 = async () => {
+  throw new Error('Creating component state directories is not allowed');
+};
+
+const FileSystemComponentState = {
+  __proto__: null,
+  canBeRestored: canBeRestored$3,
+  exists: exists$1,
+  isReadonly: isReadonly$6,
+  mkdir: mkdir$6,
+  name: name$2H,
+  readDirWithFileTypes: readDirWithFileTypes$6,
+  readFile: readFile$c,
+  remove: remove$7,
+  rename: rename$5,
+  stat,
+  writeFile: writeFile$c
+};
+
+const pattern = /^live-component-state:\/\/\/(?:dom\/|schemas\/)?(\d+(?:\.\d+)?)\.json$/;
+const execute$2 = async (applicationId, method, uri, ...args) => {
+  const application = assertOpen(applicationId);
+  if (method === 'readDirWithFileTypes' && uri === 'live-component-state:///') {
+    return getComponents(application.layoutUid).filter(component => component.editable).map(component => ({
+      name: `${component.uid}.json`,
+      type: File$1
+    }));
+  }
+  const match = pattern.exec(uri);
+  if (!match || getOwner(Number(match[1])) !== applicationId) {
+    if (method === 'exists') {
+      return false;
+    }
+    throw new Error(`Component state does not belong to application ${applicationId}: ${uri}`);
+  }
+  const fn = FileSystemComponentState[method];
+  if (typeof fn !== 'function') {
+    throw new Error(`Unsupported component state filesystem operation: ${method}`);
+  }
+  return fn(uri, ...args);
+};
+
+const ApplicationComponentStateFileSystem = {
+  __proto__: null,
+  execute: execute$2
+};
+
 const isImportErrorChrome = error => {
   return error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module');
 };
@@ -14181,7 +14668,7 @@ const executeProvider$2 = async options => {
 // Refresh can call back into the editor or Explorer that is awaiting this mutation.
 // Do not make the completed filesystem operation wait for that refresh.
 const notifyWorkspaceChanged = async changes => {
-  await Promise.allSettled([execute$6('Layout.handleWorkspaceRefresh', changes), execute$6('Layout.refreshSourceControlBadgeCount')]);
+  await Promise.allSettled([execute$7('Layout.handleWorkspaceRefresh', changes), execute$7('Layout.refreshSourceControlBadgeCount')]);
 };
 const getProviderProtocolPathAndUri = uri => {
   const protocol = getProtocol(uri);
@@ -14235,7 +14722,7 @@ const readProviderFile = uri => {
     protocol
   });
 };
-const readFile$c = async uri => {
+const readFile$b = async uri => {
   const content = await readProviderFile(uri);
   return content instanceof Blob ? content.text() : content;
 };
@@ -14252,7 +14739,7 @@ const getBlobUrl$2 = async (uri, type = '') => {
   const blob = await getBlob$2(uri, type);
   return invoke$I('ObjectUrl.create', blob);
 };
-const remove$7 = async uri => {
+const remove$6 = async uri => {
   const {
     protocol,
     path,
@@ -14276,7 +14763,7 @@ const remove$7 = async uri => {
  * @param {string} oldUri
  * @param {string} newUri
  */
-const rename$5 = async (oldUri, newUri) => {
+const rename$4 = async (oldUri, newUri) => {
   const {
     protocol,
     path: oldPath,
@@ -14298,7 +14785,7 @@ const rename$5 = async (oldUri, newUri) => {
   });
   return result;
 };
-const mkdir$6 = uri => {
+const mkdir$5 = uri => {
   const {
     protocol,
     path,
@@ -14344,7 +14831,7 @@ const createFolder$1 = uri => {
     protocol
   });
 };
-const writeFile$c = async (uri, content) => {
+const writeFile$b = async (uri, content) => {
   const {
     protocol,
     path,
@@ -14362,7 +14849,7 @@ const writeFile$c = async (uri, content) => {
   });
   return result;
 };
-const readDirWithFileTypes$6 = uri => {
+const readDirWithFileTypes$5 = uri => {
   const {
     protocol,
     path,
@@ -14376,7 +14863,7 @@ const readDirWithFileTypes$6 = uri => {
     protocol
   });
 };
-const isReadonly$6 = async uri => {
+const isReadonly$5 = async uri => {
   const {
     protocol
   } = getProviderProtocolPathAndUri(uri);
@@ -14395,16 +14882,16 @@ const ExtensionHostFileSystem = {
   createFolder: createFolder$1,
   getBlob: getBlob$2,
   getBlobUrl: getBlobUrl$2,
-  isReadonly: isReadonly$6,
-  mkdir: mkdir$6,
-  readDirWithFileTypes: readDirWithFileTypes$6,
-  readFile: readFile$c,
-  remove: remove$7,
-  rename: rename$5,
-  writeFile: writeFile$c
+  isReadonly: isReadonly$5,
+  mkdir: mkdir$5,
+  readDirWithFileTypes: readDirWithFileTypes$5,
+  readFile: readFile$b,
+  remove: remove$6,
+  rename: rename$4,
+  writeFile: writeFile$b
 };
 
-const name$2H = 'App';
+const name$2G = 'App';
 const appPrefix = 'app://';
 const readonlyPaths = new Set(['memory-usage', 'session.json', 'startup-performance']);
 const getPath$2 = uri => {
@@ -14431,7 +14918,7 @@ const getModule$2 = uri => {
       throw new Error(`unsupported file: ${uri}`);
   }
 };
-const readFile$b = async uri => {
+const readFile$a = async uri => {
   const module = await getModule$2(getPath$2(uri));
   return module.readFile();
 };
@@ -14440,42 +14927,42 @@ const readJson$4 = async uri => {
   // @ts-ignore
   return module.readJson();
 };
-const writeFile$b = async (uri, content) => {
+const writeFile$a = async (uri, content) => {
   const module = await getModule$2(getPath$2(uri));
   return module.writeFile(content);
 };
-const readDirWithFileTypes$5 = () => {
+const readDirWithFileTypes$4 = () => {
   return [];
 };
-const rename$4 = async (oldUri, newUri) => {
+const rename$3 = async (oldUri, newUri) => {
   throw new Error('not allowed');
 };
-const remove$6 = async path => {
+const remove$5 = async path => {
   throw new Error('not allowed');
 };
-const mkdir$5 = async path => {
+const mkdir$4 = async path => {
   throw new Error('not allowed');
 };
-const isReadonly$5 = uri => {
+const isReadonly$4 = uri => {
   return readonlyPaths.has(getPath$2(uri));
 };
-const canBeRestored$3 = true;
+const canBeRestored$2 = true;
 
 const FileSystemApp = {
   __proto__: null,
-  canBeRestored: canBeRestored$3,
-  isReadonly: isReadonly$5,
-  mkdir: mkdir$5,
-  name: name$2H,
-  readDirWithFileTypes: readDirWithFileTypes$5,
-  readFile: readFile$b,
+  canBeRestored: canBeRestored$2,
+  isReadonly: isReadonly$4,
+  mkdir: mkdir$4,
+  name: name$2G,
+  readDirWithFileTypes: readDirWithFileTypes$4,
+  readFile: readFile$a,
   readJson: readJson$4,
-  remove: remove$6,
-  rename: rename$4,
-  writeFile: writeFile$b
+  remove: remove$5,
+  rename: rename$3,
+  writeFile: writeFile$a
 };
 
-const name$2G = 'Data';
+const name$2F = 'Data';
 const dataPrefix = 'data://';
 const getPath$1 = uri => {
   if (uri.startsWith(dataPrefix)) {
@@ -14486,29 +14973,29 @@ const getPath$1 = uri => {
 const copy$1 = (source, target) => {
   throw new Error('not implemented');
 };
-const readFile$a = path => {
+const readFile$9 = path => {
   return getPath$1(path);
 };
-const remove$5 = path => {
+const remove$4 = path => {
   throw new Error('not implemented');
 };
-const rename$3 = (oldUri, newUri) => {
+const rename$2 = (oldUri, newUri) => {
   throw new Error('not implemented');
 };
-const mkdir$4 = path => {
+const mkdir$3 = path => {
   throw new Error('not implemented');
 };
-const writeFile$a = async (path, content) => {
+const writeFile$9 = async (path, content) => {
   throw new Error('not implemented');
 };
 const ensureFile = async () => {};
-const readDirWithFileTypes$4 = path => {
+const readDirWithFileTypes$3 = path => {
   throw new Error('not implemented');
 };
 const getBlobUrl$1 = path => {
   throw new Error('not implemented');
 };
-const isReadonly$4 = () => {
+const isReadonly$3 = () => {
   return true;
 };
 
@@ -14517,20 +15004,20 @@ const FileSystemData = {
   copy: copy$1,
   ensureFile,
   getBlobUrl: getBlobUrl$1,
-  isReadonly: isReadonly$4,
-  mkdir: mkdir$4,
-  name: name$2G,
-  readDirWithFileTypes: readDirWithFileTypes$4,
-  readFile: readFile$a,
-  remove: remove$5,
-  rename: rename$3,
-  writeFile: writeFile$a
+  isReadonly: isReadonly$3,
+  mkdir: mkdir$3,
+  name: name$2F,
+  readDirWithFileTypes: readDirWithFileTypes$3,
+  readFile: readFile$9,
+  remove: remove$4,
+  rename: rename$2,
+  writeFile: writeFile$9
 };
 
 // TODO when it rejects, it should throw a custom error,
 // FileSystemError
 
-const name$2F = 'Web';
+const name$2E = 'Web';
 const state$b = {
   watchers: Object.create(null),
   saveListeners: [],
@@ -14739,7 +15226,7 @@ state$b.files['/sample-folder/c.txt'] = '';
 //   return path.slice('/workspace'.length)
 // }
 
-const readFile$9 = async path => {
+const readFile$8 = async path => {
   path = getPath(path);
   const file = state$b.files[path];
   if (file === undefined) {
@@ -14747,13 +15234,13 @@ const readFile$9 = async path => {
   }
   return file;
 };
-const remove$4 = async path => {
+const remove$3 = async path => {
   throw new Error('not implemented');
 };
-const rename$2 = async (oldPath, newPath) => {
+const rename$1 = async (oldPath, newPath) => {
   throw new Error('not implemented');
 };
-const mkdir$3 = async path => {
+const mkdir$2 = async path => {
   throw new Error('not implemented');
 };
 const createFile = async path => {
@@ -14762,7 +15249,7 @@ const createFile = async path => {
 const createFolder = async path => {
   throw new Error('not implemented');
 };
-const writeFile$9 = async (path, content) => {
+const writeFile$8 = async (path, content) => {
   path = getPath(path);
   state$b.files[path] = content;
 };
@@ -14779,7 +15266,7 @@ const getDirent = (path, relativePath) => {
     name: rest
   };
 };
-const readDirWithFileTypes$3 = path => {
+const readDirWithFileTypes$2 = path => {
   path = getPath(path);
   const dirents = [];
   for (const key in state$b.files) {
@@ -14806,35 +15293,35 @@ const unwatchAll = () => {
 const onDidSave = listener => {
   throw new Error('not implemented');
 };
-const isReadonly$3 = () => {
+const isReadonly$2 = () => {
   return false;
 };
-const canBeRestored$2 = true;
+const canBeRestored$1 = true;
 
 const FileSystemWeb = {
   __proto__: null,
-  canBeRestored: canBeRestored$2,
+  canBeRestored: canBeRestored$1,
   createFile,
   createFolder,
-  isReadonly: isReadonly$3,
-  mkdir: mkdir$3,
-  name: name$2F,
+  isReadonly: isReadonly$2,
+  mkdir: mkdir$2,
+  name: name$2E,
   onDidSave,
-  readDirWithFileTypes: readDirWithFileTypes$3,
-  readFile: readFile$9,
-  remove: remove$4,
-  rename: rename$2,
+  readDirWithFileTypes: readDirWithFileTypes$2,
+  readFile: readFile$8,
+  remove: remove$3,
+  rename: rename$1,
   state: state$b,
   unwatch,
   unwatchAll,
   watch: watch$1,
-  writeFile: writeFile$9
+  writeFile: writeFile$8
 };
 
 // TODO move all of this to an extension
 
-const canBeRestored$1 = true;
-const name$2E = 'Fetch';
+const canBeRestored = true;
+const name$2D = 'Fetch';
 const state$a = {
   files: Object.create(null)
 };
@@ -14852,7 +15339,7 @@ const fetchAsset = async uri => {
   }
   return response;
 };
-const readFile$8 = async uri => {
+const readFile$7 = async uri => {
   uri = normalizeUri(uri);
   if (uri.startsWith('localhost:') || uri.startsWith(location.host)) {
     return invoke$E('FileSystem.readFile', `${location.protocol}//${uri}`);
@@ -14863,9 +15350,9 @@ const readFile$8 = async uri => {
   const response = await fetchAsset(uri);
   return response.text();
 };
-const exists$1 = async uri => {
+const exists = async uri => {
   try {
-    await readFile$8(uri);
+    await readFile$7(uri);
     return true;
   } catch {
     return false;
@@ -14882,22 +15369,22 @@ const readJson$3 = async uri => {
   const response = await fetchAsset(uri);
   return response.json();
 };
-const writeFile$8 = (uri, content) => {
+const writeFile$7 = (uri, content) => {
   uri = normalizeUri(uri);
   throw new Error('Fetch file systems are readonly');
 };
-const mkdir$2 = uri => {
+const mkdir$1 = uri => {
   uri = normalizeUri(uri);
   throw new Error('Fetch file systems are readonly');
 };
-const isReadonly$2 = () => {
+const isReadonly$1 = () => {
   return true;
 };
-const remove$3 = uri => {
+const remove$2 = uri => {
   uri = normalizeUri(uri);
   throw new Error('Fetch file systems are readonly');
 };
-const readDirWithFileTypes$2 = async uri => {
+const readDirWithFileTypes$1 = async uri => {
   uri = normalizeUri(uri);
   const directoryPrefix = uri.endsWith(Slash$1) ? uri : `${uri}${Slash$1}`;
   const response = await fetchAsset('/config/fileMap.json');
@@ -14944,19 +15431,19 @@ const getBlob$1 = async (uri, type) => {
 
 const FileSystemFetch = {
   __proto__: null,
-  canBeRestored: canBeRestored$1,
+  canBeRestored,
   chmod: chmod$1,
-  exists: exists$1,
+  exists,
   getBlob: getBlob$1,
-  isReadonly: isReadonly$2,
-  mkdir: mkdir$2,
-  name: name$2E,
-  readDirWithFileTypes: readDirWithFileTypes$2,
-  readFile: readFile$8,
+  isReadonly: isReadonly$1,
+  mkdir: mkdir$1,
+  name: name$2D,
+  readDirWithFileTypes: readDirWithFileTypes$1,
+  readFile: readFile$7,
   readJson: readJson$3,
-  remove: remove$3,
+  remove: remove$2,
   state: state$a,
-  writeFile: writeFile$8
+  writeFile: writeFile$7
 };
 
 const debugWorkerUrl = `${assetDir}/packages/debug-worker/dist/debugWorkerMain.js`;
@@ -14974,27 +15461,27 @@ const launchDebugWorker = async () => {
 };
 
 const {
-  invoke: invoke$y,
-  restart: restart$m
+  invoke: invoke$x,
+  restart: restart$l
 } = getOrCreateWorker(launchDebugWorker);
 
-const name$2D = 'Debug';
-const readFile$7 = uri => {
-  return invoke$y('RunAndDebug.readFile', uri);
+const name$2C = 'Debug';
+const readFile$6 = uri => {
+  return invoke$x('RunAndDebug.readFile', uri);
 };
-const writeFile$7 = (uri, content) => {
+const writeFile$6 = (uri, content) => {
   throw new Error('not implemented');
 };
-const mkdir$1 = uri => {
+const mkdir = uri => {
   throw new Error('not implemented');
 };
-const isReadonly$1 = () => {
+const isReadonly = () => {
   return true;
 };
-const remove$2 = uri => {
+const remove$1 = uri => {
   throw new Error('not implemented');
 };
-const readDirWithFileTypes$1 = uri => {
+const readDirWithFileTypes = uri => {
   throw new Error('not implemented');
 };
 const getBlobUrl = uri => {
@@ -15006,7 +15493,7 @@ const getBlob = async uri => {
 const chmod = (path, permissions) => {
   throw new Error('not implemented');
 };
-const rename$1 = (oldPath, newPath) => {
+const rename = (oldPath, newPath) => {
   throw new Error('not implemented');
 };
 const getFiles = () => {
@@ -15019,66 +15506,6 @@ const FileSystemDebug = {
   getBlob,
   getBlobUrl,
   getFiles,
-  isReadonly: isReadonly$1,
-  mkdir: mkdir$1,
-  name: name$2D,
-  readDirWithFileTypes: readDirWithFileTypes$1,
-  readFile: readFile$7,
-  remove: remove$2,
-  rename: rename$1,
-  writeFile: writeFile$7
-};
-
-const componentStateWorkerUrl = `${assetDir}/packages/component-state-worker/dist/componentStateWorkerMain.js`;
-
-const launchComponentStateWorker = async () => {
-  const ipc = await create$1n({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name: 'Component State Worker',
-    url: getConfiguredWorkerUrl$1('develop.componentStateWorkerPath', componentStateWorkerUrl)
-  });
-  handleIpc$1(ipc);
-  return ipc;
-};
-
-const {
-  invoke: invoke$x,
-  invokeAndTransfer: invokeAndTransfer$D,
-  restart: restart$l
-} = getOrCreateWorker(launchComponentStateWorker);
-
-const ComponentStateWorker = {
-  __proto__: null,
-  invoke: invoke$x,
-  invokeAndTransfer: invokeAndTransfer$D,
-  restart: restart$l
-};
-
-const name$2C = 'ComponentState';
-const readFile$6 = uri => invoke$x('ComponentState.readFile', uri);
-const writeFile$6 = (uri, content) => invoke$x('ComponentState.writeFile', uri, content);
-const readDirWithFileTypes = uri => invoke$x('ComponentState.readDirWithFileTypes', uri);
-const exists = uri => invoke$x('ComponentState.exists', uri);
-const stat = async uri => ({
-  exists: await exists(uri),
-  type: File$1
-});
-const isReadonly = uri => invoke$x('ComponentState.isReadonly', uri);
-const canBeRestored = true;
-const rename = async () => {
-  throw new Error('Renaming component state is not allowed');
-};
-const remove$1 = async () => {
-  throw new Error('Removing component state is not allowed');
-};
-const mkdir = async () => {
-  throw new Error('Creating component state directories is not allowed');
-};
-
-const FileSystemComponentState = {
-  __proto__: null,
-  canBeRestored,
-  exists,
   isReadonly,
   mkdir,
   name: name$2C,
@@ -15086,7 +15513,6 @@ const FileSystemComponentState = {
   readFile: readFile$6,
   remove: remove$1,
   rename,
-  stat,
   writeFile: writeFile$6
 };
 
@@ -15596,7 +16022,7 @@ const Callback_ipc = {
 const minimize = () => {
   switch (getPlatform$4()) {
     case Electron$1:
-      return execute$6('ElectronWindow.minimize');
+      return execute$7('ElectronWindow.minimize');
     default:
       throw new Error('not implemented');
   }
@@ -15604,7 +16030,7 @@ const minimize = () => {
 const maximize = () => {
   switch (getPlatform$4()) {
     case Electron$1:
-      return execute$6('ElectronWindow.maximize');
+      return execute$7('ElectronWindow.maximize');
     default:
       throw new Error('not implemented');
   }
@@ -15612,7 +16038,7 @@ const maximize = () => {
 const unmaximize = () => {
   switch (getPlatform$4()) {
     case Electron$1:
-      return execute$6('ElectronWindow.unmaximize');
+      return execute$7('ElectronWindow.unmaximize');
     default:
       throw new Error('not implemented');
   }
@@ -15620,7 +16046,7 @@ const unmaximize = () => {
 const close$2 = () => {
   switch (getPlatform$4()) {
     case Electron$1:
-      return execute$6('ElectronWindow.close');
+      return execute$7('ElectronWindow.close');
     default:
       throw new Error('not implemented');
   }
@@ -15628,7 +16054,7 @@ const close$2 = () => {
 const exit = () => {
   switch (getPlatform$4()) {
     case Electron$1:
-      return execute$6('Exit.exit');
+      return execute$7('Exit.exit');
     default:
       throw new Error('not implemented');
   }
@@ -15636,7 +16062,7 @@ const exit = () => {
 const openNew = () => {
   switch (getPlatform$4()) {
     case Electron$1:
-      return execute$6('ElectronWindow.openNew');
+      return execute$7('ElectronWindow.openNew');
     default:
       throw new Error('not implemented');
   }
@@ -15644,7 +16070,7 @@ const openNew = () => {
 const zoomIn$1 = () => {
   switch (getPlatform$4()) {
     case Electron$1:
-      return execute$6('ElectronWindow.zoomIn');
+      return execute$7('ElectronWindow.zoomIn');
     default:
       throw new Error('not implemented');
   }
@@ -15652,7 +16078,7 @@ const zoomIn$1 = () => {
 const zoomOut$1 = () => {
   switch (getPlatform$4()) {
     case Electron$1:
-      return execute$6('ElectronWindow.zoomOut');
+      return execute$7('ElectronWindow.zoomOut');
     default:
       throw new Error('not implemented');
   }
@@ -15660,7 +16086,7 @@ const zoomOut$1 = () => {
 const zoomReset = () => {
   switch (getPlatform$4()) {
     case Electron$1:
-      return execute$6('ElectronWindow.zoomReset');
+      return execute$7('ElectronWindow.zoomReset');
     default:
       throw new Error('not implemented');
   }
@@ -16000,309 +16426,6 @@ const ContextMenu_ipc = {
   name: name$2i
 };
 
-// Compare the JSON representation exposed by live state files, ignoring schema metadata.
-const serializeComponentState = state => {
-  const {
-    $schema,
-    ...componentState
-  } = state;
-  return JSON.stringify(Array.isArray(state) ? state : componentState, (_key, value) => {
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-      return Object.fromEntries(Object.keys(value).sort().map(key => [key, value[key]]));
-    }
-    return value;
-  });
-};
-
-const liveComponentStatePattern = /^live-component-state:\/\/\/(?:dom\/)?(\d+(?:\.\d+)?)\.json$/;
-const virtualDomTypes = new Set(Object.values(VirtualDomElements));
-const domEditorUids = new Set();
-const editorUidsByComponentUid = new Map();
-const componentUidByEditorUid = new Map();
-const mainEditorUidsAwaitingInitialRefresh = new Set();
-const refreshes = new Map();
-const getUid = instance => instance.state?.uid ?? instance.renderedState?.uid;
-const getLiveComponentUid = instance => {
-  const uri = instance.state?.uri;
-  if (typeof uri !== 'string') {
-    return undefined;
-  }
-  const match = liveComponentStatePattern.exec(uri);
-  return match ? Number(match[1]) : undefined;
-};
-const subscribe$1 = instance => {
-  const componentUid = getLiveComponentUid(instance);
-  const editorUid = getUid(instance);
-  if (componentUid === undefined || typeof editorUid !== 'number') {
-    return;
-  }
-  editorUidsByComponentUid.set(componentUid, editorUidsByComponentUid.get(componentUid)?.add(editorUid) || new Set([editorUid]));
-  componentUidByEditorUid.set(editorUid, componentUid);
-  if (instance.state.uri.startsWith('live-component-state:///dom/')) {
-    domEditorUids.add(editorUid);
-  }
-  if (getByUid(componentUid)?.moduleId === 'Main') {
-    mainEditorUidsAwaitingInitialRefresh.add(editorUid);
-  }
-};
-const unsubscribeEditor = editorUid => {
-  const componentUid = componentUidByEditorUid.get(editorUid);
-  if (componentUid === undefined) {
-    return;
-  }
-  componentUidByEditorUid.delete(editorUid);
-  mainEditorUidsAwaitingInitialRefresh.delete(editorUid);
-  domEditorUids.delete(editorUid);
-  const editorUids = editorUidsByComponentUid.get(componentUid);
-  editorUids?.delete(editorUid);
-  if (editorUids?.size === 0) {
-    editorUidsByComponentUid.delete(componentUid);
-  }
-};
-const unsubscribeComponent = componentUid => {
-  const editorUids = editorUidsByComponentUid.get(componentUid);
-  if (!editorUids) {
-    return;
-  }
-  editorUidsByComponentUid.delete(componentUid);
-  for (const editorUid of editorUids) {
-    componentUidByEditorUid.delete(editorUid);
-    domEditorUids.delete(editorUid);
-    mainEditorUidsAwaitingInitialRefresh.delete(editorUid);
-  }
-};
-const getEditorTabStates = async () => {
-  const mainInstance = getInstance$1('Main');
-  if (!mainInstance || typeof mainInstance.factory.getComponentState !== 'function') {
-    return new Map();
-  }
-  const mainState = await mainInstance.factory.getComponentState(mainInstance.state);
-  const groups = mainState?.layout?.groups;
-  if (!Array.isArray(groups)) {
-    return new Map();
-  }
-  const editorTabStates = new Map();
-  for (const group of groups) {
-    for (const tab of group.tabs || []) {
-      if (typeof tab.editorUid === 'number') {
-        editorTabStates.set(tab.editorUid, {
-          active: Boolean(group.focused && group.activeTabId === tab.id),
-          dirty: Boolean(tab.isDirty)
-        });
-      }
-    }
-  }
-  return editorTabStates;
-};
-const refreshEditorIfContentChanged = async (editorUid, content) => {
-  try {
-    const currentContent = await actualInvoke('Editor.getText', editorUid);
-    if (serializeComponentState(JSON.parse(currentContent)) === content) {
-      return;
-    }
-  } catch {
-    // Refresh in place when the current editor content cannot be read.
-  }
-  await executeViewletCommand(editorUid, 'loadContent', undefined, {
-    preserveFocus: true
-  });
-};
-const runRefreshes = async (componentUid, refresh) => {
-  try {
-    while (refresh.pending) {
-      refresh.pending = false;
-      const editorUids = [...(editorUidsByComponentUid.get(componentUid) || [])];
-      const editorTabStates = await getEditorTabStates();
-      const isMainComponent = getByUid(componentUid)?.moduleId === 'Main';
-      const editorUidsToRefresh = editorUids.filter(editorUid => {
-        if (mainEditorUidsAwaitingInitialRefresh.has(editorUid)) {
-          return true;
-        }
-        const tabState = editorTabStates.get(editorUid);
-        return !tabState?.dirty && !(isMainComponent && tabState?.active);
-      });
-      if (editorUidsToRefresh.length === 0) {
-        continue;
-      }
-      const contents = new Map();
-      const getContent = isDom => {
-        if (!contents.has(isDom)) {
-          const read = isDom ? getDom$2 : getState;
-          contents.set(isDom, read(componentUid).then(serializeComponentState).catch(() => undefined));
-        }
-        return contents.get(isDom);
-      };
-      await Promise.allSettled(editorUidsToRefresh.map(async editorUid => {
-        const content = await getContent(domEditorUids.has(editorUid));
-        if (content === undefined) {
-          await executeViewletCommand(editorUid, 'loadContent', undefined, {
-            preserveFocus: true
-          });
-        } else {
-          await refreshEditorIfContentChanged(editorUid, content);
-        }
-      }));
-      for (const editorUid of editorUidsToRefresh) {
-        mainEditorUidsAwaitingInitialRefresh.delete(editorUid);
-      }
-    }
-  } finally {
-    refreshes.delete(componentUid);
-  }
-};
-const refreshOpenEditors = componentUid => {
-  const existingRefresh = refreshes.get(componentUid);
-  if (existingRefresh) {
-    existingRefresh.pending = true;
-    return existingRefresh.promise;
-  }
-  const refresh = {
-    pending: true,
-    promise: Promise.resolve()
-  };
-  refreshes.set(componentUid, refresh);
-  refresh.promise = runRefreshes(componentUid, refresh);
-  return refresh.promise;
-};
-const handleViewletStateChange = (type, instance) => {
-  const uid = getUid(instance);
-  if (typeof uid !== 'number') {
-    return;
-  }
-  if (type === 'add') {
-    subscribe$1(instance);
-    return;
-  }
-  if (type === 'remove') {
-    unsubscribeEditor(uid);
-    unsubscribeComponent(uid);
-    return;
-  }
-  if (type === 'render' && editorUidsByComponentUid.has(uid)) {
-    void refreshOpenEditors(uid);
-  }
-};
-addListener(handleViewletStateChange);
-for (const instance of getValues()) {
-  subscribe$1(instance);
-}
-const isWorkerBacked = instance => Boolean(instance.factory?.hasFunctionalRender);
-const isEditable = instance => {
-  if (!isWorkerBacked(instance)) {
-    return true;
-  }
-  if (typeof instance.factory.isComponentStateAvailable === 'function') {
-    return instance.factory.isComponentStateAvailable(instance.state);
-  }
-  return typeof instance.factory.getComponentState === 'function' && typeof instance.factory.setComponentState === 'function';
-};
-const getInstance = uid => {
-  const instance = getByUid(uid);
-  if (!instance) {
-    throw new Error(`Component not found: ${uid}`);
-  }
-  return instance;
-};
-const getComponents = () => {
-  const seen = new Set();
-  const components = [];
-  for (const instance of getValues()) {
-    const uid = getUid(instance);
-    if (typeof uid !== 'number' || seen.has(uid)) {
-      continue;
-    }
-    seen.add(uid);
-    const moduleId = instance.moduleId || instance.factory?.name || 'Unknown';
-    const displayName = moduleId === 'ExtensionView' ? `${instance.state?.title || instance.state?.viewId || moduleId} (extension)` : moduleId;
-    components.push({
-      displayName,
-      domAvailable: typeof instance.factory.getComponentDom === 'function',
-      editable: isEditable(instance),
-      moduleId,
-      uid
-    });
-  }
-  return components.sort((a, b) => a.displayName.localeCompare(b.displayName) || a.uid - b.uid);
-};
-const getState = async uid => {
-  const instance = getInstance(uid);
-  if (isWorkerBacked(instance)) {
-    if (typeof instance.factory.getComponentState !== 'function') {
-      throw new Error(`Component state API not available: ${instance.moduleId}`);
-    }
-    return instance.factory.getComponentState(instance.state);
-  }
-  return instance.state;
-};
-const getDom$2 = async uid => {
-  const instance = getInstance(uid);
-  if (typeof instance.factory.getComponentDom !== 'function') {
-    throw new Error(`Component DOM API not available: ${instance.moduleId}`);
-  }
-  const preview = await invoke$I('Viewlet.getComponentDom', uid);
-  return preview ?? instance.factory.getComponentDom(instance.state);
-};
-const validateState = (uid, oldState, newState) => {
-  if (!newState || typeof newState !== 'object' || Array.isArray(newState)) {
-    throw new TypeError('Component state must be an object');
-  }
-  if (typeof oldState.uid === 'number' && newState.uid !== oldState.uid) {
-    throw new Error(`Component state uid must remain ${uid}`);
-  }
-};
-const renderState = async (instance, uid, newState) => {
-  const commands = filterFocusCommands(render$V(instance.factory, instance.renderedState, newState, uid, newState.parentUid));
-  setRenderedState(uid, newState);
-  if (commands.length > 0) {
-    await invoke$I('Viewlet.sendMultiple', commands);
-  }
-};
-const setState = async (uid, newComponentState) => {
-  const instance = getInstance(uid);
-  const oldComponentState = await getState(uid);
-  validateState(uid, oldComponentState, newComponentState);
-  if (serializeComponentState(oldComponentState) === serializeComponentState(newComponentState)) {
-    return;
-  }
-  if (isWorkerBacked(instance)) {
-    if (typeof instance.factory.setComponentState !== 'function') {
-      throw new Error(`Component state API not available: ${instance.moduleId}`);
-    }
-    const newRendererState = await instance.factory.setComponentState(instance.state, newComponentState);
-    await renderState(instance, uid, newRendererState);
-    return;
-  }
-  await renderState(instance, uid, newComponentState);
-};
-const setDom = async (uid, dom) => {
-  const instance = getInstance(uid);
-  if (typeof instance.factory.getComponentDom !== 'function') {
-    throw new Error(`Component DOM API not available: ${instance.moduleId}`);
-  }
-  if (!Array.isArray(dom) || dom.length === 0) {
-    throw new TypeError('Component DOM must be a non-empty array');
-  }
-  if (dom[0]?.type === Text$1 || dom[0]?.type === Reference$1) {
-    throw new TypeError('Component DOM must have an element root');
-  }
-  let remaining = 1;
-  for (const node of dom) {
-    if (!node || typeof node !== 'object' || !virtualDomTypes.has(node.type) || (node.type === Text$1 || node.type === Reference$1) && node.childCount !== 0 || !Number.isInteger(node.childCount) || node.childCount < 0 || remaining === 0) {
-      throw new TypeError('Component DOM must contain one complete tree');
-    }
-    remaining += node.childCount - 1;
-  }
-  if (remaining !== 0) {
-    throw new TypeError('Component DOM must contain one complete tree');
-  }
-  const currentDom = await getDom$2(uid);
-  if (serializeComponentState(currentDom) === serializeComponentState(dom)) {
-    return;
-  }
-  await invoke$I('Viewlet.setComponentDom', uid, dom);
-  await refreshOpenEditors(uid);
-};
-
 const name$2h = 'ComponentState';
 const Commands$2m = {
   getComponents: getComponents,
@@ -16322,7 +16445,7 @@ const name$2g = 'Application';
 const Commands$2l = {
   create: create$1c,
   dispose: dispose$Y,
-  execute: execute$3,
+  execute: execute$4,
   executeForView: executeForView,
   resize: resize$I,
   waitForHost: waitForHost
@@ -16826,23 +16949,23 @@ const showColorThemeCss = async () => {
   Main.openRawText('css://color-theme.css', colorThemeCss);
 };
 const clearCache = async () => {
-  await execute$6(/* CacheStorage.clearCache */'CacheStorage.clearCache');
-  await execute$6(/* LocalStorage.clear */'LocalStorage.clear');
-  await execute$6(/* SessionStorage.clear */'SessionStorage.clear');
+  await execute$7(/* CacheStorage.clearCache */'CacheStorage.clearCache');
+  await execute$7(/* LocalStorage.clear */'LocalStorage.clear');
+  await execute$7(/* SessionStorage.clear */'SessionStorage.clear');
 };
 const openProcessExplorer = () => {
   return open();
 };
 const openComponentState = async () => {
-  await execute$6('Layout.showSecondarySideBar');
-  await execute$6('Layout.openSecondarySideBarViewlet', ComponentState);
+  await execute$7('Layout.showSecondarySideBar');
+  await execute$7('Layout.openSecondarySideBarViewlet', ComponentState);
 };
 const showGpuInfo = () => {
   return invoke$M('Developer.showGpuInfo');
 };
 const downloadViewletState = async () => {
-  const states = await execute$6('Viewlet.getAllStates');
-  await execute$6('Download.downloadJson', /* json */states, /* fileName */'viewlets.json');
+  const states = await execute$7('Viewlet.getAllStates');
+  await execute$7('Download.downloadJson', /* json */states, /* fileName */'viewlets.json');
 };
 const openStorageOverview = async () => {
   await openUri$1('storage-overview://');
@@ -16955,14 +17078,14 @@ const state$9 = {
 };
 const openFileWeb = async () => {
   try {
-    const [fileHandle] = await execute$6('FilePicker.showFilePicker', {
+    const [fileHandle] = await execute$7('FilePicker.showFilePicker', {
       multiple: false
     });
     if (!fileHandle) {
       return;
     }
     const uri = `html:///${fileHandle.name}`;
-    await execute$6('PersistentFileHandle.addHandle', uri, fileHandle);
+    await execute$7('PersistentFileHandle.addHandle', uri, fileHandle);
     await openUri$1(uri);
   } catch (error) {
     if (isAbortError(error)) {
@@ -17345,7 +17468,11 @@ const create$14 = async type => {
 };
 
 const createConnection = async (extensionId, rpcId) => {
-  const connection = await create$14('extension-node-process');
+  // The SSH transport owns the local tunnel and must remain on the client.
+  const connection = extensionId === 'builtin.remote-ssh' ? {
+    protocols: [],
+    url: getWebSocketUrl$1('extension-node-process', getHost())
+  } : await create$14('extension-node-process');
   const url = new URL(connection.url);
   url.searchParams.set('extensionId', extensionId);
   url.searchParams.set('rpcId', rpcId);
@@ -17356,10 +17483,10 @@ const createConnection = async (extensionId, rpcId) => {
 };
 const supportsDirectConnection = () => true;
 const createMessagePort = async (port, extensionId, rpcId) => {
-  if (await connectMessagePort('extension-node-process', port, {
+  if (extensionId !== 'builtin.remote-ssh' && (await connectMessagePort('extension-node-process', port, {
     extensionId,
     rpcId
-  })) {
+  }))) {
     return;
   }
   await invokeAndTransfer$R('HandleMessagePortForExtensionNodeProcess.handleMessagePortForExtensionNodeProcess', port, extensionId, rpcId);
@@ -18597,7 +18724,7 @@ const SessionStorage_ipc = {
 
 const name$1w = 'Test';
 const Commands$1z = {
-  execute: execute$2,
+  execute: execute$3,
   executeAll: executeAll,
   tryAutoFix: tryAutoFix
 };
@@ -18685,7 +18812,7 @@ const Viewlet_ipc = {
 
 const toggleFullScreen = () => {
   if (getPlatform$4() === Electron$1) {
-    return execute$6('ElectronWindow.toggleFullScreen');
+    return execute$7('ElectronWindow.toggleFullScreen');
   }
   return invoke$I('Window.toggleFullScreen');
 };
@@ -18793,7 +18920,7 @@ const ExtensionHostQuickPick_ipc = {
 
 const showInformationMessage = async message => {
   string(message);
-  const result = await execute$6('ConfirmPrompt.prompt', message);
+  const result = await execute$7('ConfirmPrompt.prompt', message);
   return result;
 };
 
@@ -20395,8 +20522,9 @@ const mergeCss = (views, extensions) => {
     };
   });
 };
-const getExtensionViews = async () => {
-  const [views, extensions] = await Promise.all([invoke$L('Extensions.getViews', assetDir, getPlatform$4()), invoke$L('Extensions.getAllExtensions', assetDir, getPlatform$4())]);
+const getExtensionViews = async applicationId => {
+  const invoke = (command, ...args) => applicationId === undefined ? invoke$L(command, ...args) : invoke$L('Extensions.invokeForApplication', applicationId, command, ...args);
+  const [views, extensions] = await Promise.all([invoke('Extensions.getViews', assetDir, getPlatform$4()), invoke('Extensions.getAllExtensions', assetDir, getPlatform$4())]);
   return mergeCss(views, extensions);
 };
 const findExtensionView = (views, idOrUri) => {
@@ -20407,8 +20535,8 @@ const findExtensionView = (views, idOrUri) => {
   const normalizedUri = idOrUri.toLowerCase();
   return views.find(view => view.type === 'preview' && view.selector?.some(selector => normalizedUri.endsWith(selector.toLowerCase())));
 };
-const getExtensionView = async idOrUri => {
-  const views = await getExtensionViews();
+const getExtensionView = async (idOrUri, applicationId) => {
+  const views = await getExtensionViews(applicationId);
   return findExtensionView(views, idOrUri);
 };
 
@@ -20421,7 +20549,7 @@ const getWebViewsWeb = async () => {
   const url = `${assetDir}/config/webViews.json`;
   // TODO move this to shared-process-web / network-process-web
   // TODO handle error ?
-  return execute$6(/* Ajax.getJson */'Ajax.getJson', /* url */url);
+  return execute$7(/* Ajax.getJson */'Ajax.getJson', /* url */url);
 };
 
 const getWebViewsDefault = async () => {
@@ -20796,12 +20924,12 @@ const doInvalidateExtensionsCache = async () => {
 const handleExtensionsCacheInvalidated = async (extensionId, disabled) => {
   try {
     const hasExtensionState = typeof extensionId === 'string' && typeof disabled === 'boolean';
-    await execute$6('KeyBindings.hydrate');
-    await execute$6('ColorTheme.reload');
+    await execute$7('KeyBindings.hydrate');
+    await execute$7('ColorTheme.reload');
     if (hasExtensionState) {
-      await execute$6('Layout.handleExtensionsChanged', extensionId, disabled);
+      await execute$7('Layout.handleExtensionsChanged', extensionId, disabled);
     } else {
-      await execute$6('Layout.handleExtensionsChanged');
+      await execute$7('Layout.handleExtensionsChanged');
     }
   } catch {
     // ignore
@@ -21098,7 +21226,7 @@ const ExtensionHotReload_ipc = {
 };
 
 const defaultDependencies$2 = {
-  executeCommand: execute$6,
+  executeCommand: execute$7,
   executeViewletCommand: executeViewletCommand,
   getAllStates: getAllStates
 };
@@ -22703,7 +22831,7 @@ const wrapExtensionSearchCommand = key => {
 };
 
 const defaultDependencies = {
-  clearProblemsSummary: () => execute$6('Layout.clearProblemsSummary'),
+  clearProblemsSummary: () => execute$7('Layout.clearProblemsSummary'),
   getState: () => getState$2(Problems),
   invoke: invoke$f
 };
@@ -24548,7 +24676,7 @@ const handleClickOk = async state => {
   const {
     okCommand
   } = state;
-  await execute$6(okCommand);
+  await execute$7(okCommand);
   return state;
 };
 const handleClickClose = async state => {
@@ -25352,11 +25480,11 @@ const handleClickAt$1 = async (state, eventX, eventY) => {
   return state;
 };
 const handleSashCornerPointerDown = async (state, eventX, eventY) => {
-  await execute$6('Layout.handleSashPointerDown', Preview$1);
+  await execute$7('Layout.handleSashPointerDown', Preview$1);
   return state;
 };
 const handleSashCornerPointerMove = async (state, eventX, eventY) => {
-  await execute$6('Layout.handleSashPointerMove', eventX, eventY);
+  await execute$7('Layout.handleSashPointerMove', eventX, eventY);
   return state;
 };
 const handleSashCornerPointerUp = state => {
@@ -25714,7 +25842,7 @@ const handleLink = async (state, uri) => {
   if (!URL.canParse(uri) || !/^https?:\/\//i.test(uri)) {
     return state;
   }
-  await execute$6('Layout.showPreview', 'simple-browser://');
+  await execute$7('Layout.showPreview', 'simple-browser://');
   const {
     previewId
   } = getState$2(Layout);
@@ -25726,7 +25854,7 @@ const handleData = async (state, data) => {
   return state;
 };
 const handleExit = async state => {
-  await execute$6('Terminals.handleTerminalExit', state.uid);
+  await execute$7('Terminals.handleTerminalExit', state.uid);
   return state;
 };
 const handleBlur$2 = state => {
@@ -26535,7 +26663,7 @@ const loadContent$B = async (state, savedState, context) => {
   const isQuickSuggestionsEnabled$1 = isQuickSuggestionsEnabled();
   const completionTriggerCharacters = getCompletionTriggerCharacters();
   const diagnosticsEnabled$1 = diagnosticsEnabled();
-  const content = state.applicationId === undefined ? await getTextEditorContent(uri) : await execute$5(state.applicationId, 'readFile', uri);
+  const content = state.applicationId === undefined ? await getTextEditorContent(uri) : await execute$6(state.applicationId, 'readFile', uri);
   const languageId = context?.languageId || getLanguageId(state, content);
   const tokenizer = getTokenizer(languageId);
   const tokenizerId = create$1j();
@@ -26636,7 +26764,7 @@ const updateSemanticTokens = async state => {
     console.log({
       newSemanticTokens
     });
-    await execute$6(/* Editor.setDecorations */'Editor.setDecorations', /* decorations */newSemanticTokens);
+    await execute$7(/* Editor.setDecorations */'Editor.setDecorations', /* decorations */newSemanticTokens);
     // TODO apply semantic tokens to editor and rerender
     // TODO possibly overlay semantic tokens as decorations
   } catch (error) {
@@ -26863,7 +26991,7 @@ const handleUriChange = async (editor, editorUidOrNewUri, maybeNewUri) => {
   };
 };
 const loadContentLater$2 = async editor => {
-  await execute$6('Viewlet.executeViewletCommand', editor.uid, 'updateDiagnostics');
+  await execute$7('Viewlet.executeViewletCommand', editor.uid, 'updateDiagnostics');
 };
 const loadEditorContent = wrapEditorCommand('Editor.loadContent');
 const loadEditorContentPreservingFocus = wrapEditorCommand('Editor.loadContent', {
@@ -27446,7 +27574,7 @@ const create$w = (id, uri, x, y, width, height, _args, parentUid) => {
   };
 };
 const loadContent$v = async (state, savedState) => {
-  const view = await getExtensionView(state.uri);
+  const view = await getExtensionView(state.uri, state.applicationId);
   if (!view) {
     throw new Error(`view ${state.uri} not found`);
   }
@@ -27459,7 +27587,7 @@ const loadContent$v = async (state, savedState) => {
     viewId: view.id
   };
   if (view.kind === 'virtualDom') {
-    const result = await invoke$L('Extensions.createViewInstance', view.id, state.uid, createContext(stateWithViewId, savedState), assetDir, getPlatform$4());
+    const result = await invoke$L('Extensions.createViewInstance', view.id, state.uid, createContext(stateWithViewId, savedState), assetDir, getPlatform$4(), state.applicationId);
     const createResult = result;
     if (createResult.ok === false) {
       throw restoreError(createResult.error);
@@ -27558,7 +27686,7 @@ const setComponentState$9 = async (state, componentState) => {
   };
 };
 const handleClickAction$2 = async (state, index, command) => {
-  await execute$6('ExtensionHost.executeCommand', command);
+  await execute$7('ExtensionHost.executeCommand', command);
   return state;
 };
 const handleInput$3 = (state, name, value) => {
@@ -27608,6 +27736,7 @@ const Commands$s = {
   handleSubmit,
   handleViewCommand,
   handleViewEvent,
+  loadContent: loadContent$v,
   rerender
 };
 const dispose$v = async state => {
@@ -28021,7 +28150,7 @@ const getUri = (state, index) => {
 const selectIndexLead = async (state, index) => {
   const uri = getUri(state, index);
   // TODO open file and jump to line
-  await execute$6(/* Main.openUri */'Main.openUri', /* uri */uri);
+  await execute$7(/* Main.openUri */'Main.openUri', /* uri */uri);
   return {
     ...state,
     focusedIndex: index
@@ -29007,7 +29136,7 @@ const handleDispose = async browserUid => {
 const Deb = 'Deb';
 const None$4 = 'None';
 
-const commit = '4d1244a';
+const commit = 'c766415';
 
 const getAutoUpdateType = () => {
   if (getPlatform$4() === Web$1) {
@@ -30071,7 +30200,7 @@ const closeChat = state => {
   return hideSecondarySideBar(state);
 };
 const openCommandPalette = async state => {
-  await execute$6('QuickPick.showCommands');
+  await execute$7('QuickPick.showCommands');
   return {
     newState: state,
     commands: []
@@ -30121,7 +30250,7 @@ const showPanel = async (state, moduleId = state.panelView, uri = '') => {
 const openIntegratedTerminal = async (state, cwd) => {
   const terminalsActive = state.panelVisible && Boolean(getInstance$1(Terminals));
   if (terminalsActive) {
-    await execute$6('Terminals.addTerminal', cwd);
+    await execute$7('Terminals.addTerminal', cwd);
     return {
       newState: {
         ...state,
@@ -30135,7 +30264,7 @@ const openIntegratedTerminal = async (state, cwd) => {
 const openProblems = async (state, filterValue) => {
   const result = await showPanel(state, Problems);
   if (filterValue !== undefined) {
-    await execute$6('Problems.handleFilterInput', filterValue);
+    await execute$7('Problems.handleFilterInput', filterValue);
   }
   return result;
 };
@@ -30145,7 +30274,7 @@ const openOutput = async (state, channelId) => {
   }
   // Commit the panel's DOM before updating the channel value in its toolbar.
   await executeViewletCommand(state.uid, 'showPanel', Output, channelId);
-  await execute$6('Output.selectChannel', channelId);
+  await execute$7('Output.selectChannel', channelId);
   return {
     newState: state,
     commands: []
@@ -30154,7 +30283,7 @@ const openOutput = async (state, channelId) => {
 const openDebugConsole = async (state, inputValue) => {
   const result = await showPanel(state, DebugConsole);
   if (inputValue !== undefined) {
-    await execute$6('ViewletDebugConsole.handleInput', inputValue);
+    await execute$7('ViewletDebugConsole.handleInput', inputValue);
   }
   return result;
 };
@@ -30363,7 +30492,7 @@ const showPreview = async (initialState, uri = initialState.previewUri, previewV
       };
     }
     if (previewViewletId === Preview$3) {
-      await execute$6('Preview.setUri', uri);
+      await execute$7('Preview.setUri', uri);
     }
     return {
       newState: {
@@ -31342,7 +31471,7 @@ const handleFocus = state => {
   return handleFocusChange$1(state, true);
 };
 const showE2eTests = async state => {
-  await execute$6('SideBar.show', 'E2eTests');
+  await execute$7('SideBar.show', 'E2eTests');
   return state;
 };
 const handleBlur = state => {
@@ -31579,7 +31708,7 @@ const refreshAuthState = async state => {
 };
 const showAuthNotification = async (type, message) => {
   try {
-    await execute$6('Notification.create', type, message);
+    await execute$7('Notification.create', type, message);
   } catch {
     // Authentication should continue when notifications are unavailable.
   }
@@ -31693,7 +31822,7 @@ const refreshSourceControlBadgeCount = async state => {
   }
 };
 const contentLoadedEffects$2 = async () => {
-  await execute$6('Layout.refreshSourceControlBadgeCount');
+  await execute$7('Layout.refreshSourceControlBadgeCount');
 };
 const handleBadgeCountChange = async (state, changes) => {
   return callGlobalEvent(state, 'handleBadgeCountChange', changes);
@@ -31948,29 +32077,29 @@ const ViewletLayout = {
 const defaultColorTheme = 'slime';
 const defaultTitleTemplate = '${folderName}';
 const closeWidgets = async () => {
-  await Promise.all([execute$6('Viewlet.closeWidget', QuickPick), execute$6('Viewlet.closeWidget', About), execute$6('Viewlet.closeWidget', Dialog), execute$6('Viewlet.closeWidget', Confirm$1)]);
+  await Promise.all([execute$7('Viewlet.closeWidget', QuickPick), execute$7('Viewlet.closeWidget', About), execute$7('Viewlet.closeWidget', Dialog), execute$7('Viewlet.closeWidget', Confirm$1)]);
 };
 const resetTitleBar = async titleBarWidth => {
-  await execute$6('TitleBar.closeMenu');
-  await execute$6('TitleBar.setTitleTemplate', defaultTitleTemplate);
-  await execute$6('TitleBar.setWidth', titleBarWidth);
+  await execute$7('TitleBar.closeMenu');
+  await execute$7('TitleBar.setTitleTemplate', defaultTitleTemplate);
+  await execute$7('TitleBar.setWidth', titleBarWidth);
 };
 const resetWorkspace = async () => {
-  await execute$6('Main.closeAllEditors');
-  const workspacePath = await execute$6('Workspace.getPath');
+  await execute$7('Main.closeAllEditors');
+  const workspacePath = await execute$7('Workspace.getPath');
   if (workspacePath) {
-    await execute$6('Workspace.close');
+    await execute$7('Workspace.close');
   }
 };
 const resetSideBar = async (sideBarFocusMode, sideBarLocation, sideBarView, sideBarVisible) => {
   if (sideBarFocusMode) {
-    await execute$6('Layout.leaveSideBarFocusMode');
+    await execute$7('Layout.leaveSideBarFocusMode');
   }
   if (sideBarLocation !== Right) {
-    await execute$6('Layout.moveSideBarRight');
+    await execute$7('Layout.moveSideBarRight');
   }
   if (!sideBarVisible || sideBarView !== Explorer$1) {
-    await execute$6('Layout.showSideBar', Explorer$1, false);
+    await execute$7('Layout.showSideBar', Explorer$1, false);
   }
 };
 const resetPanel = async (panelMaximized, panelView, panelVisible) => {
@@ -31979,37 +32108,37 @@ const resetPanel = async (panelMaximized, panelView, panelVisible) => {
     return;
   }
   if (panelMaximized) {
-    await execute$6('Layout.unmaximizePanel');
+    await execute$7('Layout.unmaximizePanel');
   }
   if (panelViewNeedsReset) {
-    await execute$6('Layout.showPanel', Problems);
+    await execute$7('Layout.showPanel', Problems);
   }
-  await execute$6('Layout.hidePanel');
+  await execute$7('Layout.hidePanel');
 };
 const resetActivityBar = async () => {
-  await execute$6('ActivityBar.reset');
+  await execute$7('ActivityBar.reset');
 };
 const resetVisibility = async state => {
   if (state.secondarySideBarVisible) {
-    await execute$6('Layout.hideSecondarySideBar');
+    await execute$7('Layout.hideSecondarySideBar');
   }
   if (state.previewVisible) {
-    await execute$6('Layout.hidePreview');
+    await execute$7('Layout.hidePreview');
   }
   if (state.secondaryPreviewVisible) {
-    await execute$6('Layout.hideSecondaryPreview');
+    await execute$7('Layout.hideSecondaryPreview');
   }
   if (!state.mainVisible) {
-    await execute$6('Layout.showMain');
+    await execute$7('Layout.showMain');
   }
   if (!state.activityBarVisible) {
-    await execute$6('Layout.showActivityBar');
+    await execute$7('Layout.showActivityBar');
   }
   if (!state.statusBarVisible) {
-    await execute$6('Layout.showStatusBar');
+    await execute$7('Layout.showStatusBar');
   }
   if (!state.titleBarVisible) {
-    await execute$6('Layout.showTitleBar');
+    await execute$7('Layout.showTitleBar');
   }
 };
 const resetViewLocations = async state => {
@@ -32042,7 +32171,7 @@ const reset = async state => {
     sideBarVisible,
     titleBarWidth
   } = state;
-  await Promise.all([execute$6('Menu.hide', false), resetTitleBar(titleBarWidth), closeWidgets(), execute$6('ColorTheme.setColorTheme', defaultColorTheme), resetWorkspace()]);
+  await Promise.all([execute$7('Menu.hide', false), resetTitleBar(titleBarWidth), closeWidgets(), execute$7('ColorTheme.setColorTheme', defaultColorTheme), resetWorkspace()]);
   await Promise.all([resetSideBar(sideBarFocusMode, sideBarLocation, sideBarView, sideBarVisible), resetPanel(panelMaximized, panelView, panelVisible)]);
   await resetActivityBar();
   return {
@@ -33252,7 +33381,7 @@ const ViewletOutput_ipc = {
 };
 
 const contentLoadedEffects$1 = async () => {
-  await execute$6('Layout.refreshProblemsSummary');
+  await execute$7('Layout.refreshProblemsSummary');
 };
 const {
   Commands: Commands$i,
@@ -33665,11 +33794,11 @@ const create$g = (id, uri, x, y, width, height, args, parentUid) => {
 };
 const loadContent$f = async (state, savedState) => {
   const isTest$1 = isTest();
-  await invoke$y('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
-  await invoke$y('RunAndDebug.loadContent', state.uid, isTest$1, savedState);
-  const diffResult = await invoke$y('RunAndDebug.diff2', state.uid);
-  const commands = await invoke$y('RunAndDebug.render2', state.uid, diffResult);
-  const actionsDom = await invoke$y('RunAndDebug.renderActions', state.uid);
+  await invoke$x('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
+  await invoke$x('RunAndDebug.loadContent', state.uid, isTest$1, savedState);
+  const diffResult = await invoke$x('RunAndDebug.diff2', state.uid);
+  const commands = await invoke$x('RunAndDebug.render2', state.uid, diffResult);
+  const actionsDom = await invoke$x('RunAndDebug.renderActions', state.uid);
   const debugId = isTest$1 ? 'test-debug' : 'node-debug'; // TODO
   return {
     ...state,
@@ -33690,17 +33819,17 @@ const hotReload$7 = async state => {
   state.isHotReloading = true;
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
-  const savedState = await invoke$y('RunAndDebug.saveState', state.uid);
-  await restart$m('RunAndDebug.terminate');
+  const savedState = await invoke$x('RunAndDebug.saveState', state.uid);
+  await restart$l('RunAndDebug.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$y('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
-  await invoke$y('RunAndDebug.loadContent', state.uid, state.isTest, savedState);
-  await invoke$y('RunAndDebug.loadContentLater', state.uid);
-  const diffResult = await invoke$y('RunAndDebug.diff2', state.uid);
-  const commands = await invoke$y('RunAndDebug.render2', state.uid, diffResult);
+  await invoke$x('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
+  await invoke$x('RunAndDebug.loadContent', state.uid, state.isTest, savedState);
+  await invoke$x('RunAndDebug.loadContentLater', state.uid);
+  const diffResult = await invoke$x('RunAndDebug.diff2', state.uid);
+  const commands = await invoke$x('RunAndDebug.render2', state.uid, diffResult);
   return {
     ...oldState,
     commands,
@@ -33761,19 +33890,19 @@ const resize$c = (state, dimensions) => {
   };
 };
 const saveState$7 = async state => {
-  const savedState = await invoke$y('RunAndDebug.saveState', state.uid);
+  const savedState = await invoke$x('RunAndDebug.saveState', state.uid);
   return savedState;
 };
 
 const wrapRunAndDebugCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$y(`RunAndDebug.${key}`, state.uid, ...args);
-    const diffResult = await invoke$y('RunAndDebug.diff2', state.uid);
+    await invoke$x(`RunAndDebug.${key}`, state.uid, ...args);
+    const diffResult = await invoke$x('RunAndDebug.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$y('RunAndDebug.render2', state.uid, diffResult);
-    const actionsDom = await invoke$y('RunAndDebug.renderActions', state.uid);
+    const commands = await invoke$x('RunAndDebug.render2', state.uid, diffResult);
+    const actionsDom = await invoke$x('RunAndDebug.renderActions', state.uid);
     if (commands.length === 0) {
       return state;
     }
@@ -33790,7 +33919,7 @@ const wrapRunAndDebugCommand = key => {
 
 const Commands$d = {};
 const getCommands$8 = async () => {
-  const commands = await invoke$y('RunAndDebug.getCommandIds');
+  const commands = await invoke$x('RunAndDebug.getCommandIds');
   for (const command of commands) {
     Commands$d[command] = wrapRunAndDebugCommand(command);
   }
@@ -33805,13 +33934,13 @@ const Variables$6 = ['TitleBarForeground', 'DebugSectionHeaderBackground', 'Side
 const Events$8 = {};
 
 const getKeyBindings$8 = () => {
-  return invoke$y('RunAndDebug.getKeyBindings');
+  return invoke$x('RunAndDebug.getKeyBindings');
 };
 
 const menus$8 = [];
 const getMenus$7 = async () => {
   try {
-    const modules = await invoke$y('RunAndDebug.getMenuEntries');
+    const modules = await invoke$x('RunAndDebug.getMenuEntries');
     const adjusted = modules.map(module => {
       return {
         ...module,
@@ -33838,7 +33967,7 @@ const renderItems$1 = {
 };
 const render$f = [renderItems$1];
 const renderEventListeners$b = async () => {
-  const listeners = await invoke$y('RunAndDebug.renderEventListeners');
+  const listeners = await invoke$x('RunAndDebug.renderEventListeners');
   return listeners;
 };
 
@@ -34243,11 +34372,11 @@ const handleClickAction$1 = async (state, index, command) => {
   }
   const currentViewletId = getId$1(state);
   if (currentViewletId.includes('.')) {
-    await execute$6('ExtensionHost.executeCommand', command);
+    await execute$7('ExtensionHost.executeCommand', command);
     return state;
   }
   const fullCommand = `${currentViewletId}.${command}`;
-  await execute$6(fullCommand);
+  await execute$7(fullCommand);
   return state;
 };
 
@@ -34293,7 +34422,7 @@ const create$a = (id, uri, x, y, width, height) => {
 const loadContent$9 = async (state, savedState, targetViewletId) => {
   // TODO get it from layout state
   const restore = savedState?.restore !== false;
-  let savedViewletId = restore ? targetViewletId || (await execute$6('Layout.getActiveSideBarView')) : Explorer$1;
+  let savedViewletId = restore ? targetViewletId || (await execute$7('Layout.getActiveSideBarView')) : Explorer$1;
   if (!savedViewletId) {
     savedViewletId = Explorer$1;
   }
@@ -34334,8 +34463,8 @@ const getChildModuleId = moduleId => {
   }
   return ExtensionView$1;
 };
-const getExtensionViewMetadata = async moduleId => {
-  const view = await getExtensionView(moduleId);
+const getExtensionViewMetadata = async (moduleId, applicationId) => {
+  const view = await getExtensionView(moduleId, applicationId);
   return {
     extensionId: view?.extensionId || '',
     titleAreaHeight: view?.showSideBarHeader === false ? 0 : defaultTitleAreaHeight
@@ -34377,7 +34506,7 @@ const handleSideBarViewletChange = async (state, moduleId, restore = true) => {
   state.currentViewletId = moduleId;
   const uid = state.uid;
   const childModuleId = getChildModuleId(moduleId);
-  const extensionViewMetadata = childModuleId === ExtensionView$1 ? await getExtensionViewMetadata(moduleId) : {
+  const extensionViewMetadata = childModuleId === ExtensionView$1 ? await getExtensionViewMetadata(moduleId, state.applicationId) : {
     extensionId: '',
     titleAreaHeight: defaultTitleAreaHeight
   };
@@ -34539,7 +34668,7 @@ const setTitle = (state, title) => {
 
 // TODO no default parameter -> monomorphism
 const openViewlet$1 = async (state, moduleId, focus = false, args) => {
-  await execute$6('Layout.openSideBarViewlet', moduleId);
+  await execute$7('Layout.openSideBarViewlet', moduleId);
   return state;
 };
 const dispose$8 = state => {
@@ -34590,7 +34719,7 @@ const focus$3 = async state => {
     return state;
   }
   if (state.applicationId === undefined) {
-    await execute$6(`${currentViewletId}.focus`);
+    await execute$7(`${currentViewletId}.focus`);
   } else {
     await executeForApplication(state.applicationId, `${currentViewletId}.focus`);
   }
@@ -34722,7 +34851,7 @@ const create$9 = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$8 = async (state, savedState) => {
-  let savedViewletId = await execute$6('Layout.getActiveSecondarySideBarView');
+  let savedViewletId = await execute$7('Layout.getActiveSecondarySideBarView');
   if (!savedViewletId) {
     savedViewletId = Chat;
   }
@@ -34781,8 +34910,8 @@ const handleSecondarySideBarViewletChange = async (state, moduleId) => {
   };
 };
 const openViewlet = async (state, moduleId, focus = false, args) => {
-  await execute$6('Layout.showSecondarySideBar');
-  await execute$6('Layout.openSecondarySideBarViewlet', moduleId);
+  await execute$7('Layout.showSecondarySideBar');
+  await execute$7('Layout.openSecondarySideBarViewlet', moduleId);
   return state;
 };
 const dispose$7 = state => {};
@@ -34821,7 +34950,7 @@ const focus$2 = async state => {
   if (!currentViewlet) {
     return state;
   }
-  await execute$6(`${currentViewletId}.focus`);
+  await execute$7(`${currentViewletId}.focus`);
   return state;
 };
 const handleUpdateStateChange = state => {
@@ -36733,7 +36862,7 @@ const handleWindowOpen = async (state, browserViewId, childBrowserViewId, url, d
   adoptWebContentsView();
   if (openExternalLinks || !tabsEnabled) {
     await disposeWebContentsView(childBrowserViewId);
-    await execute$6('Open.openExternal', url);
+    await execute$7('Open.openExternal', url);
     return state;
   }
   const currentState = state.hasSuggestionsOverlay ? await closeSuggestions(state) : state;
@@ -37203,7 +37332,7 @@ const openCookieImportView = value => {
   if (!value.startsWith('cookie-import-view:///')) {
     return false;
   }
-  void execute$6('Main.openUri', value);
+  void execute$7('Main.openUri', value);
   return true;
 };
 const addToSearchHistory = (state, value) => {
@@ -37310,7 +37439,7 @@ const handleKeyBinding = async (state, browserViewId, keyBinding) => {
     return focusPreviousTab(state);
   }
   if (keyBinding === openHistoryKeyBinding) {
-    await execute$6('Main.openUri', 'simple-browser-history://');
+    await execute$7('Main.openUri', 'simple-browser-history://');
     return state;
   }
   await handleKeyBinding$1(keyBinding);
@@ -37418,7 +37547,7 @@ const setFullWidth = async (state, fullWidth, addressSelection) => {
   };
 };
 const toggleFullWidth = state => {
-  void execute$6('Layout.toggleSimpleBrowserFullWidth', state.uid);
+  void execute$7('Layout.toggleSimpleBrowserFullWidth', state.uid);
   return state;
 };
 const focusAddress = async state => {
@@ -37451,7 +37580,7 @@ const openBackgroundTab = async (state, url) => {
     tabsEnabled
   } = state;
   if (!tabsEnabled) {
-    await execute$6('Main.openBackgroundTab', 'simple-browser://', {
+    await execute$7('Main.openBackgroundTab', 'simple-browser://', {
       iframeSrc: url
     });
     return state;
@@ -37577,7 +37706,7 @@ const openContextMenu = async (x, y, id, ...args) => {
     return;
   }
   const commandArgs = item.args || [];
-  await execute$6(item.command, ...commandArgs);
+  await execute$7(item.command, ...commandArgs);
 };
 const openContextMenu2 = async (x, y, uid, menuId, ...args) => {
   const entries = await getMenuEntries2(uid, menuId, ...args);
@@ -37591,7 +37720,7 @@ const openContextMenu2 = async (x, y, uid, menuId, ...args) => {
     return;
   }
   const commandArgs = item.args || [];
-  await execute$6(item.command, ...commandArgs);
+  await execute$7(item.command, ...commandArgs);
 };
 const openBrowserContextMenu = async (x, y, entries, browserViewId) => {
   const event = await invoke$M('ElectronContextMenu.openContextMenu', convertMenuItems(entries), x, y, browserViewId);
@@ -37599,7 +37728,7 @@ const openBrowserContextMenu = async (x, y, entries, browserViewId) => {
   const item = getItem(entries, event.data);
   // Native editing actions have already executed against the captured WebContents.
   if (!item || item.role || item.flags === Disabled || !item.command) return;
-  await execute$6(item.command, ...(item.args || []));
+  await execute$7(item.command, ...(item.args || []));
 };
 
 const menuEntrySeparator = {
@@ -39228,7 +39357,7 @@ const renderPendingSourceControl = async state => {
     };
     setState$2(state.uid, newState);
     setRenderedState(state.uid, newState);
-    await execute$6('Layout.setBadgeCount', SourceControl, badgeCount);
+    await execute$7('Layout.setBadgeCount', SourceControl, badgeCount);
   }
   return {
     ...state,
@@ -39281,7 +39410,7 @@ const loadContent$5 = async (state, savedState) => {
   const commands = await invoke$9('SourceControl.render2', state.uid, diffResult);
   const actionsDom = await invoke$9('SourceControl.renderActions2', state.uid);
   const badgeCount = await invoke$9('SourceControl.getBadgeCount', state.uid);
-  if (state.applicationId === undefined) await execute$6('Layout.setBadgeCount', SourceControl, badgeCount);else await execute$3(state.applicationId, 'Layout.setBadgeCount', SourceControl, badgeCount);
+  if (state.applicationId === undefined) await execute$7('Layout.setBadgeCount', SourceControl, badgeCount);else await execute$4(state.applicationId, 'Layout.setBadgeCount', SourceControl, badgeCount);
   return {
     ...state,
     commands,
@@ -39291,7 +39420,7 @@ const loadContent$5 = async (state, savedState) => {
   };
 };
 const loadContentLater = async state => {
-  await execute$6('Viewlet.executeViewletCommand', state.uid, 'loadContent', state.savedState);
+  await execute$7('Viewlet.executeViewletCommand', state.uid, 'loadContent', state.savedState);
 };
 const dispose$3 = async state => {
   await invoke$9('SourceControl.dispose', state.uid);
@@ -39377,7 +39506,7 @@ const handleWorkspaceChange = async state => {
   const commands = await invoke$9('SourceControl.render2', state.uid, diffResult);
   const actionsDom = await invoke$9('SourceControl.renderActions2', state.uid);
   const badgeCount = await invoke$9('SourceControl.getBadgeCount', state.uid);
-  if (state.applicationId === undefined) await execute$6('Layout.setBadgeCount', SourceControl, badgeCount);else await execute$3(state.applicationId, 'Layout.setBadgeCount', SourceControl, badgeCount);
+  if (state.applicationId === undefined) await execute$7('Layout.setBadgeCount', SourceControl, badgeCount);else await execute$4(state.applicationId, 'Layout.setBadgeCount', SourceControl, badgeCount);
   return {
     ...loadingState,
     actionsDom,
@@ -39578,7 +39707,7 @@ const getMenus$1 = async () => {
 };
 
 const contentLoadedEffects = async () => {
-  await execute$6('Layout.refreshProblemsSummary');
+  await execute$7('Layout.refreshProblemsSummary');
 };
 const {
   Commands: Commands$3,
@@ -39821,7 +39950,7 @@ const getChildBounds = (state, index = 0, count = 1) => {
 };
 const createViewlet = async (state, childUid, spawnOptions, cwd = '', index = 0, count = 1) => {
   const bounds = getChildBounds(state, index, count);
-  await execute$6('Layout.createViewlet', Terminal2, childUid, 0, bounds, cwd, [spawnOptions]);
+  await execute$7('Layout.createViewlet', Terminal2, childUid, 0, bounds, cwd, [spawnOptions]);
 };
 const resizeTerminals = async (state, terminalUids) => {
   return (await Promise.all(terminalUids.map((uid, index) => resize$J(uid, getChildBounds(state, index, terminalUids.length))))).flat();
@@ -40559,7 +40688,7 @@ const ViewletWebView_ipc = {
 };
 
 const readFile$5 = () => {
-  return execute$6(/* Developer.getStartupPerformanceContent */'Developer.getStartupPerformanceContent');
+  return execute$7(/* Developer.getStartupPerformanceContent */'Developer.getStartupPerformanceContent');
 };
 const writeFile$5 = () => {
   throw new Error('not implemented');
@@ -40572,7 +40701,7 @@ const FileSystemAppStartupPerformance = {
 };
 
 const readFile$4 = () => {
-  return execute$6('Developer.getMemoryUsageContent');
+  return execute$7('Developer.getMemoryUsageContent');
 };
 const writeFile$4 = () => {
   throw new Error('not implemened');
@@ -40662,7 +40791,7 @@ const readJsonInternal = async (getPath, defaultContent = '') => {
 };
 const writeFileWeb = async (path, content) => {
   if (getPlatform$4() === Web$1) {
-    await execute$6(/* LocalStorage.setText */'LocalStorage.setText', /* key */path, /* value */content);
+    await execute$7(/* LocalStorage.setText */'LocalStorage.setText', /* key */path, /* value */content);
   }
 };
 const writeFileNode = async (path, content) => {
@@ -40813,19 +40942,19 @@ const isDirectoryPickerNotSupportedError = error => {
 };
 const openFolder$2 = async () => {
   try {
-    const result = await execute$6('FilePicker.showDirectoryPicker', {
+    const result = await execute$7('FilePicker.showDirectoryPicker', {
       startIn: 'pictures',
       mode: 'readwrite'
     });
     const uri = `html:///${result.name}`;
-    await execute$6('PersistentFileHandle.addHandle', uri, result);
-    await execute$6('Workspace.setPath', uri);
+    await execute$7('PersistentFileHandle.addHandle', uri, result);
+    await execute$7('Workspace.setPath', uri);
   } catch (error) {
     if (isAbortError(error)) {
       return;
     }
     if (isDirectoryPickerNotSupportedError(error)) {
-      await execute$6('Dialog.showWarning', {
+      await execute$7('Dialog.showWarning', {
         message: "Your browser doesn't support opening local folders.",
         title: 'Opening Local Folders is Unsupported'
       });
@@ -40846,7 +40975,7 @@ const openFolder$1 = async () => {
     return;
   }
   const uri = pathToFileUri(path);
-  await execute$6(/* Workspace.setUri */'Workspace.setUri', /* uri */uri);
+  await execute$7(/* Workspace.setUri */'Workspace.setUri', /* uri */uri);
 };
 
 const OpenFolderRemote = {
@@ -40861,7 +40990,7 @@ const openFolder = async () => {
   }
   const path = folders[0];
   const uri = pathToFileUri(path);
-  await execute$6(/* Workspace.setUri */'Workspace.setUri', /* uri */uri);
+  await execute$7(/* Workspace.setUri */'Workspace.setUri', /* uri */uri);
 };
 
 const OpenFolderElectron = {
@@ -40873,7 +41002,7 @@ const openExternal = async state => {
   const {
     iframeSrc
   } = state;
-  await execute$6('Open.openExternal', iframeSrc);
+  await execute$7('Open.openExternal', iframeSrc);
   return state;
 };
 
@@ -40883,7 +41012,7 @@ const ViewletSimpleBrowserOpenExternal = {
 };
 
 const openHistory = async state => {
-  await execute$6('Main.openUri', 'simple-browser-history://');
+  await execute$7('Main.openUri', 'simple-browser-history://');
   return state;
 };
 
@@ -40999,7 +41128,7 @@ const ViewletSimpleBrowserForward = {
 };
 
 const importFirefoxCookies = async state => {
-  await execute$6('Main.openUri', 'cookie-import-view:///');
+  await execute$7('Main.openUri', 'cookie-import-view:///');
   return state;
 };