@lvce-editor/extension-search-view 7.7.0 → 7.9.1

package/dist/extensionSearchViewWorkerMain.js

@@ -145,7 +145,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -299,7 +298,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -603,8 +609,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -615,55 +623,77 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    error.stack = error.stack + NewLine + currentStack;
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  restoredError.stack = parentStack + NewLine + currentStack;
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+    return;
+  }
+  if (error.data.stack) {
+    restoredError.stack = error.data.stack;
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  if (!error.data) {
+    return;
+  }
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -747,7 +777,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$9 = (message, result) => {
+const create$a = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -756,7 +786,7 @@ const create$9 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -850,7 +880,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$8 = (method, params) => {
+const create$9 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -858,7 +888,7 @@ const create$8 = (method, params) => {
   };
 };
 
-const create$7 = (id, method, params) => {
+const create$8 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -869,12 +899,12 @@ const create$7 = (id, method, params) => {
 };
 
 let id$1 = 0;
-const create$6 = () => {
+const create$7 = () => {
   return ++id$1;
 };
 
 const registerPromise = map => {
-  const id = create$6();
+  const id = create$7();
   const {
     promise,
     resolve
@@ -891,7 +921,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
+  const message = create$8(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -927,7 +957,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$8(method, params);
+      const message = create$9(method, params);
       ipc.send(message);
     }
   };
@@ -967,7 +997,7 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$5 = async ({
+const create$6 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -985,7 +1015,7 @@ const create$5 = async ({
   return rpc;
 };
 
-const create$4 = async ({
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -995,14 +1025,14 @@ const create$4 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$6({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
 
-const create$3 = async ({
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1045,7 +1075,7 @@ const remove = id => {
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create$2 = rpcId => {
+const create$3 = rpcId => {
   return {
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1083,18 +1113,182 @@ const create$2 = rpcId => {
 
 const None$3 = 'none';
 
+const Audio = 0;
 const Button$2 = 1;
+const Col = 2;
+const ColGroup = 3;
 const Div = 4;
+const H1 = 5;
 const Input$1 = 6;
+const Kbd = 7;
+const Span = 8;
+const Table = 9;
+const TBody = 10;
+const Td = 11;
 const Text = 12;
+const Th = 13;
+const THead = 14;
+const Tr = 15;
+const I = 16;
 const Img = 17;
+const Root = 0;
+const Ins = 20;
+const Del = 21;
+const H2 = 22;
+const H3 = 23;
+const H4 = 24;
+const H5 = 25;
+const H6 = 26;
+const Article = 27;
+const Aside = 28;
+const Footer = 29;
+const Header = 30;
+const Nav = 40;
+const Section = 41;
+const Search = 42;
+const Dd = 43;
+const Dl = 44;
+const Figcaption = 45;
+const Figure = 46;
+const Hr = 47;
+const Li = 48;
+const Ol = 49;
+const P = 50;
+const Pre = 51;
+const A = 53;
+const Abbr = 54;
+const Br = 55;
+const Cite = 56;
+const Data = 57;
+const Time = 58;
+const Tfoot = 59;
+const Ul = 60;
+const Video = 61;
+const TextArea = 62;
+const Select = 63;
+const Option$1 = 64;
+const Code = 65;
+const Label = 66;
+const Dt = 67;
+const Iframe = 68;
+const Main = 69;
+const Strong = 70;
+const Em = 71;
+const Style = 72;
+const Html = 73;
+const Head = 74;
+const Title = 75;
+const Meta = 76;
+const Canvas = 77;
+const Form = 78;
+const BlockQuote = 79;
+const Quote = 80;
+const Circle = 81;
+const Defs = 82;
+const Ellipse = 83;
+const G = 84;
+const Line = 85;
+const Path = 86;
+const Polygon = 87;
+const Polyline = 88;
+const Rect = 89;
+const Svg = 90;
+const Use = 91;
 const Reference = 100;
 
+const VirtualDomElements = {
+  __proto__: null,
+  A,
+  Abbr,
+  Article,
+  Aside,
+  Audio,
+  BlockQuote,
+  Br,
+  Button: Button$2,
+  Canvas,
+  Circle,
+  Cite,
+  Code,
+  Col,
+  ColGroup,
+  Data,
+  Dd,
+  Defs,
+  Del,
+  Div,
+  Dl,
+  Dt,
+  Ellipse,
+  Em,
+  Figcaption,
+  Figure,
+  Footer,
+  Form,
+  G,
+  H1,
+  H2,
+  H3,
+  H4,
+  H5,
+  H6,
+  Head,
+  Header,
+  Hr,
+  Html,
+  I,
+  Iframe,
+  Img,
+  Input: Input$1,
+  Ins,
+  Kbd,
+  Label,
+  Li,
+  Line,
+  Main,
+  Meta,
+  Nav,
+  Ol,
+  Option: Option$1,
+  P,
+  Path,
+  Polygon,
+  Polyline,
+  Pre,
+  Quote,
+  Rect,
+  Reference,
+  Root,
+  Search,
+  Section,
+  Select,
+  Span,
+  Strong,
+  Style,
+  Svg,
+  TBody,
+  THead,
+  Table,
+  Td,
+  Text,
+  TextArea,
+  Tfoot,
+  Th,
+  Time,
+  Title,
+  Tr,
+  Ul,
+  Use,
+  Video
+};
+
 const Button$1 = 'event.button';
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
 const DeltaMode = 'event.deltaMode';
 const DeltaY = 'event.deltaY';
+const TargetName = 'event.target.name';
+const TargetSelectionStart = 'event.target.selectionStart';
 const TargetValue = 'event.target.value';
 
 const Script$1 = 2;
@@ -1116,7 +1310,7 @@ const SetPatches = 'Viewlet.setPatches';
 const {
   invoke: invoke$2,
   set: set$4
-} = create$2(ExtensionHostWorker);
+} = create$3(ExtensionHostWorker);
 
 const ExtensionHost = {
   __proto__: null,
@@ -1126,13 +1320,13 @@ const ExtensionHost = {
 
 const {
   set: set$3
-} = create$2(ExtensionManagementWorker);
+} = create$3(ExtensionManagementWorker);
 
 const {
   invoke: invoke$1,
   invokeAndTransfer,
   set: set$2
-} = create$2(RendererWorker);
+} = create$3(RendererWorker);
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
   number(menuId);
@@ -1140,6 +1334,12 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(y);
   await invoke$1('ContextMenu.show2', uid, menuId, x, y, args);
 };
+const disableExtension = async id => {
+  return invoke$1('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  return invoke$1('ExtensionManagement.enable', id);
+};
 const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
@@ -1158,16 +1358,82 @@ const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
 const openUri$1 = async (uri, focus, options) => {
   await invoke$1('Main.openUri', uri, focus, options);
 };
+const showErrorDialog = async errorInfo => {
+  await invoke$1('ErrorHandling.showErrorDialog', errorInfo);
+};
+const uninstallExtension = async id => {
+  return invoke$1('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  return invoke$1('ExtensionManagement.install', id);
+};
 
 const toCommandId = key => {
   const dotIndex = key.indexOf('.');
   return key.slice(dotIndex + 1);
 };
-const create$1 = () => {
+const create$2 = () => {
+  const commandQueues = new Map();
+  const generations = Object.create(null);
   const states = Object.create(null);
   const commandMapRef = {};
+  const getGeneration = uid => generations[uid] || 0;
+  const isCurrentGeneration = (uid, generation) => {
+    return states[uid] !== undefined && getGeneration(uid) === generation;
+  };
+  const updateState = (uid, generation, fallbackState, updater) => {
+    if (!isCurrentGeneration(uid, generation)) {
+      return Promise.resolve(fallbackState);
+    }
+    const current = states[uid];
+    const updatedState = updater(current.newState);
+    if (updatedState !== current.newState) {
+      states[uid] = {
+        newState: updatedState,
+        oldState: current.oldState,
+        scheduledState: updatedState
+      };
+    }
+    return Promise.resolve(updatedState);
+  };
+  const createAsyncCommandContext = (uid, generation) => {
+    let latestState = states[uid].newState;
+    return {
+      getState: () => {
+        if (isCurrentGeneration(uid, generation)) {
+          latestState = states[uid].newState;
+        }
+        return latestState;
+      },
+      updateState: async updater => {
+        latestState = await updateState(uid, generation, latestState, updater);
+        return latestState;
+      }
+    };
+  };
+  const enqueueCommand = async (uid, command) => {
+    const previous = commandQueues.get(uid) || Promise.resolve();
+    const run = async () => {
+      try {
+        await previous;
+      } catch {
+        // The previous caller receives its error; later commands must still run.
+      }
+      await command();
+    };
+    const current = run();
+    commandQueues.set(uid, current);
+    try {
+      await current;
+    } finally {
+      if (commandQueues.get(uid) === current) {
+        commandQueues.delete(uid);
+      }
+    }
+  };
   return {
     clear() {
+      commandQueues.clear();
       for (const key of Object.keys(states)) {
         delete states[key];
       }
@@ -1187,6 +1453,7 @@ const create$1 = () => {
       return diffResult;
     },
     dispose(uid) {
+      commandQueues.delete(uid);
       delete states[uid];
     },
     get(uid) {
@@ -1204,14 +1471,27 @@ const create$1 = () => {
       Object.assign(commandMapRef, commandMap);
     },
     set(uid, oldState, newState, scheduledState) {
+      const current = states[uid];
+      if (!current || oldState === newState && newState !== current.newState) {
+        generations[uid] = getGeneration(uid) + 1;
+      }
       states[uid] = {
         newState,
         oldState,
         scheduledState: scheduledState ?? newState
       };
     },
+    wrapAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const context = createAsyncCommandContext(uid, generation);
+        await fn(context, ...args);
+      };
+      return wrapped;
+    },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -1220,6 +1500,9 @@ const create$1 = () => {
         if (oldState === newerState || newState === newerState) {
           return;
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return;
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -1244,6 +1527,7 @@ const create$1 = () => {
     },
     wrapLoadContent(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -1258,6 +1542,11 @@ const create$1 = () => {
             error
           };
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return {
+            error
+          };
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -1273,6 +1562,51 @@ const create$1 = () => {
         };
       };
       return wrapped;
+    },
+    wrapSerialAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const context = createAsyncCommandContext(uid, generation);
+          await fn(context, ...args);
+        });
+      };
+      return wrapped;
+    },
+    wrapSerialCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const {
+            newState,
+            oldState
+          } = states[uid];
+          const newerState = await fn(newState, ...args);
+          if (oldState === newerState || newState === newerState) {
+            return;
+          }
+          if (!isCurrentGeneration(uid, generation)) {
+            return;
+          }
+          const latestOld = states[uid];
+          const latestNew = {
+            ...latestOld.newState,
+            ...newerState
+          };
+          states[uid] = {
+            newState: latestNew,
+            oldState: latestOld.oldState,
+            scheduledState: latestNew
+          };
+        });
+      };
+      return wrapped;
     }
   };
 };
@@ -1284,21 +1618,84 @@ const None$2 = 0;
 const Input = 1;
 const List$2 = 2;
 
+const isWhiteSpace = character => {
+  return /\s/.test(character);
+};
+const getCompletionRange = (value, cursorOffset) => {
+  const offset = Math.min(Math.max(cursorOffset, 0), value.length);
+  let start = offset;
+  while (start > 0 && !isWhiteSpace(value[start - 1])) {
+    start--;
+  }
+  if (value[start] !== '@') {
+    return undefined;
+  }
+  let end = offset;
+  while (end < value.length && !isWhiteSpace(value[end])) {
+    end++;
+  }
+  return {
+    end,
+    query: value.slice(start, offset),
+    start
+  };
+};
+
 const handleError = async (error, notify = true, prefix = '') => {
   // @ts-ignore
   console.error(error);
 };
 
+const loadStates = new Map();
+const tokenGenerator = {
+  value: 0
+};
+const cancel = uid => {
+  const loadState = loadStates.get(uid);
+  if (!loadState) {
+    return;
+  }
+  loadStates.delete(uid);
+  loadState.resolve();
+};
+const create$1 = uid => {
+  cancel(uid);
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  const token = ++tokenGenerator.value;
+  loadStates.set(uid, {
+    promise,
+    resolve,
+    token
+  });
+};
+const finish = (uid, token) => {
+  const loadState = loadStates.get(uid);
+  if (!loadState || loadState.token !== token) {
+    return;
+  }
+  loadStates.delete(uid);
+  loadState.resolve();
+};
+const getToken = uid => {
+  return loadStates.get(uid)?.token;
+};
+const wait = uid => {
+  return loadStates.get(uid)?.promise || Promise.resolve();
+};
+
 const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
 const i18nString = (key, placeholders = emptyObject) => {
   if (placeholders === emptyObject) {
     return key;
   }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
+  let result = key;
+  for (const [placeholder, replacement] of Object.entries(placeholders)) {
+    result = result.split(`{${placeholder}}`).join(String(replacement));
+  }
+  return result;
 };
 
 const NoExtensionsFound = 'No extensions found.';
@@ -1309,30 +1706,38 @@ const Enable = 'Enable';
 const Disable = 'Disable';
 const EnableWorkspace = 'Enable Workspace';
 const DisableWorkspace = 'Disable Workspace';
+const Uninstall = 'Uninstall';
+const Install = 'Install';
+const Installing$1 = 'Installing';
+const Uninstalling$1 = 'Uninstalling';
 const InstallAnotherVersion = 'Install Another Version';
 const SearchExtensionsInMarketplace = 'Search Extensions in Marketplace';
 const ViewsAndMoreActions = 'Views and more Actions...';
 const Extensions$2 = 'Extensions';
 const Installed$1 = 'Installed';
+const Marketplace = 'Marketplace';
 const Copy = 'Copy';
 const CopyExtensionId = 'Copy Extension Id';
 const Name = 'Name';
 const Id$1 = 'Id';
 const Description = 'Description';
+const Downloads = 'Downloads';
 const Version = 'Version';
 const Publisher = 'Publisher';
+const Rating = 'Rating';
 const MarketplaceLink = 'Marketplace Link';
 const Category$1 = 'Category';
-const Disabled$1 = 'Disabled';
-const Featured = 'Featured';
-const McpServers = 'MCP Servers';
-const MostPopular = 'Most Popular';
-const RecentlyPublished = 'Recently Published';
-const Recommended = 'Recommended';
+const Disabled$3 = 'Disabled';
+const Featured$1 = 'Featured';
+const McpServers$1 = 'MCP Servers';
+const MostPopular$1 = 'Most Popular';
+const RecentlyPublished$1 = 'Recently Published';
+const Recommended$1 = 'Recommended';
 const Updates = 'Updates';
 const BuiltIn = 'Built-in';
-const Enabled$1 = 'Enabled';
-const WorkspaceUnsupported = 'Workspace Unsupported';
+const Enabled$2 = 'Enabled';
+const WorkspaceUnsupported$1 = 'Workspace Unsupported';
+const Deprecated$1 = 'Deprecated';
 const SortBy = 'Sort By';
 
 const noExtensionsFound = () => {
@@ -1350,9 +1755,15 @@ const version = () => {
 const description = () => {
   return i18nString(Description);
 };
+const downloads = () => {
+  return i18nString(Downloads);
+};
 const publisher = () => {
   return i18nString(Publisher);
 };
+const rating = () => {
+  return i18nString(Rating);
+};
 const marketplaceLink = () => {
   return i18nString(MarketplaceLink);
 };
@@ -1368,10 +1779,10 @@ const extensions = () => {
 const clearExtensionSearchResults = () => {
   return i18nString(ClearExtensionSearchResults);
 };
-const enable$1 = () => {
+const enable$2 = () => {
   return i18nString(Enable);
 };
-const disable$1 = () => {
+const disable$2 = () => {
   return i18nString(Disable);
 };
 const enableWorkspace$1 = () => {
@@ -1380,6 +1791,18 @@ const enableWorkspace$1 = () => {
 const disableWorkspace$1 = () => {
   return i18nString(DisableWorkspace);
 };
+const uninstall$1 = () => {
+  return i18nString(Uninstall);
+};
+const install$1 = () => {
+  return i18nString(Install);
+};
+const installing$1 = () => {
+  return i18nString(Installing$1);
+};
+const uninstalling$1 = () => {
+  return i18nString(Uninstalling$1);
+};
 const installAnotherVersion$1 = () => {
   return i18nString(InstallAnotherVersion);
 };
@@ -1398,26 +1821,29 @@ const viewsAndMoreActions = () => {
 const installed = () => {
   return i18nString(Installed$1);
 };
+const marketplace = () => {
+  return i18nString(Marketplace);
+};
 const category = () => {
   return i18nString(Category$1);
 };
 const disabled = () => {
-  return i18nString(Disabled$1);
+  return i18nString(Disabled$3);
 };
 const featured = () => {
-  return i18nString(Featured);
+  return i18nString(Featured$1);
 };
 const mcpServers = () => {
-  return i18nString(McpServers);
+  return i18nString(McpServers$1);
 };
 const mostPopular = () => {
-  return i18nString(MostPopular);
+  return i18nString(MostPopular$1);
 };
 const recentlyPublished = () => {
-  return i18nString(RecentlyPublished);
+  return i18nString(RecentlyPublished$1);
 };
 const recommended = () => {
-  return i18nString(Recommended);
+  return i18nString(Recommended$1);
 };
 const updates = () => {
   return i18nString(Updates);
@@ -1426,10 +1852,13 @@ const builtIn = () => {
   return i18nString(BuiltIn);
 };
 const enabled = () => {
-  return i18nString(Enabled$1);
+  return i18nString(Enabled$2);
 };
 const workspaceUnsupported = () => {
-  return i18nString(WorkspaceUnsupported);
+  return i18nString(WorkspaceUnsupported$1);
+};
+const deprecated = () => {
+  return i18nString(Deprecated$1);
 };
 const sortBy = () => {
   return i18nString(SortBy);
@@ -1458,6 +1887,12 @@ const HandleTouchStart = 14;
 const HandleWheel = 15;
 const HandleHeaderContextMenu = 16;
 const HandleBlur = 17;
+const HandleInstall = 19;
+const HandleUninstall = 20;
+const HandleEnable = 21;
+const HandleDisable = 22;
+const HandleInputFocus = 23;
+const HandleInputBlur = 24;
 
 const ClearAll = 'ClearAll';
 const Filter = 'Filter';
@@ -1516,15 +1951,22 @@ const getScrollBarY$1 = (delta, finalDelta, size, scrollBarSize) => {
 };
 
 const Installed = '@installed';
-const Enabled = '@enabled';
-const Disabled = '@disabled';
+const Enabled$1 = '@enabled';
+const Disabled$2 = '@disabled';
 const Builtin = '@builtin';
 const Sort = '@sort';
 const Id = '@id';
 const Category = '@category';
 const Outdated = '@outdated';
-
-const RE_PARAM = /@\w+(?::\w+)?/g;
+const Featured = '@featured';
+const McpServers = '@mcpservers';
+const MostPopular = '@most-popular';
+const RecentlyPublished = '@recentlypublished';
+const Recommended = '@recommended';
+const WorkspaceUnsupported = '@workspaceunsupported';
+const Deprecated = '@deprecated';
+
+const RE_PARAM = /@[\w-]+(?::\w+)?/g;
 const deserializeCategory = value => {
   if (value.startsWith(':"') && value.endsWith('"')) {
     return value.slice(2, -1);
@@ -1553,10 +1995,10 @@ const parseValue = value => {
     if (match.startsWith(Installed)) {
       installed = true;
     }
-    if (match.startsWith(Enabled)) {
+    if (match.startsWith(Enabled$1)) {
       enabled = true;
     }
-    if (match.startsWith(Disabled)) {
+    if (match.startsWith(Disabled$2)) {
       disabled = true;
     }
     if (match.startsWith(Builtin)) {
@@ -1680,6 +2122,103 @@ const searchExtensions = async (extensions, value, platform, assetDir) => {
   }
 };
 
+const requestVersions = new Map();
+const requestVersionGenerator = {
+  value: 0
+};
+const getSearchResult = async state => {
+  const {
+    allExtensions,
+    headerHeight,
+    height,
+    itemHeight,
+    minimumSliderSize,
+    searchValue
+  } = state;
+  const value = searchValue.trim();
+  const inputActions = getInputActions(value.length > 0);
+  const items = await searchExtensions(allExtensions, value);
+  if (items.length === 0) {
+    return {
+      deltaY: 0,
+      finalDeltaY: 0,
+      focus: Input,
+      inputActions,
+      items,
+      maxLineY: 0,
+      message: noExtensionsFound(),
+      minLineY: 0,
+      placeholder: searchExtensionsInMarketPlace(),
+      scrollBarHeight: 0
+    };
+  }
+  const total = items.length;
+  const listHeight = getListHeight(total, itemHeight, height - headerHeight);
+  const scrollBarHeight = getScrollBarSize(listHeight, total * itemHeight, minimumSliderSize);
+  const maxLineY = Math.min(getNumberOfVisibleItems$1(listHeight, itemHeight), total);
+  const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, total);
+  const scrollBarY = getScrollBarY$1(0, finalDeltaY, listHeight, scrollBarHeight);
+  return {
+    deltaY: 0,
+    finalDeltaY,
+    focus: state.focus,
+    inputActions,
+    items,
+    maxLineY,
+    message: '',
+    minLineY: 0,
+    placeholder: searchExtensionsInMarketPlace(),
+    scrollBarHeight,
+    scrollBarY
+  };
+};
+const handleChangeWithContext = async (context, update, waitForExtensions = true) => {
+  const {
+    uid
+  } = context.getState();
+  if (waitForExtensions) {
+    await wait(uid);
+  }
+  const requestVersion = ++requestVersionGenerator.value;
+  requestVersions.set(uid, requestVersion);
+  const requestState = {
+    ...context.getState(),
+    ...update,
+    initial: false
+  };
+  try {
+    const result = await getSearchResult(requestState);
+    await context.updateState(state => {
+      if (requestVersions.get(state.uid) !== requestVersion) {
+        return state;
+      }
+      return {
+        ...state,
+        ...update,
+        initial: false,
+        ...result
+      };
+    });
+  } catch (error) {
+    await handleError(error);
+    await context.updateState(state => {
+      if (requestVersions.get(state.uid) !== requestVersion) {
+        return state;
+      }
+      return {
+        ...state,
+        ...update,
+        initial: false,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    });
+  } finally {
+    if (requestVersions.get(uid) === requestVersion) {
+      requestVersions.delete(uid);
+    }
+  }
+};
+
 // TODO debounce
 const handleChange = async (state, update) => {
   const fullNewState = {
@@ -1687,70 +2226,11 @@ const handleChange = async (state, update) => {
     ...update
   };
   try {
-    const value = fullNewState.searchValue.trim();
-    const {
-      inputSource
-    } = fullNewState;
-    const hasValue = value.length > 0;
-    const inputActions = getInputActions(hasValue);
-    const {
-      allExtensions,
-      assetDir,
-      headerHeight,
-      height,
-      itemHeight,
-      minimumSliderSize,
-      platform
-    } = state;
-    // TODO cancel ongoing requests
-    // TODO handle errors
-    const items = await searchExtensions(allExtensions, value, platform, assetDir);
-    if (items.length === 0) {
-      return {
-        ...state,
-        allExtensions,
-        deltaY: 0,
-        finalDeltaY: 0,
-        focus: Input,
-        inputActions,
-        inputSource,
-        items,
-        maxLineY: 0,
-        message: noExtensionsFound(),
-        minLineY: 0,
-        placeholder: searchExtensionsInMarketPlace(),
-        scrollBarHeight: 0,
-        searchValue: value
-      };
-    }
-    const total = items.length;
-    const availableHeight = height - headerHeight;
-    const listHeight = getListHeight(total, itemHeight, availableHeight);
-    const contentHeight = total * itemHeight;
-    const scrollBarHeight = getScrollBarSize(listHeight, contentHeight, minimumSliderSize);
-    const numberOfVisible = getNumberOfVisibleItems$1(listHeight, itemHeight);
-    const maxLineY = Math.min(numberOfVisible, total);
-    const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, total);
-    const scrollBarY = getScrollBarY$1(0, finalDeltaY, listHeight, scrollBarHeight);
+    const result = await getSearchResult(fullNewState);
     return {
-      ...state,
-      allExtensions,
-      deltaY: 0,
-      finalDeltaY,
-      inputActions,
-      inputSource,
-      items,
-      maxLineY,
-      message: '',
-      minLineY: 0,
-      placeholder: searchExtensionsInMarketPlace(),
-      scrollBarHeight,
-      scrollBarY,
-      searchValue: value
+      ...fullNewState,
+      ...result
     };
-
-    // TODO handle out of order responses (a bit complicated)
-    // for now just assume everything comes back in order
   } catch (error) {
     // TODO send error to error worker
     await handleError(error);
@@ -1761,17 +2241,71 @@ const handleChange = async (state, update) => {
   }
 };
 
-const clearSearchResults = state => {
+const User = 1;
+const Script = 2;
+
+const acceptCompletionWithContext = async (context, label) => {
+  const state = context.getState();
+  const completion = label || state.completionItems[state.completionFocusedIndex]?.label;
+  if (!completion) {
+    return;
+  }
+  const range = getCompletionRange(state.searchValue, state.cursorOffset);
+  if (!range) {
+    return;
+  }
+  const searchValue = `${state.searchValue.slice(0, range.start)}${completion}${state.searchValue.slice(range.end)}`;
+  await handleChangeWithContext(context, {
+    completionFocusedIndex: 0,
+    completionItems: [],
+    cursorOffset: range.start + completion.length,
+    focus: Input,
+    inputSource: Script,
+    searchValue,
+    suggestOpen: false
+  });
+};
+const acceptCompletion = async (state, label) => {
+  const completion = label || state.completionItems[state.completionFocusedIndex]?.label;
+  if (!completion) {
+    return state;
+  }
+  const range = getCompletionRange(state.searchValue, state.cursorOffset);
+  if (!range) {
+    return state;
+  }
+  const searchValue = `${state.searchValue.slice(0, range.start)}${completion}${state.searchValue.slice(range.end)}`;
   return handleChange(state, {
-    ...state,
+    completionFocusedIndex: 0,
+    completionItems: [],
+    cursorOffset: range.start + completion.length,
+    focus: Input,
+    inputSource: Script,
+    searchValue,
+    suggestOpen: false
+  });
+};
+
+const clearSearchResultsWithContext = async context => {
+  await handleChangeWithContext(context, {
+    completionFocusedIndex: 0,
+    completionItems: [],
+    cursorOffset: 0,
     focus: Input,
     inputSource: Script$1,
-    searchValue: ''
+    searchValue: '',
+    suggestOpen: false
   });
 };
 
 const closeSuggest = state => {
-  return state;
+  if (!state.suggestOpen) {
+    return state;
+  }
+  return {
+    ...state,
+    suggestOpen: false
+  };
 };
 
 const getFocusedItem = state => {
@@ -1855,14 +2389,18 @@ const {
   getCommandIds,
   registerCommands,
   set: set$1,
+  wrapAsyncCommand,
   wrapCommand,
   wrapGetter
-} = create$1();
+} = create$2();
 
-const create = (id, uri, x, y, width, height, platform, assetDir) => {
+const create = (id, uri, x, y, width, height, platform, assetDir, parentUid) => {
   const state = {
     allExtensions: [],
     assetDir,
+    completionFocusedIndex: 0,
+    completionItems: [],
+    cursorOffset: 0,
     deltaY: 0,
     finalDeltaY: 0,
     focus: 0,
@@ -1881,11 +2419,13 @@ const create = (id, uri, x, y, width, height, platform, assetDir) => {
     minimumSliderSize: 0,
     minLineY: 0,
     negativeMargin: 0,
+    parentUid,
     placeholder: '',
     platform,
     scrollBarActive: false,
     scrollBarHeight: 0,
     scrollBarY: 0,
+    scrollSensitivity: 1,
     searchValue: '',
     size: 0,
     suggestOpen: false,
@@ -1894,29 +2434,31 @@ const create = (id, uri, x, y, width, height, platform, assetDir) => {
     x,
     y
   };
+  create$1(id);
   set$1(id, state, state);
 };
 
-const isEqual$3 = (oldState, newState) => {
-  return oldState.scrollBarHeight === newState.scrollBarHeight && oldState.scrollBarY === newState.scrollBarY && oldState.initial === newState.initial && oldState.deltaY === newState.deltaY;
+const isEqual$4 = (oldState, newState) => {
+  return oldState.cursorOffset === newState.cursorOffset && oldState.scrollBarHeight === newState.scrollBarHeight && oldState.scrollBarY === newState.scrollBarY && oldState.initial === newState.initial && oldState.deltaY === newState.deltaY && oldState.width === newState.width;
 };
 
-const isEqual$2 = (oldState, newState) => {
+const isEqual$3 = (oldState, newState) => {
   if (!newState.focus) {
     return true;
   }
   return oldState.focus === newState.focus && oldState.inputSource === newState.inputSource;
 };
 
-const isEqual$1 = (oldState, newState) => {
-  return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.focusedIndex === newState.focusedIndex && oldState.message === newState.message && oldState.focus === newState.focus && oldState.inputActions === newState.inputActions && oldState.placeholder === newState.placeholder;
+const isEqual$2 = (oldState, newState) => {
+  return oldState.completionFocusedIndex === newState.completionFocusedIndex && oldState.completionItems === newState.completionItems && oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.focusedIndex === newState.focusedIndex && oldState.message === newState.message && oldState.focus === newState.focus && oldState.inputActions === newState.inputActions && oldState.placeholder === newState.placeholder && oldState.suggestOpen === newState.suggestOpen;
 };
 
-const User = 1;
-const Script = 2;
+const isEqual$1 = (oldState, newState) => {
+  return newState.inputSource === User || oldState.searchValue === newState.searchValue;
+};
 
 const isEqual = (oldState, newState) => {
-  return newState.inputSource === User || oldState.searchValue === newState.searchValue;
+  return newState.parentUid === undefined || oldState.searchValue === newState.searchValue;
 };
 
 const RenderHeader = 1;
@@ -1928,15 +2470,16 @@ const RenderSearchValue = 7;
 const RenderFocusContext = 8;
 const RenderIncremental = 9;
 const RenderCss = 10;
+const RenderTitle = 11;
 
-const modules = [isEqual$1, isEqual$2, isEqual, isEqual$2, isEqual$3];
-const numbers = [RenderIncremental, RenderFocus, RenderSearchValue, RenderFocusContext, RenderCss];
+const modules = [isEqual$2, isEqual$3, isEqual$1, isEqual$3, isEqual$4, isEqual];
+const numbers = [RenderIncremental, RenderFocus, RenderSearchValue, RenderFocusContext, RenderCss, RenderTitle];
 
 const diff2 = uid => {
   return diff(uid, modules, numbers);
 };
 
-const disable = async (state, _id) => {
+const disable$1 = async (state, _id) => {
   await confirm('not implemented');
   return state;
 };
@@ -1947,10 +2490,11 @@ const disableWorkspace = async (state, _id) => {
 };
 
 const dispose = uid => {
+  cancel(uid);
   dispose$1(uid);
 };
 
-const enable = async (state, _id) => {
+const enable$1 = async (state, _id) => {
   await confirm('not implemented');
   return state;
 };
@@ -1960,45 +2504,118 @@ const enableWorkspace = async (state, _id) => {
   return state;
 };
 
-// TODO optimize this function to return the minimum number
-// of visible items needed, e.g. when not scrolled 5 items with
-// 20px fill 100px but when scrolled 6 items are needed
-const getNumberOfVisibleItems = (listHeight, itemHeight) => {
-  return Math.ceil(listHeight / itemHeight) + 1;
+const getFuzzyHighlights = (label, query) => {
+  const lowerLabel = label.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  const matchedIndexes = [];
+  let labelIndex = 0;
+  for (const character of lowerQuery) {
+    labelIndex = lowerLabel.indexOf(character, labelIndex);
+    if (labelIndex === -1) {
+      return undefined;
+    }
+    matchedIndexes.push(labelIndex);
+    labelIndex++;
+  }
+  const highlights = [];
+  for (const index of matchedIndexes) {
+    const lastEnd = highlights.at(-1);
+    if (lastEnd === index) {
+      highlights[highlights.length - 1] = index + 1;
+    } else {
+      highlights.push(index, index + 1);
+    }
+  }
+  return highlights;
 };
-const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
-  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
-  return scrollBarOffset;
+
+const Suggestions = ['@builtin', '@category:', '@disabled', '@enabled', '@featured', '@id:', '@installed', '@mcpservers', '@most-popular', '@outdated', '@recentlypublished', '@recommended', '@sort:installs', '@workspaceunsupported'];
+
+const getCompletionItems = (value, cursorOffset) => {
+  const range = getCompletionRange(value, cursorOffset);
+  if (!range) {
+    return [];
+  }
+  const items = [];
+  for (const label of Suggestions) {
+    const highlights = getFuzzyHighlights(label, range.query);
+    if (highlights) {
+      items.push({
+        highlights,
+        label
+      });
+    }
+  }
+  return items;
 };
-const getScrollBarY = getScrollBarOffset;
-const focusIndexScrollDown = (state, index, listHeight, itemHeight, itemsLength) => {
-  const {
-    finalDeltaY,
-    height,
+
+const handleInputWithContext = async (context, value, inputSource = User, cursorOffset = value.length) => {
+  const completionItems = getCompletionItems(value, cursorOffset);
+  await handleChangeWithContext(context, {
+    completionFocusedIndex: 0,
+    completionItems,
+    cursorOffset,
+    focus: Input,
+    inputSource,
+    searchValue: value,
+    suggestOpen: inputSource === User && completionItems.length > 0
+  });
+};
+
+const addFilter = (searchValue, filter) => {
+  const values = searchValue.trim().split(/\s+/);
+  if (values.includes(filter)) {
+    return searchValue;
+  }
+  return `${searchValue.trim()} ${filter}`.trim();
+};
+const filterByMostPopularWithContext = async context => {
+  const {
+    searchValue
+  } = context.getState();
+  const value = addFilter(searchValue, MostPopular);
+  await handleInputWithContext(context, value, Script);
+};
+
+// TODO optimize this function to return the minimum number
+// of visible items needed, e.g. when not scrolled 5 items with
+// 20px fill 100px but when scrolled 6 items are needed
+const getNumberOfVisibleItems = (listHeight, itemHeight) => {
+  return Math.ceil(listHeight / itemHeight) + 1;
+};
+const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
+  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
+  return scrollBarOffset;
+};
+const getScrollBarY = getScrollBarOffset;
+const focusIndexScrollDown = (state, index, listHeight, itemHeight, itemsLength) => {
+  const {
+    finalDeltaY,
     headerHeight,
+    height,
     scrollBarHeight
   } = state;
-  const newMaxLineY = Math.min(index + 1, itemsLength);
   const fittingItems = getNumberOfVisibleItems(listHeight, itemHeight);
-  const newMinLineY = Math.max(newMaxLineY - fittingItems, 0);
-  const newDeltaY = itemsLength < fittingItems ? 0 : newMinLineY * itemHeight - listHeight % itemHeight + itemHeight;
+  const newDeltaY = Math.min(Math.max((index + 1) * itemHeight - listHeight, 0), finalDeltaY);
+  const newMinLineY = Math.floor(newDeltaY / itemHeight);
+  const newMaxLineY = Math.min(newMinLineY + fittingItems, itemsLength);
   const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
   return {
     ...state,
+    deltaY: newDeltaY,
+    focused: true,
     focusedIndex: index,
     listFocusedIndex: index,
-    minLineY: newMinLineY,
     maxLineY: newMaxLineY,
-    focused: true,
-    deltaY: newDeltaY,
+    minLineY: newMinLineY,
     scrollBarY
   };
 };
 const focusIndexScrollUp = (state, index, listHeight, itemHeight, itemsLength) => {
   const {
     finalDeltaY,
-    height,
     headerHeight,
+    height,
     scrollBarHeight
   } = state;
   const newMinLineY = index;
@@ -2008,23 +2625,23 @@ const focusIndexScrollUp = (state, index, listHeight, itemHeight, itemsLength) =
   const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
   return {
     ...state,
+    deltaY: newDeltaY,
+    focused: true,
     focusedIndex: index,
     listFocusedIndex: index,
-    minLineY: newMinLineY,
     maxLineY: newMaxLineY,
-    focused: true,
-    deltaY: newDeltaY,
+    minLineY: newMinLineY,
     scrollBarY
   };
 };
 const focusIndex = (state, index) => {
   const {
-    itemHeight,
-    minLineY,
-    maxLineY,
     headerHeight,
     height,
-    items
+    itemHeight,
+    items,
+    maxLineY,
+    minLineY
   } = state;
   const itemsLength = items.length;
   if (itemsLength === 0) {
@@ -2034,9 +2651,9 @@ const focusIndex = (state, index) => {
   if (index === -1) {
     return {
       ...state,
+      focused: true,
       focusedIndex: -1,
-      listFocusedIndex: -1,
-      focused: true
+      listFocusedIndex: -1
     };
   }
   const listHeight = height - headerHeight;
@@ -2048,9 +2665,9 @@ const focusIndex = (state, index) => {
   }
   return {
     ...state,
+    focused: true,
     focusedIndex: index,
-    listFocusedIndex: index,
-    focused: true
+    listFocusedIndex: index
   };
 };
 const first = () => {
@@ -2063,7 +2680,7 @@ const next = (items, index) => {
   return (index + 1) % items.length;
 };
 const previous = (items, index) => {
-  return index === 0 ? items.length - 1 : index - 1;
+  return (index === 0 ? items.length : index) - 1;
 };
 const focusFirst = state => {
   const firstIndex = first();
@@ -2120,8 +2737,8 @@ const focusPrevious = state => {
 const focusPreviousPage = state => {
   const {
     focusedIndex,
-    minLineY,
-    maxLineY
+    maxLineY,
+    minLineY
   } = state;
   if (focusedIndex === 0 || focusedIndex === -1) {
     return state;
@@ -2145,6 +2762,7 @@ const getActions = () => {
 };
 
 const Enter = 3;
+const Escape = 8;
 const Space = 9;
 const PageUp = 10;
 const PageDown = 11;
@@ -2160,6 +2778,26 @@ const FocusExtensionsInput = 7000;
 
 const getKeyBindings = () => {
   return [{
+    command: 'Extensions.closeSuggest',
+    key: Escape,
+    when: FocusExtensionsInput
+  }, {
+    command: 'Extensions.acceptCompletion',
+    key: Enter,
+    when: FocusExtensionsInput
+  }, {
+    command: 'Extensions.selectPreviousCompletion',
+    key: UpArrow,
+    when: FocusExtensionsInput
+  }, {
+    command: 'Extensions.selectNextCompletion',
+    key: DownArrow,
+    when: FocusExtensionsInput
+  }, {
+    command: 'Extensions.openSuggest',
+    key: CtrlCmd | Space,
+    when: FocusExtensionsInput
+  }, {
     command: 'Extensions.focusFirst',
     key: Home,
     when: FocusExtensions
@@ -2202,19 +2840,45 @@ const getKeyBindings = () => {
   }];
 };
 
+const Disabled$1 = 'disabled';
+const Enabled = 'enabled';
+const Installing = 'installing';
+const NotInstalled = 'not-installed';
+const Uninstalling = 'uninstalling';
+const statuses = [Disabled$1, Enabled, Installing, NotInstalled, Uninstalling];
+const isExtensionStatus = status => {
+  return statuses.includes(status);
+};
+
 const Separator = 1;
 const None$1 = 0;
 const SubMenu = 4;
+const Disabled = 5;
 
-const getMenuEntriesList = () => {
+const nonEnableableStatuses = [Installing, NotInstalled, Uninstalling];
+const getEnablementFlags = (disabled, status) => {
+  if (status && nonEnableableStatuses.includes(status)) {
+    return {
+      disable: Disabled,
+      enable: Disabled
+    };
+  }
+  const isDisabled = status === Disabled$1 || status === undefined && disabled;
+  return {
+    disable: isDisabled ? Disabled : None$1,
+    enable: isDisabled ? None$1 : Disabled
+  };
+};
+const getMenuEntriesList = (builtin, disabled = false, status) => {
+  const enablementFlags = getEnablementFlags(disabled, status);
   return [{
     command: 'SearchExtensions.enable',
-    flags: None$1,
+    flags: enablementFlags.enable,
     id: 'enable',
-    label: enable$1()
+    label: enable$2()
   }, {
     command: 'SearchExtensions.enableWorkspace',
-    flags: None$1,
+    flags: enablementFlags.enable,
     id: 'enableWorkspace',
     label: enableWorkspace$1()
   }, {
@@ -2224,12 +2888,12 @@ const getMenuEntriesList = () => {
     label: ''
   }, {
     command: 'SearchExtensions.disable',
-    flags: None$1,
+    flags: enablementFlags.disable,
     id: 'disable',
-    label: disable$1()
+    label: disable$2()
   }, {
     command: 'SearchExtensions.disableWorkspace',
-    flags: None$1,
+    flags: enablementFlags.disable,
     id: 'disableWorkspace',
     label: disableWorkspace$1()
   }, {
@@ -2239,7 +2903,7 @@ const getMenuEntriesList = () => {
     label: ''
   }, {
     command: 'SearchExtensions.installAnotherVersion',
-    flags: None$1,
+    flags: builtin ? Disabled : None$1,
     id: 'installAnotherVersion',
     label: installAnotherVersion$1()
   }, {
@@ -2267,7 +2931,7 @@ const getMenuEntriesFilter = () => {
     id: 'filterByMcpServers',
     label: mcpServers()
   }, {
-    command: 'SearchExtensions.filterByMostPopular',
+    command: 'Extensions.filterByMostPopular',
     flags: None$1,
     id: 'filterByMostPopular',
     label: mostPopular()
@@ -2342,7 +3006,7 @@ const getMenuEntries2 = (state, props) => {
     case ExtensionSearchFilter:
       return getMenuEntriesFilter();
     default:
-      return getMenuEntriesList();
+      return getMenuEntriesList(props.builtin, props.disabled, props.status);
   }
 };
 
@@ -2353,7 +3017,8 @@ const getMenuIds = () => {
 const handleBlur = state => {
   return {
     ...state,
-    focus: None$2
+    focus: None$2,
+    suggestOpen: false
   };
 };
 
@@ -2365,6 +3030,13 @@ const openUri = async uri => {
   return openUri$1(uri);
 };
 
+const selectIndex = (state, index) => {
+  return {
+    ...state,
+    focusedIndex: index
+  };
+};
+
 const handleClick = async (state, index) => {
   const {
     items,
@@ -2381,7 +3053,7 @@ const handleClick = async (state, index) => {
   const extension = items[actualIndex];
   const uri = getExtensionDetailUri(extension.id);
   await openUri(uri);
-  const partialNewState = focusIndex(state, actualIndex);
+  const partialNewState = selectIndex(state, actualIndex);
   const newState = {
     ...partialNewState,
     focus: List$2
@@ -2401,6 +3073,8 @@ const text = data => {
   };
 };
 
+new Set(Object.values(VirtualDomElements));
+
 const SetText = 1;
 const Replace = 2;
 const SetAttribute = 3;
@@ -2669,7 +3343,20 @@ const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight, headerHeight) =>
   return index;
 };
 
-const handleClickAt = async (state, button, eventX, eventY) => {
+const handleCompletionPointerDown = (state, label) => {
+  if (state.completionItems.every(item => item.label !== label)) {
+    return Promise.resolve(state);
+  }
+  return acceptCompletion(state, label);
+};
+
+const handleClickAt = async (state, button, eventX, eventY, name = '') => {
+  if (name.startsWith('@')) {
+    return handleCompletionPointerDown(state, name);
+  }
+  if (name) {
+    return state;
+  }
   if (button !== LeftClick) {
     return state;
   }
@@ -2735,22 +3422,48 @@ const handleContextMenu = async (state, button, eventX, eventY) => {
     return state;
   }
   await show2(uid, ManageExtension, eventX, eventY, {
-    menuId: ManageExtension
+    builtin: items[index]?.builtin === true,
+    disabled: items[index]?.disabled === true,
+    menuId: ManageExtension,
+    status: items[index]?.status
   });
   return state;
 };
 
-const handleDisable = (state, id) => {
-  return state;
-  // TODO
+const updateStatus = (extension, id, status, builtin) => {
+  if (extension.id !== id) {
+    return extension;
+  }
+  return {
+    ...extension,
+    builtin: builtin ?? extension.builtin,
+    disabled: status === Disabled$1,
+    status
+  };
+};
+const setExtensionStatus = (state, id, status, builtin) => {
+  if (!isExtensionStatus(status)) {
+    throw new TypeError(`Invalid extension status: ${status}`);
+  }
+  return {
+    ...state,
+    allExtensions: state.allExtensions.map(extension => updateStatus(extension, id, status, builtin)),
+    items: state.items.map(extension => updateStatus(extension, id, status, builtin))
+  };
+};
+
+const handleDisable = async (state, id) => {
+  const error = await disableExtension(id);
+  return error ? state : setExtensionStatus(state, id, Disabled$1);
 };
 
 const handleDisableWorkspace = (state, id) => {
   return state;
 };
 
-const handleEnable = (state, id) => {
-  return state;
+const handleEnable = async (state, id) => {
+  const error = await enableExtension(id);
+  return error ? state : setExtensionStatus(state, id, Enabled);
 };
 
 const handleEnableWorkspace = (state, id) => {
@@ -2768,17 +3481,16 @@ const handleHeaderContextMenu = async state => {
   return state;
 };
 
-const handleInput = async (state, value, inputSource = User) => {
-  return handleChange(state, {
-    inputSource,
-    searchValue: value
-  });
+const handleInputFocus = state => {
+  return {
+    ...state,
+    focus: Input
+  };
 };
 
-// TODO show error / warning  when installment fails / times out
 const handleInstall = async (state, id) => {
-  return state;
-  // TODO
+  await installExtension(id);
+  return setExtensionStatus(state, id, Enabled);
 };
 
 const handleScrollBarCaptureLost = state => {
@@ -2934,20 +3646,28 @@ const handleSettingsButtonClick = async (state, index) => {
   const menuY = itemY + itemHeight - 10; // Position at the bottom of the extension item
 
   await show2(uid, ManageExtension, menuX, menuY, {
-    menuId: ManageExtension
+    builtin: items[actualIndex].builtin === true,
+    disabled: items[actualIndex].disabled === true,
+    menuId: ManageExtension,
+    status: items[actualIndex].status
   });
   return state;
 };
 
-// TODO show error / warning  when installment fails / times out
 const handleUninstall = async (state, id) => {
-  return state;
+  try {
+    await uninstallExtension(id);
+    return setExtensionStatus(state, id, NotInstalled);
+  } catch (error) {
+    await showErrorDialog(error);
+    return state;
+  }
 };
 
 const handleWheel = (state, deltaMode, deltaY) => {
   number(deltaMode);
   number(deltaY);
-  return setDeltaY(state, state.deltaY + deltaY);
+  return setDeltaY(state, state.deltaY + deltaY * state.scrollSensitivity);
 };
 
 const sendMessagePortToExtensionHostWorker = async port => {
@@ -2956,7 +3676,7 @@ const sendMessagePortToExtensionHostWorker = async port => {
 
 const createExtensionHostWorkerRpc = async () => {
   try {
-    const rpc = await create$4({
+    const rpc = await create$5({
       commandMap: {},
       send: sendMessagePortToExtensionHostWorker
     });
@@ -2978,7 +3698,7 @@ const initializeExtensionHostWorker = async () => {
 
 const createExtensionManagementWorkerRpc = async () => {
   try {
-    const rpc = await create$4({
+    const rpc = await create$5({
       commandMap: {},
       send: port => sendMessagePortToExtensionManagementWorker(port, 0)
     });
@@ -3041,6 +3761,11 @@ const getViewletSize = width => {
   return Large;
 };
 
+const getIsFirefox = () => {
+  const globalWithNavigator = globalThis;
+  return globalWithNavigator.navigator?.userAgent.toLowerCase().includes('firefox') ?? false;
+};
+
 const getRemoteUrl = (extension, platform, assetDir) => {
   if (platform === Remote || platform === Electron) {
     if (extension.builtin) {
@@ -3086,6 +3811,37 @@ const getExtensionIcon = (extension, platform, assetDir) => {
   return getRemoteUrl(extension, platform, assetDir);
 };
 
+const getDownloadCountValue = extension => {
+  return extension?.downloadCount ?? extension?.downloads ?? extension?.marketplace?.downloadCount ?? extension?.marketplace?.downloads ?? extension?.packageJSON?.downloadCount ?? extension?.packageJSON?.downloads;
+};
+const getDownloadCount = extension => {
+  const downloadCount = getDownloadCountValue(extension);
+  if (typeof downloadCount !== 'number') {
+    return 'n/a';
+  }
+  return downloadCount.toLocaleString();
+};
+
+const getRatingValue = extension => {
+  return extension?.rating ?? extension?.averageRating ?? extension?.marketplace?.rating ?? extension?.marketplace?.averageRating ?? extension?.packageJSON?.rating ?? extension?.packageJSON?.averageRating;
+};
+const getRating = extension => {
+  const rating = getRatingValue(extension);
+  if (typeof rating !== 'number') {
+    return 'n/a';
+  }
+  return rating.toFixed(1);
+};
+
+const getBuiltin = extension => {
+  return extension?.builtin === true;
+};
+const getDisabled = extension => {
+  return extension?.disabled === true;
+};
+const getStatus = extension => {
+  return typeof extension?.status === 'string' ? extension.status : undefined;
+};
 const getIcon = (extension, platform, assetDir) => {
   return getExtensionIcon(extension, platform, assetDir);
 };
@@ -3149,13 +3905,18 @@ const getPublisher = extension => {
 
 const normalizeExtension = (extension, platform, assetDir) => {
   return {
+    builtin: getBuiltin(extension),
     categories: getCategories(extension),
     description: getDescription(extension),
+    disabled: getDisabled(extension),
+    downloadCount: getDownloadCount(extension),
     icon: getIcon(extension, platform, assetDir),
     id: getId$1(extension),
     name: getName(extension),
     publisher: getPublisher(extension),
+    rating: getRating(extension),
     size: getSize(extension),
+    status: getStatus(extension),
     updatedDate: getUpdatedDate(extension),
     uri: ''
   };
@@ -3187,44 +3948,78 @@ const restoreState = savedState => {
   };
 };
 
-const loadContent = async (state, savedState) => {
-  const {
-    assetDir,
-    platform,
-    width
-  } = state;
+const loadContentWithContext = async (context, savedState) => {
   const {
-    deltaY,
-    searchValue
-  } = restoreState(savedState);
-  // TODO just get local extensions on demand (not when query string is already different)
-  const allExtensions = await getAllExtensions(platform);
-  const size = getViewletSize(width);
-  const normalized = normalizeExtensions(allExtensions, platform, assetDir);
-  const updatedState = await handleInput({
-    ...state,
-    allExtensions: normalized,
-    deltaY,
-    initial: false,
-    inputSource: Script,
-    size
-  }, searchValue, Script);
-  return updatedState;
+    uid
+  } = context.getState();
+  const loadToken = getToken(uid);
+  try {
+    const initialState = context.getState();
+    const {
+      assetDir,
+      platform,
+      width
+    } = initialState;
+    const {
+      deltaY,
+      searchValue: restoredSearchValue
+    } = restoreState(savedState);
+    const size = getViewletSize(width);
+    const scrollSensitivity = getIsFirefox() ? 2.5 : 1;
+    await context.updateState(state => {
+      if (!state.initial) {
+        return state;
+      }
+      return {
+        ...state,
+        deltaY,
+        initial: false,
+        inputSource: Script,
+        scrollSensitivity,
+        searchValue: restoredSearchValue,
+        size
+      };
+    });
+    const allExtensions = await getAllExtensions(platform);
+    const normalized = normalizeExtensions(allExtensions, platform, assetDir);
+    await context.updateState(state => ({
+      ...state,
+      allExtensions: normalized
+    }));
+    await handleChangeWithContext(context, {}, false);
+  } finally {
+    finish(uid, loadToken);
+  }
 };
 
 const openSuggest = state => {
-  return state;
+  const completionItems = getCompletionItems(state.searchValue, state.cursorOffset);
+  if (completionItems.length === 0) {
+    return state;
+  }
+  return {
+    ...state,
+    completionFocusedIndex: 0,
+    completionItems,
+    suggestOpen: true
+  };
 };
 
 const getCss = state => {
   const {
+    cursorOffset,
     deltaY,
+    headerHeight,
     itemHeight,
     scrollBarHeight,
-    scrollBarY
+    scrollBarY,
+    width
   } = state;
   const relative = -(deltaY % itemHeight);
   const roundedScrollBarY = Math.round(scrollBarY);
+  const maximumCompletionLeft = Math.max(8, width - 168);
+  const completionLeft = Math.min(Math.round(8 + cursorOffset * 7.5), maximumCompletionLeft);
+  const completionTop = Math.max(0, headerHeight - 10);
   return `.Extensions .ScrollBarThumb {
   height: ${scrollBarHeight}px;
   translate: 0 ${roundedScrollBarY}px;
@@ -3247,6 +4042,79 @@ const getCss = state => {
   gap: 0;
   overflow-y: hidden;
 }
+
+.ExtensionHeader {
+  contain: layout style;
+  position: relative;
+  z-index: 1;
+}
+
+.ExtensionListItemFooter {
+  justify-content: flex-end;
+  padding-right: 2px;
+}
+
+.ExtensionListItemAuthorName {
+  flex: 1;
+}
+
+.ExtensionActions {
+  display: flex;
+  gap: 6px;
+}
+
+.ExtensionActionButton {
+  padding: 0 5px;
+}
+
+.ExtensionSearchCompletionWidget {
+  position: absolute;
+  left: ${completionLeft}px;
+  top: ${completionTop}px;
+  width: min(320px, calc(100% - ${completionLeft + 8}px));
+  max-height: 240px;
+  overflow-y: auto;
+  z-index: 10;
+  box-sizing: border-box;
+  border: 1px solid var(--CompletionListBorder, #95a29d);
+  background: var(--CompletionListBackground, #282e2f);
+  color: var(--CompletionListForeground, white);
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.36);
+  font-size: 13px;
+  line-height: 20px;
+  user-select: none;
+}
+
+.ExtensionSearchCompletionItem {
+  display: block;
+  width: 100%;
+  min-height: 20px;
+  padding: 0 6px;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  line-height: inherit;
+  text-align: left;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  cursor: pointer;
+}
+
+.ExtensionSearchCompletionItem:hover {
+  background: var(--CompletionListItemHoverBackground, rgba(64, 92, 80, 0.2));
+}
+
+.ExtensionSearchCompletionItemFocused {
+  background: var(--CompletionListItemActiveBackground, #405c50);
+  color: var(--CompletionListItemActiveForeground);
+}
+
+.ExtensionSearchCompletionHighlight {
+  color: var(--CompletionHighlightForeground, #e1b974);
+  font-weight: 700;
+}
 `;
 };
 
@@ -3295,21 +4163,39 @@ const renderFocusContext = newState => {
   return [];
 };
 
+const ComboBox = 'combobox';
+const List$1 = 'list';
+const ListBox = 'listbox';
+const ListItem = 'listitem';
+const None = 'none';
+const Option = 'option';
+const ToolBar = 'toolbar';
+
 const Actions = 'Actions';
 const ExtensionActions = 'ExtensionActions';
+const ExtensionActionButton = 'ExtensionActionButton';
 const ExtensionActive = 'ExtensionActive';
 const ExtensionHeader = 'ExtensionHeader';
 const ExtensionListItem = 'ExtensionListItem';
+const ExtensionListItemActionInstall = 'ExtensionListItemActionInstall';
 const ExtensionListItemAuthorName = 'ExtensionListItemAuthorName';
 const ExtensionListItemDescription = 'ExtensionListItemDescription';
 const ExtensionListItemDetail = 'ExtensionListItemDetail';
+const ExtensionListItemDownloadCount = 'ExtensionListItemDownloadCount';
 const ExtensionListItemFooter = 'ExtensionListItemFooter';
 const ExtensionListItemIcon = 'ExtensionListItemIcon';
+const ExtensionListItemMetadata = 'ExtensionListItemMetadata';
 const ExtensionListItemName = 'ExtensionListItemName';
+const ExtensionListItemRating = 'ExtensionListItemRating';
+const ExtensionListItemStatistic = 'ExtensionListItemStatistic';
+const ExtensionSearchCompletionHighlight = 'ExtensionSearchCompletionHighlight';
+const ExtensionSearchCompletionItem = 'ExtensionSearchCompletionItem';
+const ExtensionSearchCompletionItemFocused = 'ExtensionSearchCompletionItemFocused';
+const ExtensionSearchCompletionWidget = 'ExtensionSearchCompletionWidget';
 const Extensions = 'Extensions';
 const FocusOutline = 'FocusOutline';
 const IconButton = 'IconButton';
-const List$1 = 'List';
+const List = 'List';
 const ListItems = 'ListItems';
 const MaskIcon = 'MaskIcon';
 const MultilineInputBox = 'MultilineInputBox';
@@ -3325,10 +4211,73 @@ const SearchFieldButtons = 'SearchFieldButtons';
 const SearchFieldContainer = 'SearchFieldContainer';
 const Viewlet = 'Viewlet';
 
-const List = 'list';
-const ListItem = 'listitem';
-const None = 'none';
-const ToolBar = 'toolbar';
+const getCompletionLabelVirtualDom = (label, highlights) => {
+  const dom = [];
+  let position = 0;
+  for (let i = 0; i < highlights.length; i += 2) {
+    const start = highlights[i];
+    const end = highlights[i + 1];
+    if (position < start) {
+      dom.push(text(label.slice(position, start)));
+    }
+    dom.push({
+      childCount: 1,
+      className: ExtensionSearchCompletionHighlight,
+      name: label,
+      type: Span
+    }, text(label.slice(start, end)));
+    position = end;
+  }
+  if (position < label.length) {
+    dom.push(text(label.slice(position)));
+  }
+  return dom;
+};
+
+const getRootNodeCount = nodes => {
+  let count = 0;
+  const remainingChildCounts = [];
+  for (const node of nodes) {
+    while (remainingChildCounts.length > 0 && remainingChildCounts.at(-1) === 0) {
+      remainingChildCounts.pop();
+    }
+    if (remainingChildCounts.length === 0) {
+      count++;
+    } else {
+      const lastIndex = remainingChildCounts.length - 1;
+      remainingChildCounts[lastIndex]--;
+    }
+    remainingChildCounts.push(node.childCount);
+  }
+  return count;
+};
+const getCompletionItemVirtualDom = (item, index, focusedIndex) => {
+  const labelDom = getCompletionLabelVirtualDom(item.label, item.highlights);
+  const focused = index === focusedIndex;
+  return [{
+    ariaSelected: focused,
+    childCount: getRootNodeCount(labelDom),
+    className: focused ? mergeClassNames(ExtensionSearchCompletionItem, ExtensionSearchCompletionItemFocused) : ExtensionSearchCompletionItem,
+    id: `ExtensionSearchCompletion-${index}`,
+    name: item.label,
+    onPointerDown: HandlePointerDown,
+    role: Option,
+    type: Button$2
+  }, ...labelDom];
+};
+
+const getCompletionWidgetVirtualDom = (items, focusedIndex) => {
+  return [{
+    ariaLabel: 'Extension search completions',
+    childCount: items.length,
+    className: ExtensionSearchCompletionWidget,
+    id: 'ExtensionSearchCompletions',
+    role: ListBox,
+    type: Div
+  }, ...items.flatMap((item, index) => getCompletionItemVirtualDom(item, index, focusedIndex))];
+};
+
+const Focusable = 0;
 
 const disabledClassName = mergeClassNames(SearchFieldButton, SearchFieldButtonDisabled);
 const getClassName$1 = enabled => {
@@ -3348,7 +4297,7 @@ const getSearchFieldButtonVirtualDom = button => {
     childCount: 1,
     className: getClassName$1(enabled),
     onClick,
-    tabIndex: 0,
+    tabIndex: Focusable,
     title,
     type: Button$2
   }, {
@@ -3358,14 +4307,15 @@ const getSearchFieldButtonVirtualDom = button => {
   }];
 };
 
-const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, onFocus = '') => {
+const searchFieldNode = {
+  childCount: 2,
+  className: SearchField,
+  role: None,
+  type: Div
+};
+const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, onFocus = '', onBlur = '', inputProperties = {}) => {
   // TODO avoid mutation
-  const dom = [{
-    childCount: 2,
-    className: SearchField,
-    role: None,
-    type: Div
-  }, {
+  const dom = [searchFieldNode, {
     autocapitalize: 'off',
     autocomplete: 'off',
     autocorrect: 'off',
@@ -3373,11 +4323,15 @@ const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, out
     className: MultilineInputBox,
     inputType: 'search',
     name,
+    ...(onBlur && {
+      onBlur
+    }),
     onFocus,
     onInput,
     placeholder,
     spellcheck: false,
-    type: Input$1
+    type: Input$1,
+    ...inputProperties
   }, {
     childCount: insideButtons.length,
     className: SearchFieldButtons,
@@ -3395,24 +4349,117 @@ const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, out
   return dom;
 };
 
-const parentNode = {
-  childCount: 1,
-  className: ExtensionHeader,
-  onContextMenu: HandleHeaderContextMenu,
-  type: Div
-};
-const getExtensionHeaderVirtualDom = (placeholder, actions) => {
-  return [parentNode, ...getSearchFieldVirtualDom(Extensions$1, placeholder, HandleExtensionsInput, actions, [])];
+const getExtensionHeaderVirtualDom = (placeholder, actions, completionItems = [], completionFocusedIndex = 0, suggestOpen = false) => {
+  const inputProperties = suggestOpen ? {
+    ariaActivedescendant: `ExtensionSearchCompletion-${completionFocusedIndex}`,
+    ariaAutoComplete: 'list',
+    ariaControls: 'ExtensionSearchCompletions',
+    ariaExpanded: true,
+    role: ComboBox
+  } : {
+    ariaAutoComplete: 'list',
+    ariaExpanded: false,
+    role: ComboBox
+  };
+  return [{
+    childCount: suggestOpen ? 2 : 1,
+    className: ExtensionHeader,
+    onContextMenu: HandleHeaderContextMenu,
+    type: Div
+  }, ...getSearchFieldVirtualDom(Extensions$1, placeholder, HandleExtensionsInput, actions, [], HandleInputFocus, HandleInputBlur, inputProperties), ...(suggestOpen ? getCompletionWidgetVirtualDom(completionItems, completionFocusedIndex) : [])];
 };
 
 const renderHeader = newState => {
   const actions = getInputActions(newState.searchValue.length > 0);
-  const dom = getExtensionHeaderVirtualDom(newState.placeholder, actions);
+  const dom = getExtensionHeaderVirtualDom(newState.placeholder, actions, newState.completionItems, newState.completionFocusedIndex, newState.suggestOpen);
   return ['setHeaderDom', dom];
 };
 
 const Extension = 'Extension';
 
+const install = {
+  disabled: false,
+  label: install$1(),
+  onClick: HandleInstall
+};
+const installing = {
+  disabled: true,
+  label: installing$1(),
+  onClick: HandleInstall
+};
+const enable = {
+  disabled: false,
+  label: enable$2(),
+  onClick: HandleEnable
+};
+const disable = {
+  disabled: false,
+  label: disable$2(),
+  onClick: HandleDisable
+};
+const uninstall = {
+  disabled: false,
+  label: uninstall$1(),
+  onClick: HandleUninstall
+};
+const uninstalling = {
+  disabled: true,
+  label: uninstalling$1(),
+  onClick: HandleUninstall
+};
+const getExtensionActions = (builtin, disabled, status) => {
+  if (status === NotInstalled) {
+    return [install];
+  }
+  if (status === Installing) {
+    return [installing];
+  }
+  if (status === Uninstalling) {
+    return builtin ? [] : [uninstalling];
+  }
+  const enableOrDisable = status === Disabled$1 || status === undefined && disabled ? enable : disable;
+  return builtin ? [enableOrDisable] : [enableOrDisable, uninstall];
+};
+
+const className = mergeClassNames(ExtensionListItemActionInstall, ExtensionActionButton);
+const getActionVirtualDom$1 = (action, id) => {
+  return [{
+    childCount: 1,
+    className,
+    disabled: action.disabled,
+    name: id,
+    onClick: action.onClick,
+    type: Button$2
+  }, text(action.label)];
+};
+const getExtensionActionsVirtualDom = (id, builtin, disabled, status) => {
+  const actions = getExtensionActions(builtin, disabled, status);
+  return [{
+    childCount: actions.length,
+    className: ExtensionActions,
+    type: Div
+  }, ...actions.flatMap(action => getActionVirtualDom$1(action, id))];
+};
+
+const extensionListItemMetadataNode = {
+  childCount: 2,
+  className: ExtensionListItemMetadata,
+  type: Div
+};
+const getStatisticVirtualDom = (label, value, className) => {
+  const accessibleLabel = `${label}: ${value}`;
+  return [{
+    ariaLabel: accessibleLabel,
+    childCount: 1,
+    className: mergeClassNames(ExtensionListItemStatistic, className),
+    title: accessibleLabel,
+    type: Span
+  }, text(value)];
+};
+const getExtensionStatisticsVirtualDom = (downloadCount, rating$1) => {
+  return [extensionListItemMetadataNode, ...getStatisticVirtualDom(downloads(), downloadCount, ExtensionListItemDownloadCount), ...getStatisticVirtualDom(rating(), rating$1, ExtensionListItemRating)];
+};
+
 const listItemDetail = {
   childCount: 3,
   className: ExtensionListItemDetail,
@@ -3429,7 +4476,7 @@ const listItemDescription = {
   type: Div
 };
 const listItemFooter = {
-  childCount: 2,
+  childCount: 3,
   className: ExtensionListItemFooter,
   type: Div
 };
@@ -3452,14 +4499,21 @@ const getId = focused => {
 };
 const getExtensionListItemVirtualDom = extension => {
   const {
+    builtin = false,
     description,
+    disabled = false,
+    downloadCount = 'n/a',
     focused,
     icon,
+    id,
     name,
     posInSet,
     publisher,
-    setSize
+    rating = 'n/a',
+    setSize,
+    status
   } = extension;
+  const actionsDom = getExtensionActionsVirtualDom(id, builtin, disabled, status);
   const dom = [{
     ariaPosInSet: posInSet,
     ariaRoleDescription: Extension,
@@ -3475,11 +4529,7 @@ const getExtensionListItemVirtualDom = extension => {
     role: None,
     src: icon,
     type: Img
-  }, listItemDetail, listItemName, text(name), listItemDescription, text(description), listItemFooter, listItemAuthorName, text(publisher), {
-    childCount: 0,
-    className: ExtensionActions,
-    type: Div
-  }];
+  }, listItemDetail, listItemName, text(name), listItemDescription, text(description), listItemFooter, listItemAuthorName, text(publisher), ...getExtensionStatisticsVirtualDom(downloadCount, rating), ...actionsDom];
   return dom;
 };
 
@@ -3498,8 +4548,8 @@ const getExtensionsListVirtualDom = (visibleExtensions, focusOutline) => {
     onTouchMove: HandleTouchMove,
     onTouchStart: HandleTouchStart,
     onWheel: HandleWheel,
-    role: List,
-    tabIndex: 0,
+    role: List$1,
+    tabIndex: Focusable,
     type: Div
   }, ...visibleExtensions.flatMap(getExtensionListItemVirtualDom)];
   return dom;
@@ -3511,14 +4561,20 @@ const getExtensionsVirtualDom = (visibleExtensions, focusOutline) => {
   return dom;
 };
 
+const noExtensionsFoundNode = {
+  childCount: 1,
+  className: NoExtensionsFoundMessage,
+  type: Div
+};
 const getNoExtensionsFoundVirtualDom = message => {
-  return [{
-    childCount: 1,
-    className: NoExtensionsFoundMessage,
-    type: Div
-  }, text(message)];
+  return [noExtensionsFoundNode, text(message)];
 };
 
+const scrollBarThumbNode = {
+  childCount: 0,
+  className: ScrollBarThumb,
+  type: Div
+};
 const getScrollBarVirtualDom = (scrollBarHeight, scrollBarTop) => {
   const shouldShowScrollbar = scrollBarHeight > 0;
   if (!shouldShowScrollbar) {
@@ -3530,24 +4586,28 @@ const getScrollBarVirtualDom = (scrollBarHeight, scrollBarTop) => {
     onPointerDown: HandleScrollBarPointerDown,
     // TODO support pointercapture event
     type: Div
-  }, {
-    childCount: 0,
-    className: ScrollBarThumb,
-    type: Div
-  }];
+  }, scrollBarThumbNode];
 };
 
 const getVisibleItem = (item, setSize, itemHeight, minLineY, relative, i, focusedIndex) => {
   // TODO use normal parameters
   const {
+    builtin,
     description,
+    disabled,
+    downloadCount,
     icon,
     id,
     name,
-    publisher
+    publisher,
+    rating,
+    status
   } = item;
   return {
+    builtin,
     description,
+    disabled,
+    downloadCount,
     focused: i === focusedIndex,
     icon,
     id,
@@ -3555,7 +4615,9 @@ const getVisibleItem = (item, setSize, itemHeight, minLineY, relative, i, focuse
     name,
     posInSet: i + 1,
     publisher,
+    rating,
     setSize,
+    status,
     top: (i - minLineY) * itemHeight - relative
   };
 };
@@ -3585,21 +4647,25 @@ const getContentVirtualDom = (visibleExtensions, message, scrollBarHeight, scrol
   }
   return [{
     childCount: 2,
-    className: mergeClassNames(Viewlet, List$1),
+    className: mergeClassNames(Viewlet, List),
     type: Div
   }, ...getExtensionsVirtualDom(visibleExtensions, focusOutline), ...getScrollBarVirtualDom(scrollBarHeight)];
 };
 const getExtensionsViewVirtualDom = state => {
   const visibleExtensions = getVisible(state);
   const {
+    completionFocusedIndex,
+    completionItems,
+    focus,
     focusedIndex,
     inputActions,
     message,
     placeholder,
     scrollBarHeight,
-    scrollBarY
+    scrollBarY,
+    suggestOpen
   } = state;
-  const focusOutline = focusedIndex === -1 && state.focus === List$2;
+  const focusOutline = focusedIndex === -1 && focus === List$2;
   return [{
     ariaBusy: false,
     ariaLive: 'polite',
@@ -3607,7 +4673,7 @@ const getExtensionsViewVirtualDom = state => {
     className: mergeClassNames(Viewlet, Extensions),
     role: None$3,
     type: Div
-  }, ...getExtensionHeaderVirtualDom(placeholder, inputActions), ...getContentVirtualDom(visibleExtensions, message, scrollBarHeight, scrollBarY, focusOutline)];
+  }, ...getExtensionHeaderVirtualDom(placeholder, inputActions, completionItems, completionFocusedIndex, suggestOpen), ...getContentVirtualDom(visibleExtensions, message, scrollBarHeight, scrollBarY, focusOutline)];
 };
 
 const renderItems2 = newState => {
@@ -3654,10 +4720,7 @@ const renderScrollBar = newState => {
   const roundedScrollBarY = Math.round(scrollBarY);
   const heightString = px(scrollBarHeight);
   const translateString = position(0, roundedScrollBarY);
-  let className = ScrollBarThumb;
-  if (newState.scrollBarActive) {
-    className += ' ' + ScrollBarThumbActive;
-  }
+  const className = mergeClassNames(ScrollBarThumb, newState.scrollBarActive ? ScrollBarThumbActive : '');
   return [/* method */SetScrollBar, translateString, heightString, className];
 };
 
@@ -3665,6 +4728,66 @@ const renderSearchValue = newState => {
   return [/* method */'Viewlet.setValueByName', newState.uid, Extensions$1, newState.searchValue];
 };
 
+const titleFilters = [{
+  label: deprecated,
+  value: Deprecated
+}, {
+  label: installed,
+  value: Installed
+}, {
+  label: enabled,
+  value: Enabled$1
+}, {
+  label: disabled,
+  value: Disabled$2
+}, {
+  label: builtIn,
+  value: Builtin
+}, {
+  label: updates,
+  value: Outdated
+}, {
+  label: featured,
+  value: Featured
+}, {
+  label: mcpServers,
+  value: McpServers
+}, {
+  label: mostPopular,
+  value: MostPopular
+}, {
+  label: recentlyPublished,
+  value: RecentlyPublished
+}, {
+  label: recommended,
+  value: Recommended
+}, {
+  label: workspaceUnsupported,
+  value: WorkspaceUnsupported
+}];
+const getTitleSuffix = searchValue => {
+  if (!searchValue.trim()) {
+    return installed();
+  }
+  const normalizedSearchValue = searchValue.toLowerCase();
+  for (const filter of titleFilters) {
+    if (normalizedSearchValue.includes(filter.value)) {
+      return filter.label();
+    }
+  }
+  return marketplace();
+};
+const renderTitle = state => {
+  return `${extensions()}: ${getTitleSuffix(state.searchValue)}`;
+};
+
+const renderTitleCommand = newState => {
+  if (newState.parentUid === undefined) {
+    return [];
+  }
+  return ['Viewlet.send', newState.parentUid, 'setTitle', renderTitle(newState)];
+};
+
 const getRenderer = diffType => {
   switch (diffType) {
     case RenderCss:
@@ -3685,6 +4808,8 @@ const getRenderer = diffType => {
       return renderScrollBar;
     case RenderSearchValue:
       return renderSearchValue;
+    case RenderTitle:
+      return renderTitleCommand;
     default:
       throw new Error('unknown renderer');
   }
@@ -3773,7 +4898,7 @@ const renderEventListeners = () => {
     preventDefault: true
   }, {
     name: HandlePointerDown,
-    params: ['handleClickAt', Button$1, ClientX, ClientY],
+    params: ['handleClickAt', Button$1, ClientX, ClientY, TargetName],
     preventDefault: true
   }, {
     name: HandleScrollBarPointerDown,
@@ -3792,7 +4917,7 @@ const renderEventListeners = () => {
     passive: true
   }, {
     name: HandleExtensionsInput,
-    params: ['handleInput', TargetValue, User]
+    params: ['handleInput', TargetValue, User, TargetSelectionStart]
   }, {
     name: HandleClearSearchResults,
     params: ['clearSearchResults']
@@ -3805,6 +4930,24 @@ const renderEventListeners = () => {
   }, {
     name: HandleBlur,
     params: ['handleBlur']
+  }, {
+    name: HandleInstall,
+    params: ['handleInstall', TargetName]
+  }, {
+    name: HandleUninstall,
+    params: ['handleUninstall', TargetName]
+  }, {
+    name: HandleEnable,
+    params: ['handleEnable', TargetName]
+  }, {
+    name: HandleDisable,
+    params: ['handleDisable', TargetName]
+  }, {
+    name: HandleInputFocus,
+    params: ['handleInputFocus']
+  }, {
+    name: HandleInputBlur,
+    params: ['handleBlur']
   }];
 };
 
@@ -3868,34 +5011,46 @@ const scrollDown = state => {
   return setDeltaY(state, newDeltaY);
 };
 
-const selectIndex = (state, index) => {
+const selectNextCompletion = state => {
+  if (!state.suggestOpen || state.completionItems.length === 0) {
+    return state;
+  }
   return {
     ...state,
-    focusedIndex: index
+    completionFocusedIndex: (state.completionFocusedIndex + 1) % state.completionItems.length
   };
 };
 
-const toggleSuggest = state => {
+const selectPreviousCompletion = state => {
+  if (!state.suggestOpen || state.completionItems.length === 0) {
+    return state;
+  }
   return {
     ...state,
-    suggestOpen: !state.suggestOpen
+    completionFocusedIndex: (state.completionFocusedIndex - 1 + state.completionItems.length) % state.completionItems.length
   };
 };
 
+const toggleSuggest = state => {
+  return state.suggestOpen ? closeSuggest(state) : openSuggest(state);
+};
+
 const commandMap = {
   'Extensions.copyExtensionId': wrapCommand(copyExtensionId),
   'Extensions.copyExtensionInfo': wrapCommand(copyExtensionInfo),
-  'SearchExtensions.clearSearchResults': wrapCommand(clearSearchResults),
+  'SearchExtensions.acceptCompletion': wrapAsyncCommand(acceptCompletionWithContext),
+  'SearchExtensions.clearSearchResults': wrapAsyncCommand(clearSearchResultsWithContext),
   'SearchExtensions.closeSuggest': wrapCommand(closeSuggest),
   'SearchExtensions.copyExtensionId': wrapCommand(copyExtensionId),
   'SearchExtensions.copyExtensionInfo': wrapCommand(copyExtensionInfo),
   'SearchExtensions.create': create,
   'SearchExtensions.diff2': diff2,
-  'SearchExtensions.disable': wrapCommand(disable),
+  'SearchExtensions.disable': wrapCommand(disable$1),
   'SearchExtensions.disableWorkspace': wrapCommand(disableWorkspace),
   'SearchExtensions.dispose': dispose,
-  'SearchExtensions.enable': wrapCommand(enable),
+  'SearchExtensions.enable': wrapCommand(enable$1),
   'SearchExtensions.enableWorkspace': wrapCommand(enableWorkspace),
+  'SearchExtensions.filterByMostPopular': wrapAsyncCommand(filterByMostPopularWithContext),
   'SearchExtensions.focusFirst': wrapCommand(focusFirst),
   'SearchExtensions.focusIndex': wrapCommand(focusIndex),
   'SearchExtensions.focusLast': wrapCommand(focusLast),
@@ -3923,7 +5078,8 @@ const commandMap = {
   'SearchExtensions.handleEnableWorkspace': wrapCommand(handleEnableWorkspace),
   'SearchExtensions.handleFocus': wrapCommand(handleFocus),
   'SearchExtensions.handleHeaderContextMenu': wrapCommand(handleHeaderContextMenu),
-  'SearchExtensions.handleInput': wrapCommand(handleInput),
+  'SearchExtensions.handleInput': wrapAsyncCommand(handleInputWithContext),
+  'SearchExtensions.handleInputFocus': wrapCommand(handleInputFocus),
   'SearchExtensions.handleInstall': wrapCommand(handleInstall),
   'SearchExtensions.handleScrollBarCaptureLost': wrapCommand(handleScrollBarCaptureLost),
   'SearchExtensions.handleScrollBarClick': wrapCommand(handleScrollBarClick),
@@ -3934,7 +5090,7 @@ const commandMap = {
   'SearchExtensions.handleWheel': wrapCommand(handleWheel),
   'SearchExtensions.initialize': initialize,
   'SearchExtensions.installAnotherVersion': wrapCommand(installAnotherVersion),
-  'SearchExtensions.loadContent': wrapCommand(loadContent),
+  'SearchExtensions.loadContent': wrapAsyncCommand(loadContentWithContext),
   'SearchExtensions.openSuggest': wrapCommand(openSuggest),
   'SearchExtensions.render3': render3,
   'SearchExtensions.renderActions': renderActions,
@@ -3945,14 +5101,17 @@ const commandMap = {
   'SearchExtensions.scrollDown': wrapCommand(scrollDown),
   'SearchExtensions.searchExtensions': searchExtensions,
   'SearchExtensions.selectIndex': wrapCommand(selectIndex),
+  'SearchExtensions.selectNextCompletion': wrapCommand(selectNextCompletion),
+  'SearchExtensions.selectPreviousCompletion': wrapCommand(selectPreviousCompletion),
   'SearchExtensions.setDeltaY': wrapCommand(setDeltaY),
+  'SearchExtensions.setExtensionStatus': wrapCommand(setExtensionStatus),
   'SearchExtensions.terminate': terminate,
   'SearchExtensions.toggleSuggest': wrapCommand(toggleSuggest)
 };
 
 const listen = async () => {
   registerCommands(commandMap);
-  const rpc = await create$3({
+  const rpc = await create$4({
     commandMap: commandMap
   });
   set$2(rpc);