@lvce-editor/quick-pick-worker 4.32.0 → 4.33.1

package/dist/quickPickWorkerMain.js

@@ -67,7 +67,7 @@ const String$1 = 4;
 const Boolean$1 = 5;
 const Function = 6;
 const Null = 7;
-const Unknown = 8;
+const Unknown$1 = 8;
 const getType = value => {
   switch (typeof value) {
     case 'number':
@@ -87,7 +87,7 @@ const getType = value => {
     case 'boolean':
       return Boolean$1;
     default:
-      return Unknown;
+      return Unknown$1;
   }
 };
 const object = value => {
@@ -1229,6 +1229,279 @@ const Text = 12;
 const Img = 17;
 const Reference = 100;
 
+const Unknown = 0;
+const Backspace = 1;
+const Tab = 2;
+const Enter$1 = 3;
+const Ctrl = 4;
+const Alt = 5;
+const PauseBreak = 6;
+const CapsLock = 7;
+const Escape$1 = 8;
+const Space$1 = 9;
+const PageUp$1 = 10;
+const PageDown$1 = 11;
+const End = 255;
+const Home = 12;
+const LeftArrow = 13;
+const UpArrow$1 = 14;
+const RightArrow = 15;
+const DownArrow$1 = 16;
+const Insert = 17;
+const Delete = 18;
+const Digit0 = 19;
+const Digit1 = 20;
+const Digit2 = 21;
+const Digit3 = 22;
+const Digit4 = 23;
+const Digit5 = 24;
+const Digit6 = 25;
+const Digit7 = 26;
+const Digit8 = 27;
+const Digit9 = 28;
+const KeyA = 29;
+const KeyB = 30;
+const KeyC = 31;
+const KeyD = 32;
+const KeyE = 33;
+const KeyF = 34;
+const KeyG = 35;
+const KeyH = 36;
+const KeyI = 37;
+const KeyJ = 38;
+const KeyK = 39;
+const KeyL = 40;
+const KeyM = 41;
+const KeyN = 42;
+const KeyO = 43;
+const KeyP = 44;
+const KeyQ = 45;
+const KeyR = 46;
+const KeyS = 47;
+const KeyT = 48;
+const KeyU = 49;
+const KeyV = 50;
+const KeyW = 51;
+const KeyX = 52;
+const KeyY = 53;
+const KeyZ = 54;
+const Meta = 55;
+const ContextMenu = 56;
+const F1 = 57;
+const F2 = 58;
+const F3 = 59;
+const F4 = 60;
+const F5 = 61;
+const F6 = 62;
+const F7 = 63;
+const F8 = 64;
+const F9 = 65;
+const F10 = 66;
+const F11 = 67;
+const F12 = 68;
+const F13 = 69;
+const F14 = 70;
+const F15 = 71;
+const F16 = 72;
+const F17 = 72;
+const F18 = 74;
+const F19 = 75;
+const F20 = 76;
+const F21 = 77;
+const F22 = 78;
+const F23 = 79;
+const F24 = 80;
+const NumLock = 81;
+const ScrollLock = 82;
+const SemiColon = 83;
+const Equal = 84;
+const Comma = 85;
+const Minus = 86;
+const Period = 87;
+const Slash$1 = 88;
+const Backquote = 89;
+const BracketLeft = 90;
+const Backslash = 91;
+const BracketRight = 92;
+const Quote = 93;
+const OEM_8 = 94;
+const IntlBackslash = 95;
+const Numpad0 = 96;
+const Numpad1 = 97;
+const Numpad2 = 98;
+const Numpad3 = 99;
+const Numpad4 = 100;
+const Numpad5 = 101;
+const Numpad6 = 102;
+const Numpad7 = 103;
+const Numpad8 = 104;
+const Numpad9 = 105;
+const NumpadMultiply = 106;
+const NumpadAdd = 107;
+const NumpadSeparator = 108;
+const NumpadSubtract = 109;
+const NumpadDecimal = 110;
+const NumpadDivide = 111;
+const KeyInComposition = 112;
+const ABNT_C1 = 113;
+const ABNT_C2 = 114;
+const AudioVolumeMute = 115;
+const AudioVolumeUp = 116;
+const AudioVolumeDown = 117;
+const BrowserSearch = 118;
+const BrowserHome = 119;
+const BrowserBack = 120;
+const BrowserForward = 121;
+const MediaTrackNext = 122;
+const MediaTrackPrevious = 123;
+const MediaStop = 124;
+const MediaPlayPause = 125;
+const LaunchMediaPlayer = 126;
+const LaunchMail = 127;
+const LaunchApp2 = 128;
+const Clear = 129;
+const MaxValue = 130;
+const Star = 131;
+const Plus = 132;
+
+const KeyCode = {
+  __proto__: null,
+  ABNT_C1,
+  ABNT_C2,
+  Alt,
+  AudioVolumeDown,
+  AudioVolumeMute,
+  AudioVolumeUp,
+  Backquote,
+  Backslash,
+  Backspace,
+  BracketLeft,
+  BracketRight,
+  BrowserBack,
+  BrowserForward,
+  BrowserHome,
+  BrowserSearch,
+  CapsLock,
+  Clear,
+  Comma,
+  ContextMenu,
+  Ctrl,
+  Delete,
+  Digit0,
+  Digit1,
+  Digit2,
+  Digit3,
+  Digit4,
+  Digit5,
+  Digit6,
+  Digit7,
+  Digit8,
+  Digit9,
+  DownArrow: DownArrow$1,
+  End,
+  Enter: Enter$1,
+  Equal,
+  Escape: Escape$1,
+  F1,
+  F10,
+  F11,
+  F12,
+  F13,
+  F14,
+  F15,
+  F16,
+  F17,
+  F18,
+  F19,
+  F2,
+  F20,
+  F21,
+  F22,
+  F23,
+  F24,
+  F3,
+  F4,
+  F5,
+  F6,
+  F7,
+  F8,
+  F9,
+  Home,
+  Insert,
+  IntlBackslash,
+  KeyA,
+  KeyB,
+  KeyC,
+  KeyD,
+  KeyE,
+  KeyF,
+  KeyG,
+  KeyH,
+  KeyI,
+  KeyInComposition,
+  KeyJ,
+  KeyK,
+  KeyL,
+  KeyM,
+  KeyN,
+  KeyO,
+  KeyP,
+  KeyQ,
+  KeyR,
+  KeyS,
+  KeyT,
+  KeyU,
+  KeyV,
+  KeyW,
+  KeyX,
+  KeyY,
+  KeyZ,
+  LaunchApp2,
+  LaunchMail,
+  LaunchMediaPlayer,
+  LeftArrow,
+  MaxValue,
+  MediaPlayPause,
+  MediaStop,
+  MediaTrackNext,
+  MediaTrackPrevious,
+  Meta,
+  Minus,
+  NumLock,
+  Numpad0,
+  Numpad1,
+  Numpad2,
+  Numpad3,
+  Numpad4,
+  Numpad5,
+  Numpad6,
+  Numpad7,
+  Numpad8,
+  Numpad9,
+  NumpadAdd,
+  NumpadDecimal,
+  NumpadDivide,
+  NumpadMultiply,
+  NumpadSeparator,
+  NumpadSubtract,
+  OEM_8,
+  PageDown: PageDown$1,
+  PageUp: PageUp$1,
+  PauseBreak,
+  Period,
+  Plus,
+  Quote,
+  RightArrow,
+  ScrollLock,
+  SemiColon,
+  Slash: Slash$1,
+  Space: Space$1,
+  Star,
+  Tab,
+  Unknown,
+  UpArrow: UpArrow$1
+};
+
 const EditorWorker = 99;
 const ExtensionManagementWorker = 9006;
 const RendererProcess = 1670;
@@ -1393,6 +1666,47 @@ const close = async state => {
   return state;
 };
 
+const Commands = 'quickPick://commands';
+const EveryThing = 'quickPick://everything';
+const Recent = 'quickPick://recent';
+const ColorTheme = 'quickPick://color-theme';
+const LanguageMode = 'quickPick://language-mode';
+const Symbol$2 = 'quickPick://symbol';
+const View$2 = 'quickPick://view';
+const Help$1 = 'quickPick://help';
+const WorkspaceSymbol$1 = 'quickPick://workspace-symbol';
+const Custom = 'quickPick://custom';
+const GoToLine$1 = 'quickPick://go-to-line';
+const EndOfLine = 'quickPick://end-of-line';
+const Indentation = 'quickPick://indentation';
+
+const getQuickPickProviderId = prefix => {
+  switch (prefix) {
+    case ColorTheme:
+      return ColorTheme$1;
+    case Commands:
+    case EveryThing:
+    case GoToLine$1:
+    case Help$1:
+    case Symbol$2:
+    case View$2:
+    case WorkspaceSymbol$1:
+      return EveryThing$1;
+    case Custom:
+      return Custom$1;
+    case EndOfLine:
+      return EndOfLine$1;
+    case Indentation:
+      return Indentation$1;
+    case LanguageMode:
+      return LanguageMode$1;
+    case Recent:
+      return Recent$1;
+    default:
+      return File$1;
+  }
+};
+
 const User = 1;
 const Script = 2;
 
@@ -1929,6 +2243,7 @@ const handleScrollBarPointerUp = (state, pointerId) => {
 };
 
 const create = (uid, uri, listItemHeight, x, y, width, height, platform, args, _renderAllItems, workspaceUri, assetDir, applicationId) => {
+  const providerId = getQuickPickProviderId(uri);
   const state = {
     allowEmptyResult: false,
     applicationId,
@@ -1960,6 +2275,7 @@ const create = (uid, uri, listItemHeight, x, y, width, height, platform, args, _
     inputSource: User,
     placeholder: '',
     platform,
+    providerId,
     value: ''
   };
   set$5(uid, state, state);
@@ -2336,32 +2652,32 @@ const getNewValue = (value, inputType, data, selectionStart, selectionEnd) => {
 };
 
 const Command = '>';
-const Symbol$2 = '@';
-const WorkspaceSymbol$1 = '#';
-const GoToLine$1 = ':';
-const View$2 = 'view ';
+const Symbol$1 = '@';
+const WorkspaceSymbol = '#';
+const GoToLine = ':';
+const View$1 = 'view ';
 const None$1 = '';
-const Help$1 = '?';
+const Help = '?';
 const GoToColumn = '::';
 
 const getQuickPickPrefix = value => {
   if (value.startsWith(Command)) {
     return Command;
   }
-  if (value.startsWith(Symbol$2)) {
-    return Symbol$2;
+  if (value.startsWith(Symbol$1)) {
+    return Symbol$1;
   }
-  if (value.startsWith(WorkspaceSymbol$1)) {
-    return WorkspaceSymbol$1;
+  if (value.startsWith(WorkspaceSymbol)) {
+    return WorkspaceSymbol;
   }
   if (value.startsWith(GoToColumn)) {
     return GoToColumn;
   }
-  if (value.startsWith(GoToLine$1)) {
-    return GoToLine$1;
+  if (value.startsWith(GoToLine)) {
+    return GoToLine;
   }
-  if (value.startsWith(View$2)) {
-    return View$2;
+  if (value.startsWith(View$1)) {
+    return View$1;
   }
   return None$1;
 };
@@ -2378,15 +2694,15 @@ const getQuickPickSubProviderId = (id, prefix) => {
       return Commands$1;
     case GoToColumn:
       return GoToColumn$1;
-    case GoToLine$1:
+    case GoToLine:
       return GoToLine$2;
-    case Help$1:
+    case Help:
       return Help$2;
-    case Symbol$2:
+    case Symbol$1:
       return Symbol$3;
-    case View$2:
+    case View$1:
       return View$3;
-    case WorkspaceSymbol$1:
+    case WorkspaceSymbol:
       return WorkspaceSymbol$2;
     default:
       return File$1;
@@ -3233,20 +3549,23 @@ const getWorkspaceDisplayPath = workspace => {
     };
   }
   const url = new URL(workspace);
+  const uriPrefix = url.search || url.hash || !url.pathname.startsWith('/') ? undefined : `${url.protocol}//${url.host}${trimTrailingSeparators(url.pathname)}/`;
   return {
     host: url.host,
     path: decodeURIComponent(url.pathname),
-    scheme: url.protocol
+    scheme: url.protocol,
+    uriPrefix,
+    url
   };
 };
-const getRelativeDirectory = (workspace, uri, dirName) => {
-  const workspacePath = getWorkspaceDisplayPath(workspace);
-  if (hasUriScheme(uri)) {
+const isSafeRelativePath = path => /^[a-z\d._~/-]+$/i.test(path) && path.split('/').every(segment => segment !== '.' && segment !== '..');
+const getRelativeDirectory = (workspacePath, uri, dirName, isWorkspaceRelative) => {
+  if (!isWorkspaceRelative && hasUriScheme(uri)) {
     const url = new URL(uri);
     if (workspacePath.scheme !== url.protocol || workspacePath.host !== url.host) {
       return dirName;
     }
-  } else if (workspacePath.scheme) {
+  } else if (!isWorkspaceRelative && workspacePath.scheme) {
     return dirName;
   }
   const normalizedWorkspace = trimTrailingSeparators(workspacePath.path);
@@ -3260,15 +3579,18 @@ const getRelativeDirectory = (workspace, uri, dirName) => {
   }
   return normalizedDirectory.slice(prefix.length);
 };
-const resolveFileUri = (workspace, path) => {
+const resolveFileUri = (workspace, path, workspacePath) => {
   if (hasUriScheme(path)) {
     return path;
   }
-  if (hasUriScheme(workspace)) {
-    const workspaceUrl = new URL(workspace);
+  if (workspacePath.url) {
+    if (workspacePath.uriPrefix && !isAbsolutePath(path) && isSafeRelativePath(path)) {
+      return `${workspacePath.uriPrefix}${path}`;
+    }
+    const workspaceUrl = new URL(workspacePath.url);
     const normalizedPath = path.replaceAll('\\', '/').replaceAll('%', '%25');
-    const workspacePath = trimTrailingSeparators(workspaceUrl.pathname);
-    workspaceUrl.pathname = normalizedPath.startsWith('/') ? normalizedPath : `${workspacePath}/${normalizedPath}`;
+    const workspaceUrlPath = trimTrailingSeparators(workspaceUrl.pathname);
+    workspaceUrl.pathname = normalizedPath.startsWith('/') ? normalizedPath : `${workspaceUrlPath}/${normalizedPath}`;
     return workspaceUrl.href;
   }
   if (isAbsolutePath(path)) {
@@ -3276,11 +3598,17 @@ const resolveFileUri = (workspace, path) => {
   }
   return `${trimTrailingSeparators(workspace)}/${path}`;
 };
-const convertToPick = (workspace, uri) => {
-  const displayPath = hasUriScheme(uri) ? decodeURIComponent(new URL(uri).pathname) : uri.replaceAll('\\', '/');
+const convertToPick = (workspacePath, uri, path) => {
+  const isWorkspaceRelative = Boolean(workspacePath.uriPrefix && !isAbsolutePath(path) && !hasUriScheme(path) && isSafeRelativePath(path));
+  let displayPath = uri.replaceAll('\\', '/');
+  if (isWorkspaceRelative) {
+    displayPath = `${trimTrailingSeparators(workspacePath.path)}/${path}`;
+  } else if (hasUriScheme(uri)) {
+    displayPath = decodeURIComponent(new URL(uri).pathname);
+  }
   const baseName = pathBaseName(displayPath);
   const dirName = pathDirName(displayPath);
-  const description = getRelativeDirectory(workspace, uri, dirName);
+  const description = getRelativeDirectory(workspacePath, uri, dirName, isWorkspaceRelative);
   return {
     description,
     direntType: File,
@@ -3331,7 +3659,11 @@ const getPicks$b = async searchValue => {
       });
     }
   }
-  const picks = files.map(path => convertToPick(workspace, resolveFileUri(workspace, path)));
+  if (files.length === 0) {
+    return [];
+  }
+  const workspacePath = getWorkspaceDisplayPath(workspace);
+  const picks = files.map(path => convertToPick(workspacePath, resolveFileUri(workspace, path, workspacePath), path));
   return picks;
 };
 
@@ -3493,7 +3825,7 @@ const getPicksGoToLineBase = async () => {
 };
 
 const parseGoToLinePosition = value => {
-  const [lineString, columnString = '1'] = value.slice(GoToLine$1.length).split(':');
+  const [lineString, columnString = '1'] = value.slice(GoToLine.length).split(':');
   const line = Number(lineString);
   const column = Number(columnString);
   if (!Number.isSafeInteger(line) || !Number.isSafeInteger(column) || line < 1 || column < 1) {
@@ -3506,10 +3838,10 @@ const parseGoToLinePosition = value => {
 };
 
 const getPicks$a = async value => {
-  if (value === GoToLine$1) {
+  if (value === GoToLine) {
     return getPicksGoToLineBase();
   }
-  if (value.startsWith(GoToLine$1)) {
+  if (value.startsWith(GoToLine)) {
     const position = parseGoToLinePosition(value);
     if (!position) {
       return getPicksGoToLineBase();
@@ -3531,7 +3863,7 @@ const DotDotDot = '...';
 const Colon = ':';
 const Percent = '%';
 const AngleBracket = '>';
-const View$1 = 'view';
+const View = 'view';
 
 const getPicks$9 = async () => {
   return [{
@@ -3579,7 +3911,7 @@ const getPicks$9 = async () => {
     direntType: None$2,
     fileIcon: '',
     icon: '',
-    label: View$1,
+    label: View,
     matches: [],
     uri: ''
   }];
@@ -3951,7 +4283,7 @@ const selectPickGoToColumn = async (item, value) => {
 };
 
 const selectPick$7 = async (item, value) => {
-  if (value.startsWith(GoToLine$1)) {
+  if (value.startsWith(GoToLine)) {
     const position = parseGoToLinePosition(value);
     if (position) {
       await goToPositionAndFocus(position.rowIndex, position.columnIndex);
@@ -4051,291 +4383,405 @@ const getPicks = (id, searchValue, args, {
   });
 };
 
-const requestVersions = new Map();
-const requestVersionGenerator = {
-  value: 0
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
 };
-const isSamePicker = (state, latestState) => {
-  return latestState.uri === state.uri && latestState.args === state.args;
+
+const text = data => {
+  return {
+    childCount: 0,
+    text: data,
+    type: Text
+  };
 };
-const isQuickInput = args => {
-  const options = args.at(-1);
-  return options?.mode === 'quickInput';
+
+const SetText = 1;
+const Replace = 2;
+const SetAttribute = 3;
+const RemoveAttribute = 4;
+const Add = 6;
+const NavigateChild = 7;
+const NavigateParent = 8;
+const RemoveChild = 9;
+const NavigateSibling = 10;
+const SetReferenceNodeUid = 11;
+const MultiNavigation = 18;
+
+const isKey = key => {
+  return key !== 'type' && key !== 'childCount';
 };
-const isStaticQuickInput = args => {
-  const options = args.at(-1);
-  return options?.mode === 'quickInput' && options.quickInputId === undefined;
+
+const getKeys = node => {
+  const keys = Object.keys(node).filter(isKey);
+  return keys;
 };
-const setValue = async (state, newValue) => {
-  const {
-    args,
-    assetDir,
-    fileIconCache,
-    height,
-    itemHeight,
-    maxLineY,
-    minLineY,
-    platform,
-    providerId,
-    value
-  } = state;
-  if (value === newValue) {
-    return state;
+
+const arrayToTree = nodes => {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    const {
+      children,
+      nodesConsumed
+    } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
+    result.push({
+      node,
+      children
+    });
+    i += 1 + nodesConsumed;
   }
-  if (isTextInput(args)) {
+  return result;
+};
+const getChildrenWithCount = (nodes, startIndex, childCount) => {
+  if (childCount === 0) {
     return {
-      ...state,
-      inputSource: Script,
-      value: newValue
+      children: [],
+      nodesConsumed: 0
     };
   }
-  const prefix = getQuickPickPrefix(newValue);
-  const subId = getQuickPickSubProviderId(providerId, prefix);
-  const quickInput = isQuickInput(args);
-  const reuseFilePicks = !state.initial && canReuseFilePicks(providerId, value, newValue, state.picks.length);
-  const newPicks = isStaticQuickInput(args) || subId === LanguageMode$1 || reuseFilePicks ? state.picks : await getPicks(subId, newValue, args, {
-    applicationId: state.applicationId,
-    assetDir,
-    platform
-  });
-  const filterValue = quickInput ? '' : getFilterValue(providerId, subId, newValue);
-  const items = filterQuickPickItems(newPicks, filterValue, subId === Commands$1);
-  const focusedIndex = items.length === 0 ? -1 : 0;
-  const sliced = items.slice(minLineY, maxLineY);
-  const {
-    icons,
-    newFileIconCache
-  } = await getQuickPickFileIcons(sliced, fileIconCache);
-  const listHeight = getListHeight$1(items.length, itemHeight, height);
-  const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, items.length);
+  const children = [];
+  let i = startIndex;
+  let remaining = childCount;
+  let totalConsumed = 0;
+  while (remaining > 0 && i < nodes.length) {
+    const node = nodes[i];
+    const nodeChildCount = node.childCount || 0;
+    const {
+      children: nodeChildren,
+      nodesConsumed
+    } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
+    children.push({
+      node,
+      children: nodeChildren
+    });
+    const nodeSize = 1 + nodesConsumed;
+    i += nodeSize;
+    totalConsumed += nodeSize;
+    remaining--;
+  }
   return {
-    ...state,
-    fileIconCache: newFileIconCache,
-    finalDeltaY,
-    focusedIndex,
-    icons,
-    inputSource: Script,
-    items,
-    picks: newPicks,
-    value: newValue
+    children,
+    nodesConsumed: totalConsumed
   };
 };
-const setValueWithContext = async (context, newValue) => {
-  const state = context.getState();
-  if (state.value === newValue) {
+
+const isNavigationPatch = patch => {
+  switch (patch.type) {
+    case NavigateChild:
+    case NavigateParent:
+    case NavigateSibling:
+      return true;
+    default:
+      return false;
+  }
+};
+const getNavigationIndex = patch => {
+  switch (patch.type) {
+    case NavigateChild:
+    case NavigateSibling:
+      return patch.index;
+    default:
+      return 0;
+  }
+};
+const appendNavigationPatch = (patches, type, index) => {
+  const previousPatch = patches.at(-1);
+  if (!previousPatch) {
+    patches.push(type === NavigateParent ? {
+      type
+    } : {
+      index,
+      type
+    });
     return;
   }
-  const requestVersion = ++requestVersionGenerator.value;
-  requestVersions.set(state.uid, requestVersion);
-  const result = await setValue(state, newValue);
-  await context.updateState(latestState => {
-    if (requestVersions.get(latestState.uid) !== requestVersion || !isSamePicker(state, latestState)) {
-      return latestState;
-    }
-    return {
-      ...latestState,
-      fileIconCache: result.fileIconCache,
-      finalDeltaY: result.finalDeltaY,
-      focusedIndex: result.focusedIndex,
-      icons: result.icons,
-      inputSource: result.inputSource,
-      items: result.items,
-      picks: result.picks,
-      value: result.value
+  if (previousPatch.type === MultiNavigation) {
+    previousPatch.navigations.push(type, index);
+    return;
+  }
+  if (isNavigationPatch(previousPatch)) {
+    patches[patches.length - 1] = {
+      navigations: [previousPatch.type, getNavigationIndex(previousPatch), type, index],
+      type: MultiNavigation
     };
-  });
-  if (requestVersions.get(state.uid) === requestVersion) {
-    requestVersions.delete(state.uid);
+    return;
   }
+  patches.push(type === NavigateParent ? {
+    type
+  } : {
+    index,
+    type
+  });
 };
 
-const handleInputWithContext = async (context, newValue, cursorOffset, inputSource = Script) => {
-  const state = context.getState();
-  if (state.value !== newValue) {
-    await setValueWithContext(context, newValue);
-  }
-  await context.updateState(latestState => {
-    if (latestState.value !== newValue) {
-      return latestState;
+const compareNodes = (oldNode, newNode) => {
+  // Check if node type changed - return null to signal incompatible nodes
+  // (caller should handle this with a Replace operation)
+  if (oldNode.type !== newNode.type) {
+    return null;
+  }
+  const patches = [];
+  // Handle reference nodes - special handling for uid changes
+  if (oldNode.type === Reference && oldNode.uid !== newNode.uid) {
+    patches.push({
+      type: SetReferenceNodeUid,
+      uid: newNode.uid
+    });
+  }
+  // Handle text nodes
+  if (oldNode.type === Text && newNode.type === Text) {
+    if (oldNode.text !== newNode.text) {
+      patches.push({
+        type: SetText,
+        value: newNode.text
+      });
     }
-    return {
-      ...latestState,
-      cursorOffset,
-      inputSource
-    };
-  });
-};
-
-// TODO when user types letters -> no need to query provider again -> just filter existing results
-const handleInput = async (state, newValue, cursorOffset, inputSource = Script) => {
-  if (state.value === newValue) {
-    return {
-      ...state,
-      cursorOffset,
-      inputSource
-    };
+    return patches;
   }
-  const newState = await setValue(state, newValue);
-  return {
-    ...newState,
-    cursorOffset,
-    inputSource
-  };
-};
-
-const handleBeforeInput = (state, inputType, data, selectionStart, selectionEnd) => {
-  string(inputType);
-  number(selectionStart);
-  number(selectionEnd);
-  const {
-    value
-  } = state;
-  const {
-    cursorOffset,
-    newValue
-  } = getNewValue(value, inputType, data, selectionStart, selectionEnd);
-  return handleInput(state, newValue, cursorOffset, User);
-};
-
-const getCancelResult = args => {
-  const last = args.at(-1);
-  if (last && typeof last === 'object' &&
-  // @ts-ignore
-  last.mode === 'quickPick') {
-    return undefined;
+  // Compare attributes
+  const oldKeys = getKeys(oldNode).filter(key => oldNode.type !== Reference || key !== 'uid');
+  const newKeys = getKeys(newNode).filter(key => newNode.type !== Reference || key !== 'uid');
+  // Check for attribute changes
+  for (const key of newKeys) {
+    if (oldNode[key] !== newNode[key]) {
+      patches.push({
+        type: SetAttribute,
+        key,
+        value: newNode[key]
+      });
+    }
   }
-  return {
-    canceled: true,
-    inputValue: ''
-  };
-};
-const handleBlur = async state => {
-  const {
-    args,
-    providerId
-  } = state;
-  if (providerId === Custom$1) {
-    const options = args.at(-1);
-    if (!options?.executeItemCommand) {
-      const resolveId = args[2];
-      await invoke$4('QuickPick.executeCallback', resolveId, getCancelResult(args));
+  // Check for removed attributes
+  for (const key of oldKeys) {
+    if (!Object.hasOwn(newNode, key)) {
+      patches.push({
+        type: RemoveAttribute,
+        key
+      });
     }
   }
-  await closeWidget(state.uid);
-  return state;
+  return patches;
 };
 
-const getIndex = (top, headerHeight, itemHeight, y) => {
-  const relativeY = y - top - headerHeight;
-  const index = Math.floor(relativeY / itemHeight);
-  return index;
+const treeToArray = node => {
+  const result = [];
+  const stack = [node];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    result.push(current.node);
+    for (let i = current.children.length - 1; i >= 0; i--) {
+      stack.push(current.children[i]);
+    }
+  }
+  return result;
 };
 
-const Commands = 'quickPick://commands';
-const EveryThing = 'quickPick://everything';
-const Recent = 'quickPick://recent';
-const ColorTheme = 'quickPick://color-theme';
-const LanguageMode = 'quickPick://language-mode';
-const Symbol$1 = 'quickPick://symbol';
-const View = 'quickPick://view';
-const Help = 'quickPick://help';
-const WorkspaceSymbol = 'quickPick://workspace-symbol';
-const Custom = 'quickPick://custom';
-const GoToLine = 'quickPick://go-to-line';
-const EndOfLine = 'quickPick://end-of-line';
-const Indentation = 'quickPick://indentation';
-
-const getDefaultValue = (id, uri = '', args = []) => {
-  if (uri === GoToLine) {
-    const line = Number(args[1]);
-    const column = Number(args[2]);
-    if (Number.isSafeInteger(line) && Number.isSafeInteger(column) && line >= 1 && column >= 1) {
-      return `${GoToLine$1}${line}:${column}`;
-    }
-    return GoToLine$1;
+const navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    appendNavigationPatch(patches, NavigateChild, index);
+    return index;
   }
-  if (uri === WorkspaceSymbol) {
-    return WorkspaceSymbol$1;
+  if (currentChildIndex !== index) {
+    appendNavigationPatch(patches, NavigateSibling, index);
   }
-  switch (id) {
-    case EveryThing$1:
-      return Command;
-    default:
-      return '';
+  return index;
+};
+const navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    appendNavigationPatch(patches, NavigateParent, 0);
   }
+  return -1;
 };
-
-const getQuickPickProviderId = prefix => {
-  switch (prefix) {
-    case ColorTheme:
-      return ColorTheme$1;
-    case Commands:
-    case EveryThing:
-    case GoToLine:
-    case Help:
-    case Symbol$1:
-    case View:
-    case WorkspaceSymbol:
-      return EveryThing$1;
-    case Custom:
-      return Custom$1;
-    case EndOfLine:
-      return EndOfLine$1;
-    case Indentation:
-      return Indentation$1;
-    case LanguageMode:
-      return LanguageMode$1;
-    case Recent:
-      return Recent$1;
+const addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
+};
+const replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace,
+    nodes: treeToArray(newNode)
+  });
+};
+const appendPatch = (patches, patch) => {
+  switch (patch.type) {
+    case MultiNavigation:
+      for (let i = 0; i < patch.navigations.length; i += 2) {
+        appendNavigationPatch(patches, patch.navigations[i], patch.navigations[i + 1]);
+      }
+      return;
+    case NavigateChild:
+    case NavigateSibling:
+      appendNavigationPatch(patches, patch.type, patch.index);
+      return;
+    case NavigateParent:
+      appendNavigationPatch(patches, patch.type, 0);
+      return;
     default:
-      return File$1;
+      patches.push(patch);
   }
 };
-
-const callbacks = [];
-const waitUntilVisible = () => {
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  callbacks.push(resolve);
-  return promise;
-};
-const notifyVisible = () => {
-  const pendingCallbacks = [...callbacks];
-  callbacks.length = 0;
-  for (const callback of pendingCallbacks) {
-    callback();
+const appendPatches = (patches, newPatches) => {
+  for (const patch of newPatches) {
+    appendPatch(patches, patch);
   }
 };
-
-const parseArgs = (subId, args) => {
-  if (subId !== Custom$1) {
-    return {
-      ignoreFocusOut: false,
-      initialValue: '',
-      placeholder: ''
-    };
+const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+    replaceTree(newNode, patches);
+    return nextChildIndex;
   }
-  const last = args.at(-1);
-  if (!last || typeof last !== 'object') {
-    return {
-      ignoreFocusOut: false,
-      initialValue: '',
-      placeholder: ''
-    };
+  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+  const childPatches = [];
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, childPatches);
   }
-  return {
-    // @ts-ignore
-    ignoreFocusOut: Boolean(last.ignoreFocusOut),
-    // @ts-ignore
-    initialValue: last.initialValue ? String(last.initialValue) : '',
-    // @ts-ignore
-    placeholder: last.placeholder ? String(last.placeholder) : ''
-  };
-};
-const getLoadedState = async state => {
-  const {
+  if (nodePatches.length === 0 && childPatches.length === 0) {
+    return currentChildIndex;
+  }
+  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+  patches.push(...nodePatches);
+  appendPatches(patches, childPatches);
+  return nextChildIndex;
+};
+const diffRootNode = (oldNode, newNode, patches) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    replaceTree(newNode, patches);
+    return;
+  }
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (oldNode.children.length > 0 || newNode.children.length > 0) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+};
+const diffChildren = (oldChildren, newChildren, patches) => {
+  const maxLength = Math.max(oldChildren.length, newChildren.length);
+  let currentChildIndex = -1;
+  const indicesToRemove = [];
+  for (let i = 0; i < maxLength; i++) {
+    const oldNode = oldChildren[i];
+    const newNode = newChildren[i];
+    if (!oldNode && !newNode) {
+      continue;
+    }
+    if (!oldNode) {
+      currentChildIndex = navigateToParent(patches, currentChildIndex);
+      addTree(newNode, patches);
+      continue;
+    }
+    if (!newNode) {
+      indicesToRemove.push(i);
+      continue;
+    }
+    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
+  }
+  navigateToParent(patches, currentChildIndex);
+  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
+    patches.push({
+      type: RemoveChild,
+      index: indicesToRemove[j]
+    });
+  }
+};
+const diffTrees = (oldTree, newTree, patches, path) => {
+  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
+    diffRootNode(oldTree[0], newTree[0], patches);
+    return;
+  }
+  diffChildren(oldTree, newTree, patches);
+};
+
+const removeTrailingNavigationPatches = patches => {
+  while (patches.length > 0) {
+    const patch = patches.at(-1);
+    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling && patch.type !== MultiNavigation) {
+      break;
+    }
+    patches.pop();
+  }
+  return patches;
+};
+
+const diffTree = (oldNodes, newNodes) => {
+  // Step 1: Convert flat arrays to tree structures
+  const oldTree = arrayToTree(oldNodes);
+  const newTree = arrayToTree(newNodes);
+  // Step 3: Compare the trees
+  const patches = [];
+  diffTrees(oldTree, newTree, patches, []);
+  // Remove trailing navigation patches since they serve no purpose
+  return removeTrailingNavigationPatches(patches);
+};
+
+const keyNames = new Map(Object.entries(KeyCode).map(([name, code]) => [code, name.replace(/^(Key|Digit)/, '')]));
+const getKeyLabel = key => {
+  if (typeof key === 'string') {
+    return key;
+  }
+  if (typeof key !== 'number' || !Number.isSafeInteger(key) || key <= 0) {
+    return '';
+  }
+  const name = keyNames.get(key & 0xff);
+  if (!name || name === 'Unknown') {
+    return '';
+  }
+  return [...(key & 2048 ? ['Ctrl'] : []), ...(key & 1024 ? ['Shift'] : []), ...(key & 512 ? ['Alt'] : []), ...(key & 256 ? ['Meta'] : []), name].join('+');
+};
+const loadUserKeyBindings = async invoke => {
+  try {
+    const content = await invoke('FileSystem.readFile', 'app://keybindings.json');
+    const parsed = JSON.parse(content);
+    return Array.isArray(parsed) ? parsed.filter(entry => entry && (entry.source === 'User' || typeof entry.key === 'string' && !entry.source)) : [];
+  } catch {
+    return [];
+  }
+};
+const loadCommandKeyBindings = async applicationId => {
+  const invoke = (method, ...args) => applicationId === undefined ? invoke$4(method, ...args) : invoke$4('Application.execute', applicationId, method, ...args);
+  try {
+    if ((await invoke('Preferences.get', 'quickPick.showKeyBindings')) !== true) {
+      return {};
+    }
+    const defaults = await invoke('KeyBindingsInitial.getKeyBindings');
+    const user = await loadUserKeyBindings(invoke);
+    const bindings = Object.create(null);
+    for (const entry of [...user, ...defaults]) {
+      const command = entry.command === 'ExtensionHost.executeCommand' ? `ext.${entry.args?.[0]}` : entry.command;
+      const label = getKeyLabel(entry.key);
+      if (typeof command === 'string' && label && !Object.hasOwn(bindings, command)) {
+        bindings[command] = label;
+      }
+    }
+    return bindings;
+  } catch {
+    return {};
+  }
+};
+
+const requestVersions = new Map();
+const requestVersionGenerator = {
+  value: 0
+};
+const isSamePicker = (state, latestState) => {
+  return latestState.uri === state.uri && latestState.args === state.args;
+};
+const isQuickInput = args => {
+  const options = args.at(-1);
+  return options?.mode === 'quickInput';
+};
+const isStaticQuickInput = args => {
+  const options = args.at(-1);
+  return options?.mode === 'quickInput' && options.quickInputId === undefined;
+};
+const setValue = async (state, newValue) => {
+  const {
     args,
     assetDir,
     fileIconCache,
@@ -4343,31 +4789,35 @@ const getLoadedState = async state => {
     itemHeight,
     maxVisibleItems,
     platform,
-    uri
+    providerId,
+    value
   } = state;
-  const id = getQuickPickProviderId(uri);
-  const value = getDefaultValue(id, uri, args);
-  const prefix = getQuickPickPrefix(value);
-  const subId = getQuickPickSubProviderId(id, prefix);
-  const newPicks = await getPicks(subId, value, args, {
+  if (value === newValue) {
+    return state;
+  }
+  if (isTextInput(args)) {
+    return {
+      ...state,
+      inputSource: Script,
+      value: newValue
+    };
+  }
+  const prefix = getQuickPickPrefix(newValue);
+  const subId = getQuickPickSubProviderId(providerId, prefix);
+  const previousSubId = getQuickPickSubProviderId(providerId, getQuickPickPrefix(value));
+  const commandKeyBindings = subId === Commands$1 && previousSubId !== subId ? await loadCommandKeyBindings(state.applicationId) : state.commandKeyBindings;
+  const quickInput = isQuickInput(args);
+  const reuseFilePicks = !state.initial && canReuseFilePicks(providerId, value, newValue, state.picks.length);
+  const newPicks = isStaticQuickInput(args) || subId === LanguageMode$1 || reuseFilePicks ? state.picks : await getPicks(subId, newValue, args, {
     applicationId: state.applicationId,
     assetDir,
     platform
   });
-  array(newPicks);
-  let colorTheme = '';
-  if (subId === ColorTheme$1) {
-    try {
-      colorTheme = await invoke$4('ColorTheme.getColorTheme');
-    } catch {
-      // The worker can be released before the renderer endpoint.
-    }
-  }
-  const filterValue = getFilterValue(id, subId, value);
-  const items = isTextInput(args) ? newPicks : filterQuickPickItems(newPicks, filterValue, subId === Commands$1);
-  const focusedIndex = subId === ColorTheme$1 ? Math.max(items.findIndex(item => item.label === colorTheme), 0) : 0;
-  const minLineY = Math.max(Math.min(focusedIndex - maxVisibleItems + 1, items.length - maxVisibleItems), 0);
-  const maxLineY = Math.min(minLineY + maxVisibleItems, items.length);
+  const filterValue = quickInput ? '' : getFilterValue(providerId, subId, newValue);
+  const items = filterQuickPickItems(newPicks, filterValue, subId === Commands$1);
+  const focusedIndex = items.length === 0 ? -1 : 0;
+  const minLineY = 0;
+  const maxLineY = Math.min(maxVisibleItems, items.length);
   const sliced = items.slice(minLineY, maxLineY);
   const {
     icons,
@@ -4375,90 +4825,336 @@ const getLoadedState = async state => {
   } = await getQuickPickFileIcons(sliced, fileIconCache);
   const listHeight = getListHeight$1(items.length, itemHeight, height);
   const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, items.length);
-  const parsedArgs = parseArgs(subId, args);
-  const finalValue = parsedArgs.initialValue || value;
   return {
     ...state,
-    args,
-    cursorOffset: value.length,
-    deltaY: minLineY * itemHeight,
+    commandKeyBindings,
+    deltaY: 0,
     fileIconCache: newFileIconCache,
     finalDeltaY,
-    focused: true,
     focusedIndex,
     icons,
-    initial: false,
     inputSource: Script,
     items,
     maxLineY,
     minLineY,
     picks: newPicks,
-    placeholder: parsedArgs.placeholder,
-    providerId: id,
-    state: Finished,
-    value: finalValue
+    value: newValue
   };
 };
-const loadContent = async state => {
-  const newState = await getLoadedState(state);
-  notifyVisible();
-  return newState;
-};
-const loadContentWithContext = async context => {
+const setValueWithContext = async (context, newValue) => {
   const state = context.getState();
-  const loadedState = await getLoadedState(state);
-  await context.updateState(latestState => ({
-    ...latestState,
-    cursorOffset: loadedState.cursorOffset,
-    deltaY: loadedState.deltaY,
-    fileIconCache: loadedState.fileIconCache,
-    finalDeltaY: loadedState.finalDeltaY,
-    focused: loadedState.focused,
-    focusedIndex: loadedState.focusedIndex,
-    icons: loadedState.icons,
-    initial: loadedState.initial,
-    inputSource: loadedState.inputSource,
-    items: loadedState.items,
-    maxLineY: loadedState.maxLineY,
-    minLineY: loadedState.minLineY,
-    picks: loadedState.picks,
-    placeholder: loadedState.placeholder,
-    providerId: loadedState.providerId,
-    state: loadedState.state,
-    value: loadedState.value
-  }));
-  notifyVisible();
+  if (state.value === newValue) {
+    return;
+  }
+  const requestVersion = ++requestVersionGenerator.value;
+  requestVersions.set(state.uid, requestVersion);
+  const result = await setValue(state, newValue);
+  await context.updateState(latestState => {
+    if (requestVersions.get(latestState.uid) !== requestVersion || !isSamePicker(state, latestState)) {
+      return latestState;
+    }
+    return {
+      ...latestState,
+      commandKeyBindings: result.commandKeyBindings,
+      deltaY: result.deltaY,
+      fileIconCache: result.fileIconCache,
+      finalDeltaY: result.finalDeltaY,
+      focusedIndex: result.focusedIndex,
+      icons: result.icons,
+      inputSource: result.inputSource,
+      items: result.items,
+      maxLineY: result.maxLineY,
+      minLineY: result.minLineY,
+      picks: result.picks,
+      value: result.value
+    };
+  });
+  if (requestVersions.get(state.uid) === requestVersion) {
+    requestVersions.delete(state.uid);
+  }
 };
 
-const getPick = (items, index) => {
-  array(items);
-  number(index);
-  // if (index < state.recentPicks.length) {
-  //   return state.recentPicks[index]
-  // }
-  // index -= state.recentPicks.length
-  if (index < items.length) {
-    return items[index];
+const handleInputWithContext = async (context, newValue, cursorOffset, inputSource = Script) => {
+  const state = context.getState();
+  if (state.value !== newValue) {
+    await setValueWithContext(context, newValue);
   }
-  console.warn('no pick matching index', index);
-  return undefined;
+  await context.updateState(latestState => {
+    if (latestState.value !== newValue) {
+      return latestState;
+    }
+    return {
+      ...latestState,
+      cursorOffset,
+      inputSource
+    };
+  });
 };
 
-const createCustomPick = value => {
+// TODO when user types letters -> no need to query provider again -> just filter existing results
+const handleInput = async (state, newValue, cursorOffset, inputSource = Script) => {
+  if (state.value === newValue) {
+    return {
+      ...state,
+      cursorOffset,
+      inputSource
+    };
+  }
+  const newState = await setValue(state, newValue);
   return {
-    description: '',
-    direntType: 0,
-    fileIcon: '',
-    icon: '',
-    label: value,
-    matches: [],
-    uri: ''
+    ...newState,
+    cursorOffset,
+    inputSource
   };
 };
-const shouldCloseBeforeSelect = (subId, pick) => {
-  if (subId === Recent$1) {
-    return true;
-  }
+
+const handleBeforeInput = (state, inputType, data, selectionStart, selectionEnd) => {
+  string(inputType);
+  number(selectionStart);
+  number(selectionEnd);
+  const {
+    value
+  } = state;
+  const {
+    cursorOffset,
+    newValue
+  } = getNewValue(value, inputType, data, selectionStart, selectionEnd);
+  return handleInput(state, newValue, cursorOffset, User);
+};
+
+const getCancelResult = args => {
+  const last = args.at(-1);
+  if (last && typeof last === 'object' &&
+  // @ts-ignore
+  last.mode === 'quickPick') {
+    return undefined;
+  }
+  return {
+    canceled: true,
+    inputValue: ''
+  };
+};
+const handleBlur = async state => {
+  const {
+    args,
+    providerId
+  } = state;
+  if (providerId === Custom$1) {
+    const options = args.at(-1);
+    if (!options?.executeItemCommand) {
+      const resolveId = args[2];
+      await invoke$4('QuickPick.executeCallback', resolveId, getCancelResult(args));
+    }
+  }
+  await closeWidget(state.uid);
+  return state;
+};
+
+const getIndex = (top, headerHeight, itemHeight, y) => {
+  const relativeY = y - top - headerHeight;
+  const index = Math.floor(relativeY / itemHeight);
+  return index;
+};
+
+const getDefaultValue = (id, uri = '', args = []) => {
+  if (uri === GoToLine$1) {
+    const line = Number(args[1]);
+    const column = Number(args[2]);
+    if (Number.isSafeInteger(line) && Number.isSafeInteger(column) && line >= 1 && column >= 1) {
+      return `${GoToLine}${line}:${column}`;
+    }
+    return GoToLine;
+  }
+  if (uri === WorkspaceSymbol$1) {
+    return WorkspaceSymbol;
+  }
+  switch (id) {
+    case EveryThing$1:
+      return Command;
+    default:
+      return '';
+  }
+};
+
+const callbacks = [];
+const waitUntilVisible = () => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  callbacks.push(resolve);
+  return promise;
+};
+const notifyVisible = () => {
+  const pendingCallbacks = [...callbacks];
+  callbacks.length = 0;
+  for (const callback of pendingCallbacks) {
+    callback();
+  }
+};
+
+const parseArgs = (subId, args) => {
+  if (subId !== Custom$1) {
+    return {
+      ignoreFocusOut: false,
+      initialValue: '',
+      placeholder: ''
+    };
+  }
+  const last = args.at(-1);
+  if (!last || typeof last !== 'object') {
+    return {
+      ignoreFocusOut: false,
+      initialValue: '',
+      placeholder: ''
+    };
+  }
+  return {
+    // @ts-ignore
+    ignoreFocusOut: Boolean(last.ignoreFocusOut),
+    // @ts-ignore
+    initialValue: last.initialValue ? String(last.initialValue) : '',
+    // @ts-ignore
+    placeholder: last.placeholder ? String(last.placeholder) : ''
+  };
+};
+const getLoadedState = async state => {
+  const {
+    args,
+    assetDir,
+    fileIconCache,
+    height,
+    itemHeight,
+    maxVisibleItems,
+    platform,
+    uri
+  } = state;
+  const id = getQuickPickProviderId(uri);
+  const value = getDefaultValue(id, uri, args);
+  const prefix = getQuickPickPrefix(value);
+  const subId = getQuickPickSubProviderId(id, prefix);
+  const commandKeyBindings = subId === Commands$1 ? await loadCommandKeyBindings(state.applicationId) : {};
+  const newPicks = await getPicks(subId, value, args, {
+    applicationId: state.applicationId,
+    assetDir,
+    platform
+  });
+  array(newPicks);
+  let colorTheme = '';
+  if (subId === ColorTheme$1) {
+    try {
+      colorTheme = await invoke$4('ColorTheme.getColorTheme');
+    } catch {
+      // The worker can be released before the renderer endpoint.
+    }
+  }
+  const filterValue = getFilterValue(id, subId, value);
+  const items = isTextInput(args) ? newPicks : filterQuickPickItems(newPicks, filterValue, subId === Commands$1);
+  const focusedIndex = subId === ColorTheme$1 ? Math.max(items.findIndex(item => item.label === colorTheme), 0) : 0;
+  const minLineY = Math.max(Math.min(focusedIndex - maxVisibleItems + 1, items.length - maxVisibleItems), 0);
+  const maxLineY = Math.min(minLineY + maxVisibleItems, items.length);
+  const sliced = items.slice(minLineY, maxLineY);
+  const {
+    icons,
+    newFileIconCache
+  } = await getQuickPickFileIcons(sliced, fileIconCache);
+  const listHeight = getListHeight$1(items.length, itemHeight, height);
+  const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, items.length);
+  const parsedArgs = parseArgs(subId, args);
+  const finalValue = parsedArgs.initialValue || value;
+  const latest = get$3(state.uid);
+  if (latest && latest.newState.uri === state.uri && latest.newState.args === state.args && latest.newState.value !== state.value) {
+    return state;
+  }
+  return {
+    ...state,
+    args,
+    commandKeyBindings,
+    cursorOffset: value.length,
+    deltaY: minLineY * itemHeight,
+    fileIconCache: newFileIconCache,
+    finalDeltaY,
+    focused: true,
+    focusedIndex,
+    icons,
+    initial: false,
+    inputSource: Script,
+    items,
+    maxLineY,
+    minLineY,
+    picks: newPicks,
+    placeholder: parsedArgs.placeholder,
+    providerId: id,
+    state: Finished,
+    value: finalValue
+  };
+};
+const loadContent = async state => {
+  const newState = await getLoadedState(state);
+  notifyVisible();
+  return newState;
+};
+const loadContentWithContext = async context => {
+  const state = context.getState();
+  const loadedState = await getLoadedState(state);
+  await context.updateState(latestState => {
+    if (latestState.value !== state.value || latestState.uri !== state.uri || latestState.args !== state.args) {
+      return latestState;
+    }
+    return {
+      ...latestState,
+      commandKeyBindings: loadedState.commandKeyBindings,
+      cursorOffset: loadedState.cursorOffset,
+      deltaY: loadedState.deltaY,
+      fileIconCache: loadedState.fileIconCache,
+      finalDeltaY: loadedState.finalDeltaY,
+      focused: loadedState.focused,
+      focusedIndex: loadedState.focusedIndex,
+      icons: loadedState.icons,
+      initial: loadedState.initial,
+      inputSource: loadedState.inputSource,
+      items: loadedState.items,
+      maxLineY: loadedState.maxLineY,
+      minLineY: loadedState.minLineY,
+      picks: loadedState.picks,
+      placeholder: loadedState.placeholder,
+      providerId: loadedState.providerId,
+      state: loadedState.state,
+      value: loadedState.value
+    };
+  });
+  notifyVisible();
+};
+
+const getPick = (items, index) => {
+  array(items);
+  number(index);
+  // if (index < state.recentPicks.length) {
+  //   return state.recentPicks[index]
+  // }
+  // index -= state.recentPicks.length
+  if (index < items.length) {
+    return items[index];
+  }
+  console.warn('no pick matching index', index);
+  return undefined;
+};
+
+const createCustomPick = value => {
+  return {
+    description: '',
+    direntType: 0,
+    fileIcon: '',
+    icon: '',
+    label: value,
+    matches: [],
+    uri: ''
+  };
+};
+const shouldCloseBeforeSelect = (subId, pick) => {
+  if (subId === Recent$1) {
+    return true;
+  }
   if (subId !== Commands$1) {
     return false;
   }
@@ -4578,471 +5274,148 @@ const handleMessagePort = async port => {
 };
 
 const state = {
-  connected: false
-};
-const isConnected = () => {
-  const {
-    connected
-  } = state;
-  return connected;
-};
-const invoke$1 = (method, ...params) => {
-  return invoke$5(method, ...params);
-};
-const set = rpc => {
-  set$7(rpc);
-  state.connected = true;
-};
-
-const handleRendererProcessMessagePort = async (port, viewletCommandMap, setAsRendererProcess = true) => {
-  const executeViewletCommand = async (uid, command, ...args) => {
-    const fn = viewletCommandMap[`QuickPick.${command}`];
-    if (typeof fn !== 'function') {
-      throw new TypeError(`Viewlet command not found: ${command}`);
-    }
-    await fn(uid, ...args);
-    await invoke$4('Viewlet.requestRender', uid);
-  };
-  const rpc = await create$8({
-    commandMap: {
-      'Viewlet.executeViewletCommand': executeViewletCommand
-    },
-    messagePort: port
-  });
-  if (setAsRendererProcess) {
-    set(rpc);
-  }
-};
-
-const handleStatusBarMessagePort = async port => {
-  await create$8({
-    commandMap: commandMapRef,
-    isMessagePortOpen: true,
-    messagePort: port
-  });
-};
-
-const initialize = async () => {
-  // not needed anymore
-};
-
-const invoke = async (applicationId, method, ...args) => {
-  return applicationId === undefined ? invoke$4(method, ...args) : invoke$4('Application.execute', applicationId, method, ...args);
-};
-
-const QuickPick$2 = 'QuickPick';
-
-const openStatusBarPicker = async (picker, ...args) => {
-  await invoke(undefined, 'Viewlet.openWidget', QuickPick$2, picker, ...args);
-};
-
-const getCss = (scrollBarHeight, scrollBarTop, quickPickItemsHeight) => {
-  return `.QuickPick {
-  --QuickPickItemsHeight: ${quickPickItemsHeight}px;
-  --ScrollBarThumbHeight: ${scrollBarHeight}px;
-  --ScrollBarThumbTop: ${scrollBarTop}px;
-}
-.QuickPick .QuickPickItems {
-  height: var(--QuickPickItemsHeight);
-}
-.QuickPick .ScrollBarThumb {
-  height: var(--ScrollBarThumbHeight);
-  translate: 0px var(--ScrollBarThumbTop);
-}`;
-};
-
-const getQuickPickItemsHeight = height => {
-  if (height === 0) {
-    return 20;
-  }
-  return height;
-};
-const renderCss = (_oldState, newState) => {
-  const {
-    deltaY,
-    finalDeltaY,
-    headerHeight,
-    height,
-    itemHeight,
-    items,
-    minimumSliderSize,
-    uid
-  } = newState;
-  const quickPickItemsHeight = getQuickPickItemsHeight(height);
-  const listHeight = getListHeight$1(items.length, itemHeight, quickPickItemsHeight);
-  const contentHeight = items.length * itemHeight;
-  const scrollBarHeight = getScrollBarSize(listHeight, contentHeight, minimumSliderSize);
-  const scrollBarTop = Math.round(getScrollBarY(deltaY, finalDeltaY, quickPickItemsHeight - headerHeight, scrollBarHeight));
-  const css = getCss(scrollBarHeight, scrollBarTop, quickPickItemsHeight);
-  return [SetCss, uid, css];
-};
-
-const SetCursorOffset = 'setCursorOffset';
-const SetFocusedIndex = 'setFocusedIndex';
-const SetItemsHeight = 'setItemsHeight';
-
-const renderCursorOffset = (_oldState, newState) => {
-  return ['Viewlet.send', newState.uid, /* method */SetCursorOffset, /* cursorOffset */newState.cursorOffset];
-};
-
-const QuickPickInput = 'QuickPickInput';
-
-const renderFocus = (_oldState, newState) => {
-  return ['Viewlet.focusElementByName', newState.uid, QuickPickInput];
-};
-
-const renderFocusedIndex = (oldState, newState) => {
-  const oldFocusedIndex = oldState.focusedIndex - oldState.minLineY;
-  const newFocusedIndex = newState.focusedIndex - newState.minLineY;
-  return ['Viewlet.send', newState.uid, /* method */SetFocusedIndex, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */newFocusedIndex];
-};
-
-const renderHeight = (_oldState, newState) => {
-  const {
-    height,
-    uid
-  } = newState;
-  if (height === 0) {
-    return ['Viewlet.send', uid, /* method */SetItemsHeight, /* height */20];
-  }
-  return ['Viewlet.send', uid, /* method */SetItemsHeight, /* height */height];
-};
-
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-
-const text = data => {
-  return {
-    childCount: 0,
-    text: data,
-    type: Text
-  };
-};
-
-const SetText = 1;
-const Replace = 2;
-const SetAttribute = 3;
-const RemoveAttribute = 4;
-const Add = 6;
-const NavigateChild = 7;
-const NavigateParent = 8;
-const RemoveChild = 9;
-const NavigateSibling = 10;
-const SetReferenceNodeUid = 11;
-const MultiNavigation = 18;
-
-const isKey = key => {
-  return key !== 'type' && key !== 'childCount';
-};
-
-const getKeys = node => {
-  const keys = Object.keys(node).filter(isKey);
-  return keys;
-};
-
-const arrayToTree = nodes => {
-  const result = [];
-  let i = 0;
-  while (i < nodes.length) {
-    const node = nodes[i];
-    const {
-      children,
-      nodesConsumed
-    } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
-    result.push({
-      node,
-      children
-    });
-    i += 1 + nodesConsumed;
-  }
-  return result;
-};
-const getChildrenWithCount = (nodes, startIndex, childCount) => {
-  if (childCount === 0) {
-    return {
-      children: [],
-      nodesConsumed: 0
-    };
-  }
-  const children = [];
-  let i = startIndex;
-  let remaining = childCount;
-  let totalConsumed = 0;
-  while (remaining > 0 && i < nodes.length) {
-    const node = nodes[i];
-    const nodeChildCount = node.childCount || 0;
-    const {
-      children: nodeChildren,
-      nodesConsumed
-    } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
-    children.push({
-      node,
-      children: nodeChildren
-    });
-    const nodeSize = 1 + nodesConsumed;
-    i += nodeSize;
-    totalConsumed += nodeSize;
-    remaining--;
-  }
-  return {
-    children,
-    nodesConsumed: totalConsumed
-  };
-};
-
-const isNavigationPatch = patch => {
-  switch (patch.type) {
-    case NavigateChild:
-    case NavigateParent:
-    case NavigateSibling:
-      return true;
-    default:
-      return false;
-  }
-};
-const getNavigationIndex = patch => {
-  switch (patch.type) {
-    case NavigateChild:
-    case NavigateSibling:
-      return patch.index;
-    default:
-      return 0;
-  }
-};
-const appendNavigationPatch = (patches, type, index) => {
-  const previousPatch = patches.at(-1);
-  if (!previousPatch) {
-    patches.push(type === NavigateParent ? {
-      type
-    } : {
-      index,
-      type
-    });
-    return;
-  }
-  if (previousPatch.type === MultiNavigation) {
-    previousPatch.navigations.push(type, index);
-    return;
-  }
-  if (isNavigationPatch(previousPatch)) {
-    patches[patches.length - 1] = {
-      navigations: [previousPatch.type, getNavigationIndex(previousPatch), type, index],
-      type: MultiNavigation
-    };
-    return;
-  }
-  patches.push(type === NavigateParent ? {
-    type
-  } : {
-    index,
-    type
-  });
-};
-
-const compareNodes = (oldNode, newNode) => {
-  // Check if node type changed - return null to signal incompatible nodes
-  // (caller should handle this with a Replace operation)
-  if (oldNode.type !== newNode.type) {
-    return null;
-  }
-  const patches = [];
-  // Handle reference nodes - special handling for uid changes
-  if (oldNode.type === Reference && oldNode.uid !== newNode.uid) {
-    patches.push({
-      type: SetReferenceNodeUid,
-      uid: newNode.uid
-    });
-  }
-  // Handle text nodes
-  if (oldNode.type === Text && newNode.type === Text) {
-    if (oldNode.text !== newNode.text) {
-      patches.push({
-        type: SetText,
-        value: newNode.text
-      });
-    }
-    return patches;
-  }
-  // Compare attributes
-  const oldKeys = getKeys(oldNode).filter(key => oldNode.type !== Reference || key !== 'uid');
-  const newKeys = getKeys(newNode).filter(key => newNode.type !== Reference || key !== 'uid');
-  // Check for attribute changes
-  for (const key of newKeys) {
-    if (oldNode[key] !== newNode[key]) {
-      patches.push({
-        type: SetAttribute,
-        key,
-        value: newNode[key]
-      });
-    }
-  }
-  // Check for removed attributes
-  for (const key of oldKeys) {
-    if (!Object.hasOwn(newNode, key)) {
-      patches.push({
-        type: RemoveAttribute,
-        key
-      });
-    }
-  }
-  return patches;
+  connected: false
+};
+const isConnected = () => {
+  const {
+    connected
+  } = state;
+  return connected;
+};
+const invoke$1 = (method, ...params) => {
+  return invoke$5(method, ...params);
+};
+const set = rpc => {
+  set$7(rpc);
+  state.connected = true;
 };
 
-const treeToArray = node => {
-  const result = [];
-  const stack = [node];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    result.push(current.node);
-    for (let i = current.children.length - 1; i >= 0; i--) {
-      stack.push(current.children[i]);
+const handleRendererProcessMessagePort = async (port, viewletCommandMap, setAsRendererProcess = true) => {
+  const executeViewletCommand = async (uid, command, ...args) => {
+    const fn = viewletCommandMap[`QuickPick.${command}`];
+    if (typeof fn !== 'function') {
+      throw new TypeError(`Viewlet command not found: ${command}`);
     }
+    await fn(uid, ...args);
+    await invoke$4('Viewlet.requestRender', uid);
+  };
+  const rpc = await create$8({
+    commandMap: {
+      'Viewlet.executeViewletCommand': executeViewletCommand
+    },
+    messagePort: port
+  });
+  if (setAsRendererProcess) {
+    set(rpc);
   }
-  return result;
 };
 
-const navigateToChild = (patches, currentChildIndex, index) => {
-  if (currentChildIndex === -1) {
-    appendNavigationPatch(patches, NavigateChild, index);
-    return index;
-  }
-  if (currentChildIndex !== index) {
-    appendNavigationPatch(patches, NavigateSibling, index);
-  }
-  return index;
-};
-const navigateToParent = (patches, currentChildIndex) => {
-  if (currentChildIndex >= 0) {
-    appendNavigationPatch(patches, NavigateParent, 0);
-  }
-  return -1;
-};
-const addTree = (newNode, patches) => {
-  patches.push({
-    type: Add,
-    nodes: treeToArray(newNode)
+const handleStatusBarMessagePort = async port => {
+  await create$8({
+    commandMap: commandMapRef,
+    isMessagePortOpen: true,
+    messagePort: port
   });
 };
-const replaceTree = (newNode, patches) => {
-  patches.push({
-    type: Replace,
-    nodes: treeToArray(newNode)
-  });
+
+const initialize = async () => {
+  // not needed anymore
 };
-const appendPatch = (patches, patch) => {
-  switch (patch.type) {
-    case MultiNavigation:
-      for (let i = 0; i < patch.navigations.length; i += 2) {
-        appendNavigationPatch(patches, patch.navigations[i], patch.navigations[i + 1]);
-      }
-      return;
-    case NavigateChild:
-    case NavigateSibling:
-      appendNavigationPatch(patches, patch.type, patch.index);
-      return;
-    case NavigateParent:
-      appendNavigationPatch(patches, patch.type, 0);
-      return;
-    default:
-      patches.push(patch);
-  }
+
+const invoke = async (applicationId, method, ...args) => {
+  return applicationId === undefined ? invoke$4(method, ...args) : invoke$4('Application.execute', applicationId, method, ...args);
 };
-const appendPatches = (patches, newPatches) => {
-  for (const patch of newPatches) {
-    appendPatch(patches, patch);
-  }
+
+const QuickPick$2 = 'QuickPick';
+
+const openStatusBarPicker = async (picker, ...args) => {
+  await invoke(undefined, 'Viewlet.openWidget', QuickPick$2, picker, ...args);
 };
-const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
-  const nodePatches = compareNodes(oldNode.node, newNode.node);
-  if (nodePatches === null) {
-    const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
-    replaceTree(newNode, patches);
-    return nextChildIndex;
-  }
-  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
-  const childPatches = [];
-  if (hasChildrenToCompare) {
-    diffChildren(oldNode.children, newNode.children, childPatches);
-  }
-  if (nodePatches.length === 0 && childPatches.length === 0) {
-    return currentChildIndex;
-  }
-  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
-  patches.push(...nodePatches);
-  appendPatches(patches, childPatches);
-  return nextChildIndex;
+
+const getCss = (scrollBarHeight, scrollBarTop, quickPickItemsHeight) => {
+  return `.QuickPick {
+  --QuickPickItemsHeight: ${quickPickItemsHeight}px;
+  --ScrollBarThumbHeight: ${scrollBarHeight}px;
+  --ScrollBarThumbTop: ${scrollBarTop}px;
+}
+.QuickPick .QuickPickItems {
+  height: var(--QuickPickItemsHeight);
+}
+.QuickPick .ScrollBarThumb {
+  height: var(--ScrollBarThumbHeight);
+  translate: 0px var(--ScrollBarThumbTop);
+}
+.QuickPickKeyBinding {
+  margin-left: auto;
+  display: flex;
+  gap: 2px;
+  flex-shrink: 0;
+  pointer-events: none;
+}
+.QuickPickKeyBinding .Key {
+  padding: 0 4px;
+  line-height: 16px;
+}
+.QuickPickItem:has(.QuickPickKeyBinding) .QuickPickItemLabel {
+  flex-shrink: 1;
+}`;
 };
-const diffRootNode = (oldNode, newNode, patches) => {
-  const nodePatches = compareNodes(oldNode.node, newNode.node);
-  if (nodePatches === null) {
-    replaceTree(newNode, patches);
-    return;
-  }
-  if (nodePatches.length > 0) {
-    patches.push(...nodePatches);
-  }
-  if (oldNode.children.length > 0 || newNode.children.length > 0) {
-    diffChildren(oldNode.children, newNode.children, patches);
+
+const getQuickPickItemsHeight = height => {
+  if (height === 0) {
+    return 20;
   }
+  return height;
 };
-const diffChildren = (oldChildren, newChildren, patches) => {
-  const maxLength = Math.max(oldChildren.length, newChildren.length);
-  let currentChildIndex = -1;
-  const indicesToRemove = [];
-  for (let i = 0; i < maxLength; i++) {
-    const oldNode = oldChildren[i];
-    const newNode = newChildren[i];
-    if (!oldNode && !newNode) {
-      continue;
-    }
-    if (!oldNode) {
-      currentChildIndex = navigateToParent(patches, currentChildIndex);
-      addTree(newNode, patches);
-      continue;
-    }
-    if (!newNode) {
-      indicesToRemove.push(i);
-      continue;
-    }
-    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
-  }
-  navigateToParent(patches, currentChildIndex);
-  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
-    patches.push({
-      type: RemoveChild,
-      index: indicesToRemove[j]
-    });
-  }
+const renderCss = (_oldState, newState) => {
+  const {
+    deltaY,
+    finalDeltaY,
+    headerHeight,
+    height,
+    itemHeight,
+    items,
+    minimumSliderSize,
+    uid
+  } = newState;
+  const quickPickItemsHeight = getQuickPickItemsHeight(height);
+  const listHeight = getListHeight$1(items.length, itemHeight, quickPickItemsHeight);
+  const contentHeight = items.length * itemHeight;
+  const scrollBarHeight = getScrollBarSize(listHeight, contentHeight, minimumSliderSize);
+  const scrollBarTop = Math.round(getScrollBarY(deltaY, finalDeltaY, quickPickItemsHeight - headerHeight, scrollBarHeight));
+  const css = getCss(scrollBarHeight, scrollBarTop, quickPickItemsHeight);
+  return [SetCss, uid, css];
 };
-const diffTrees = (oldTree, newTree, patches, path) => {
-  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
-    diffRootNode(oldTree[0], newTree[0], patches);
-    return;
-  }
-  diffChildren(oldTree, newTree, patches);
+
+const SetCursorOffset = 'setCursorOffset';
+const SetFocusedIndex = 'setFocusedIndex';
+const SetItemsHeight = 'setItemsHeight';
+
+const renderCursorOffset = (_oldState, newState) => {
+  return ['Viewlet.send', newState.uid, /* method */SetCursorOffset, /* cursorOffset */newState.cursorOffset];
 };
 
-const removeTrailingNavigationPatches = patches => {
-  while (patches.length > 0) {
-    const patch = patches.at(-1);
-    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling && patch.type !== MultiNavigation) {
-      break;
-    }
-    patches.pop();
-  }
-  return patches;
+const QuickPickInput = 'QuickPickInput';
+
+const renderFocus = (_oldState, newState) => {
+  return ['Viewlet.focusElementByName', newState.uid, QuickPickInput];
 };
 
-const diffTree = (oldNodes, newNodes) => {
-  // Step 1: Convert flat arrays to tree structures
-  const oldTree = arrayToTree(oldNodes);
-  const newTree = arrayToTree(newNodes);
-  // Step 3: Compare the trees
-  const patches = [];
-  diffTrees(oldTree, newTree, patches, []);
-  // Remove trailing navigation patches since they serve no purpose
-  return removeTrailingNavigationPatches(patches);
+const renderFocusedIndex = (oldState, newState) => {
+  const oldFocusedIndex = oldState.focusedIndex - oldState.minLineY;
+  const newFocusedIndex = newState.focusedIndex - newState.minLineY;
+  return ['Viewlet.send', newState.uid, /* method */SetFocusedIndex, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */newFocusedIndex];
+};
+
+const renderHeight = (_oldState, newState) => {
+  const {
+    height,
+    uid
+  } = newState;
+  if (height === 0) {
+    return ['Viewlet.send', uid, /* method */SetItemsHeight, /* height */20];
+  }
+  return ['Viewlet.send', uid, /* method */SetItemsHeight, /* height */height];
 };
 
 const getVisible$1 = (items, minLineY, maxLineY, icons) => {
@@ -5091,15 +5464,21 @@ const getHighlightSections = (highlights, label) => {
   return sections;
 };
 
-const getVisible = (setSize, protoVisibleItems, minLineY, focusedIndex) => {
+const getVisible = (setSize, protoVisibleItems, minLineY, focusedIndex, keyBindings = {}) => {
   const visibleFocusedIndex = focusedIndex - minLineY;
   const visibleItems = protoVisibleItems.map((visibleItem, i) => {
+    const {
+      id
+    } = visibleItem;
     const highlights = visibleItem.matches.slice(1);
     const sections = getHighlightSections(highlights, visibleItem.label);
     return {
       ...visibleItem,
       highlights: sections,
       isActive: i === visibleFocusedIndex,
+      ...(id && Object.hasOwn(keyBindings, id) && {
+        keyBinding: keyBindings[id]
+      }),
       posInSet: minLineY + i + 1,
       setSize
     };
@@ -5126,7 +5505,8 @@ const createQuickPickViewModel = (oldState, newState) => {
     value
   } = newState;
   const protoVisibleItems = getVisible$1(items, minLineY, maxLineY, icons);
-  const visibleItems = getVisible(items.length, protoVisibleItems, minLineY, focusedIndex);
+  const isCommands = getQuickPickSubProviderId(newState.providerId, getQuickPickPrefix(value)) === Commands$1;
+  const visibleItems = getVisible(items.length, protoVisibleItems, minLineY, focusedIndex, isCommands ? newState.commandKeyBindings : {});
   const oldFocusedIndex = oldState.focusedIndex - oldState.minLineY;
   const newFocusedIndex = focusedIndex - minLineY;
   const itemCount = items.length;
@@ -5340,6 +5720,22 @@ const getQuickPickItemVirtualDom = visibleItem => {
       type: Div
     }, text(description));
   }
+  if (visibleItem.keyBinding) {
+    parent.childCount++;
+    const keys = visibleItem.keyBinding.split('+');
+    dom.push({
+      childCount: keys.length,
+      className: 'QuickPickKeyBinding',
+      type: Div
+    });
+    for (const key of keys) {
+      dom.push({
+        childCount: 1,
+        className: 'Key',
+        type: Span
+      }, text(key));
+    }
+  }
   if (removeButton) {
     parent.childCount++;
     dom.push({