diff --git a/src/components/graph/selectionToolbox/MenuOptionItem.vue b/src/components/graph/selectionToolbox/MenuOptionItem.vue
index fb1f8c01a5..e6909737dc 100644
--- a/src/components/graph/selectionToolbox/MenuOptionItem.vue
+++ b/src/components/graph/selectionToolbox/MenuOptionItem.vue
@@ -3,10 +3,21 @@
     v-if="option.type === 'divider'"
     class="my-1 h-px bg-smoke-200 dark-theme:bg-zinc-700"
   />
+  <div
+    v-else-if="option.type === 'category'"
+    class="px-3 py-1.5 text-xs font-medium text-text-secondary uppercase tracking-wide pointer-events-none"
+  >
+    {{ t(`contextMenu.${option.label || ''}`) }}
+  </div>
   <div
     v-else
     role="button"
-    class="group flex cursor-pointer items-center gap-2 rounded px-3 py-1.5 text-left text-sm text-text-primary hover:bg-interface-menu-component-surface-hovered"
+    :class="[
+      'group flex items-center gap-2 rounded px-3 py-1.5 text-left text-sm',
+      option.disabled
+        ? 'cursor-not-allowed pointer-events-none text-node-icon-disabled'
+        : 'cursor-pointer text-text-primary hover:bg-interface-menu-component-surface-hovered'
+    ]"
     @click="handleClick"
   >
     <i v-if="option.icon" :class="[option.icon, 'h-4 w-4']" />
@@ -57,6 +68,9 @@ const props = defineProps<Props>()
 const emit = defineEmits<Emits>()
 
 const handleClick = (event: Event) => {
+  if (props.option.disabled) {
+    return
+  }
   emit('click', props.option, event)
 }
 </script>
diff --git a/src/components/graph/selectionToolbox/NodeOptions.vue b/src/components/graph/selectionToolbox/NodeOptions.vue
index 9965ffa6d4..c43f447ab3 100644
--- a/src/components/graph/selectionToolbox/NodeOptions.vue
+++ b/src/components/graph/selectionToolbox/NodeOptions.vue
@@ -11,15 +11,35 @@
       :pt="pt"
       @show="onPopoverShow"
       @hide="onPopoverHide"
-      @wheel="canvasInteractions.forwardEventToCanvas"
     >
       <div class="flex min-w-48 flex-col p-2">
-        <MenuOptionItem
-          v-for="(option, index) in menuOptions"
-          :key="option.label || `divider-${index}`"
-          :option="option"
-          @click="handleOptionClick"
-        />
+        <!-- Search input (fixed at top) -->
+        <div class="mb-2 px-1">
+          <div class="relative">
+            <i
+              class="icon-[lucide--search] absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-text-secondary"
+            />
+            <input
+              ref="searchInput"
+              v-model="searchQuery"
+              autofocus="false"
+              type="text"
+              :placeholder="t('contextMenu.Search')"
+              class="w-full rounded-lg border border-smoke-200 bg-interface-panel-surface py-2 pl-9 pr-3 text-sm text-text-primary placeholder-text-secondary focus:border-primary-500 focus:outline-none focus:ring-1 focus:ring-primary-500 dark-theme:border-zinc-700"
+              @keydown.escape="clearSearch"
+            />
+          </div>
+        </div>
+
+        <!-- Menu items (scrollable) -->
+        <div class="max-h-96 lg:max-h-[75vh] overflow-y-auto">
+          <MenuOptionItem
+            v-for="(option, index) in filteredMenuOptions"
+            :key="option.label || `divider-${index}`"
+            :option="option"
+            @click="handleOptionClick"
+          />
+        </div>
       </div>
     </Popover>
 
@@ -37,6 +57,7 @@
 import { useRafFn } from '@vueuse/core'
 import Popover from 'primevue/popover'
 import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
 
 import {
   forceCloseMoreOptionsSignal,
@@ -53,13 +74,19 @@ import type {
   SubMenuOption
 } from '@/composables/graph/useMoreOptionsMenu'
 import { useSubmenuPositioning } from '@/composables/graph/useSubmenuPositioning'
-import { useCanvasInteractions } from '@/renderer/core/canvas/useCanvasInteractions'
+import { calculateMenuPosition } from '@/composables/graph/useViewportAwareMenuPositioning'
+
+// import { useCanvasInteractions } from '@/renderer/core/canvas/useCanvasInteractions'
 
 import MenuOptionItem from './MenuOptionItem.vue'
 import SubmenuPopover from './SubmenuPopover.vue'
 
+const { t } = useI18n()
+
 const popover = ref<InstanceType<typeof Popover>>()
 const targetElement = ref<HTMLElement | null>(null)
+const searchInput = ref<HTMLInputElement | null>(null)
+const searchQuery = ref('')
 const isTriggeredByToolbox = ref<boolean>(true)
 // Track open state ourselves so we can restore after drag/move
 const isOpen = ref(false)
@@ -72,7 +99,46 @@ const currentSubmenu = ref<string | null>(null)
 
 const { menuOptions, menuOptionsWithSubmenu, bump } = useMoreOptionsMenu()
 const { toggleSubmenu, hideAllSubmenus } = useSubmenuPositioning()
-const canvasInteractions = useCanvasInteractions()
+// const canvasInteractions = useCanvasInteractions()
+
+// Filter menu options based on search query
+const filteredMenuOptions = computed(() => {
+  const query = searchQuery.value.toLowerCase().trim()
+  if (!query) {
+    return menuOptions.value
+  }
+
+  const filtered: MenuOption[] = []
+  let lastWasDivider = false
+
+  for (const option of menuOptions.value) {
+    // Skip category labels and dividers during filtering, add them back contextually
+    if (option.type === 'divider') {
+      lastWasDivider = true
+      continue
+    }
+
+    if (option.type === 'category') {
+      continue
+    }
+
+    // Check if option matches search query
+    const label = option.label?.toLowerCase() || ''
+    if (label.includes(query)) {
+      // Add divider before this item if the last item was separated by a divider
+      if (lastWasDivider && filtered.length > 0) {
+        const lastItem = filtered[filtered.length - 1]
+        if (lastItem.type !== 'divider') {
+          filtered.push({ type: 'divider' })
+        }
+      }
+      filtered.push(option)
+      lastWasDivider = false
+    }
+  }
+
+  return filtered
+})
 
 let lastLogTs = 0
 const LOG_INTERVAL = 120 // ms
@@ -114,19 +180,31 @@ const repositionPopover = () => {
   const btn = targetElement.value
   const overlayEl = resolveOverlayEl()
   if (!btn || !overlayEl) return
+
   const rect = btn.getBoundingClientRect()
-  const marginY = 8 // tailwind mt-2 ~ 0.5rem = 8px
-  const left = isTriggeredByToolbox.value
-    ? rect.left + rect.width / 2
-    : rect.right - rect.width / 4
-  const top = isTriggeredByToolbox.value
-    ? rect.bottom + marginY
-    : rect.top - marginY - 6
+
   try {
-    overlayEl.style.position = 'fixed'
-    overlayEl.style.left = `${left}px`
-    overlayEl.style.top = `${top}px`
-    overlayEl.style.transform = 'translate(-50%, 0)'
+    // Calculate viewport-aware position
+    const style = calculateMenuPosition({
+      triggerRect: rect,
+      menuElement: overlayEl,
+      isTriggeredByToolbox: isTriggeredByToolbox.value,
+      marginY: 8
+    })
+
+    // Apply positioning styles
+    overlayEl.style.position = style.position
+    overlayEl.style.left = style.left
+    overlayEl.style.transform = style.transform
+
+    // Handle top vs bottom positioning
+    if (style.top !== undefined) {
+      overlayEl.style.top = style.top
+      overlayEl.style.bottom = '' // Clear bottom if using top
+    } else if (style.bottom !== undefined) {
+      overlayEl.style.bottom = style.bottom
+      overlayEl.style.top = '' // Clear top if using bottom
+    }
   } catch (e) {
     console.warn('[NodeOptions] Failed to set overlay style', e)
     return
@@ -253,6 +331,10 @@ const setSubmenuRef = (key: string, el: any) => {
   }
 }
 
+const clearSearch = () => {
+  searchQuery.value = ''
+}
+
 const pt = computed(() => ({
   root: {
     class: 'absolute z-50 w-[300px] px-[12]'
@@ -269,8 +351,14 @@ const pt = computed(() => ({
 // Distinguish outside click (PrimeVue dismiss) from programmatic hides.
 const onPopoverShow = () => {
   overlayElCache = resolveOverlayEl()
+  // Clear search and focus input
+  searchQuery.value = ''
   // Delay first reposition slightly to ensure DOM fully painted
-  requestAnimationFrame(() => repositionPopover())
+  requestAnimationFrame(() => {
+    repositionPopover()
+    // Focus the search input after popover is shown
+    searchInput.value?.focus()
+  })
   startSync()
 }
 
@@ -282,6 +370,8 @@ const onPopoverHide = () => {
     moreOptionsOpen.value = false
     moreOptionsRestorePending.value = false
   }
+  // Clear search when hiding
+  searchQuery.value = ''
   overlayElCache = null
   stopSync()
   lastProgrammaticHideReason.value = null
diff --git a/src/components/graph/selectionToolbox/SubmenuPopover.vue b/src/components/graph/selectionToolbox/SubmenuPopover.vue
index 12c1a8571a..10baa5ee40 100644
--- a/src/components/graph/selectionToolbox/SubmenuPopover.vue
+++ b/src/components/graph/selectionToolbox/SubmenuPopover.vue
@@ -19,9 +19,15 @@
         v-for="subOption in option.submenu"
         :key="subOption.label"
         :class="
-          isColorSubmenu
-            ? 'w-7 h-7 flex items-center justify-center hover:bg-smoke-100 dark-theme:hover:bg-zinc-700 rounded cursor-pointer'
-            : 'flex items-center gap-2 px-3 py-1.5 text-sm hover:bg-smoke-100 dark-theme:hover:bg-zinc-700 rounded cursor-pointer'
+          cn(
+            'flex items-center rounded',
+            isColorSubmenu
+              ? 'w-7 h-7 justify-center'
+              : 'gap-2 px-3 py-1.5 text-sm',
+            subOption.disabled
+              ? 'cursor-not-allowed pointer-events-none text-node-icon-disabled'
+              : 'hover:bg-smoke-100 dark-theme:hover:bg-zinc-700 cursor-pointer'
+          )
         "
         :title="subOption.label"
         @click="handleSubmenuClick(subOption)"
@@ -46,13 +52,14 @@
 
 <script setup lang="ts">
 import Popover from 'primevue/popover'
-import { computed, ref } from 'vue'
+import { computed, nextTick, ref } from 'vue'
 
 import type {
   MenuOption,
   SubMenuOption
 } from '@/composables/graph/useMoreOptionsMenu'
 import { useNodeCustomization } from '@/composables/graph/useNodeCustomization'
+import { cn } from '@/utils/tailwindUtil'
 
 interface Props {
   option: MenuOption
@@ -69,20 +76,50 @@ const { getCurrentShape } = useNodeCustomization()
 
 const popover = ref<InstanceType<typeof Popover>>()
 
-const show = (event: Event, target?: HTMLElement) => {
+const show = async (event: Event, target?: HTMLElement) => {
   popover.value?.show(event, target)
+
+  // Wait for next tick to ensure the popover is rendered
+  await nextTick()
+
+  // Apply viewport-aware positioning after popover is shown
+  repositionSubmenu()
 }
 
 const hide = () => {
   popover.value?.hide()
 }
 
+const repositionSubmenu = () => {
+  const overlayEl = (popover.value as any)?.$el as HTMLElement
+  if (!overlayEl) return
+
+  // Get current position and dimensions
+  const rect = overlayEl.getBoundingClientRect()
+  const menuHeight = overlayEl.offsetHeight || overlayEl.scrollHeight
+  const viewportHeight = window.innerHeight
+
+  // Check if menu would overflow viewport bottom
+  const menuBottom = rect.top + menuHeight
+  const wouldOverflow = menuBottom > viewportHeight
+
+  if (wouldOverflow) {
+    // Dock to bottom of viewport while keeping horizontal position
+    overlayEl.style.position = 'fixed'
+    overlayEl.style.bottom = '0px'
+    overlayEl.style.top = ''
+  }
+}
+
 defineExpose({
   show,
   hide
 })
 
 const handleSubmenuClick = (subOption: SubMenuOption) => {
+  if (subOption.disabled) {
+    return
+  }
   emit('submenu-click', subOption)
 }
 
diff --git a/src/composables/graph/contextMenuConverter.ts b/src/composables/graph/contextMenuConverter.ts
new file mode 100644
index 0000000000..15b7877adb
--- /dev/null
+++ b/src/composables/graph/contextMenuConverter.ts
@@ -0,0 +1,751 @@
+import { LiteGraph } from '@/lib/litegraph/src/litegraph'
+import type { IContextMenuValue } from '@/lib/litegraph/src/litegraph'
+
+import type { MenuOption, SubMenuOption } from './useMoreOptionsMenu'
+
+// Debug logging flag - set to true to enable detailed logging
+const DEBUG = false
+
+function debug(...args: unknown[]) {
+  if (DEBUG) {
+    // eslint-disable-next-line no-console
+    console.log(...args)
+  }
+}
+
+/**
+ * Hard blacklist - items that should NEVER be included
+ */
+const HARD_BLACKLIST = new Set([
+  'Properties', // Never include Properties submenu
+  'Colors', // Use singular "Color" instead
+  'Shapes', // Use singular "Shape" instead
+  'Title',
+  'Mode',
+  'Properties Panel',
+  'Copy (Clipspace)'
+])
+
+/**
+ * Core menu items - items that should appear in the main menu, not under Extensions
+ * Includes both LiteGraph base menu items and ComfyUI built-in functionality
+ */
+const CORE_MENU_ITEMS = new Set([
+  // Basic operations
+  'Rename',
+  'Copy',
+  'Duplicate',
+  'Clone',
+  // Node state operations
+  'Run Branch',
+  'Pin',
+  'Unpin',
+  'Bypass',
+  'Remove Bypass',
+  'Mute',
+  // Structure operations
+  'Convert to Subgraph',
+  'Frame selection',
+  'Minimize Node',
+  'Expand',
+  'Collapse',
+  // Info and adjustments
+  'Node Info',
+  'Resize',
+  'Title',
+  'Properties Panel',
+  'Adjust Size',
+  // Visual
+  'Color',
+  'Colors',
+  'Shape',
+  'Shapes',
+  'Mode',
+  // Built-in node operations (node-specific)
+  'Open Image',
+  'Copy Image',
+  'Save Image',
+  'Open in MaskEditor',
+  'Edit Subgraph Widgets',
+  'Unpack Subgraph',
+  'Copy (Clipspace)',
+  'Paste (Clipspace)',
+  // Selection and alignment
+  'Align Selected To',
+  'Distribute Nodes',
+  // Deletion
+  'Delete',
+  'Remove',
+  // LiteGraph base items
+  'Show Advanced',
+  'Hide Advanced'
+])
+
+/**
+ * Normalize menu item label for duplicate detection
+ * Handles variations like Colors/Color, Shapes/Shape, Pin/Unpin, Remove/Delete
+ */
+function normalizeLabel(label: string): string {
+  return label
+    .toLowerCase()
+    .replace(/s$/, '') // Remove trailing 's' (Colors -> Color, Shapes -> Shape)
+    .replace(/^un/, '') // Remove 'un' prefix (Unpin -> Pin)
+    .trim()
+}
+
+/**
+ * Check if a similar menu item already exists in the results
+ * Returns true if an item with the same normalized label exists
+ */
+function isDuplicateItem(label: string, existingItems: MenuOption[]): boolean {
+  const normalizedLabel = normalizeLabel(label)
+
+  // Map of equivalent items
+  const equivalents: Record<string, string[]> = {
+    color: ['color', 'colors'],
+    shape: ['shape', 'shapes'],
+    pin: ['pin', 'unpin'],
+    delete: ['remove', 'delete'],
+    duplicate: ['clone', 'duplicate']
+  }
+
+  return existingItems.some((item) => {
+    if (!item.label) return false
+
+    const existingNormalized = normalizeLabel(item.label)
+
+    // Check direct match
+    if (existingNormalized === normalizedLabel) return true
+
+    // Check if they're in the same equivalence group
+    for (const values of Object.values(equivalents)) {
+      if (
+        values.includes(normalizedLabel) &&
+        values.includes(existingNormalized)
+      ) {
+        return true
+      }
+    }
+
+    return false
+  })
+}
+
+/**
+ * Check if a menu item is a core menu item (not an extension)
+ * Core items include LiteGraph base items and ComfyUI built-in functionality
+ */
+function isCoreMenuItem(label: string): boolean {
+  return CORE_MENU_ITEMS.has(label)
+}
+
+/**
+ * Filter out duplicate menu items based on label
+ * Gives precedence to Vue hardcoded options over LiteGraph options
+ */
+function removeDuplicateMenuOptions(options: MenuOption[]): MenuOption[] {
+  // Group items by label
+  const itemsByLabel = new Map<string, MenuOption[]>()
+  const itemsWithoutLabel: MenuOption[] = []
+
+  for (const opt of options) {
+    // Always keep dividers and category items
+    if (opt.type === 'divider' || opt.type === 'category') {
+      itemsWithoutLabel.push(opt)
+      continue
+    }
+
+    // Items without labels are kept as-is
+    if (!opt.label) {
+      itemsWithoutLabel.push(opt)
+      continue
+    }
+
+    // Group by label
+    if (!itemsByLabel.has(opt.label)) {
+      itemsByLabel.set(opt.label, [])
+    }
+    itemsByLabel.get(opt.label)!.push(opt)
+  }
+
+  // Select best item for each label (prefer vue over litegraph)
+  const result: MenuOption[] = []
+  const seenLabels = new Set<string>()
+
+  for (const opt of options) {
+    // Add non-labeled items in original order
+    if (opt.type === 'divider' || opt.type === 'category' || !opt.label) {
+      if (itemsWithoutLabel.includes(opt)) {
+        result.push(opt)
+        const idx = itemsWithoutLabel.indexOf(opt)
+        itemsWithoutLabel.splice(idx, 1)
+      }
+      continue
+    }
+
+    // Skip if we already processed this label
+    if (seenLabels.has(opt.label)) {
+      continue
+    }
+    seenLabels.add(opt.label)
+
+    // Get all items with this label
+    const duplicates = itemsByLabel.get(opt.label)!
+
+    // If only one item, add it
+    if (duplicates.length === 1) {
+      result.push(duplicates[0])
+      continue
+    }
+
+    // Multiple items: prefer vue source over litegraph
+    const vueItem = duplicates.find((item) => item.source === 'vue')
+    if (vueItem) {
+      result.push(vueItem)
+    } else {
+      // No vue item, just take the first one
+      result.push(duplicates[0])
+    }
+  }
+
+  return result
+}
+
+/**
+ * Order groups for menu items - defines the display order of sections
+ */
+const MENU_ORDER = [
+  // Section 1: Basic operations
+  'Rename',
+  'Copy',
+  'Duplicate',
+  // Section 2: Node actions
+  'Run Branch',
+  'Pin',
+  'Unpin',
+  'Bypass',
+  'Remove Bypass',
+  'Mute',
+  // Section 3: Structure operations
+  'Convert to Subgraph',
+  'Frame selection',
+  'Minimize Node',
+  'Expand',
+  'Collapse',
+  'Resize',
+  'Clone',
+  // Section 4: Node properties
+  'Node Info',
+  'Color',
+  // Section 5: Node-specific operations
+  'Open in MaskEditor',
+  'Open Image',
+  'Copy Image',
+  'Save Image',
+  'Copy (Clipspace)',
+  'Paste (Clipspace)',
+  // Fallback for other core items
+  'Convert to Group Node (Deprecated)'
+] as const
+
+/**
+ * Get the order index for a menu item (lower = earlier in menu)
+ */
+function getMenuItemOrder(label: string): number {
+  const index = MENU_ORDER.indexOf(label as any)
+  return index === -1 ? 999 : index
+}
+
+/**
+ * Build structured menu with core items first, then extensions under a labeled section
+ * Ensures Delete always appears at the bottom
+ */
+export function buildStructuredMenu(options: MenuOption[]): MenuOption[] {
+  /* eslint-disable no-console */
+  console.log('[Structure] Input options:', options.length)
+  console.log(
+    '[Structure] Input items:',
+    options.map((o) => o.label || o.type)
+  )
+
+  // First, remove duplicates (giving precedence to Vue hardcoded options)
+  const deduplicated = removeDuplicateMenuOptions(options)
+  console.log('[Structure] After deduplication:', deduplicated.length)
+  console.log(
+    '[Structure] Deduplicated items:',
+    deduplicated.map((o) => o.label || o.type)
+  )
+
+  const coreItemsMap = new Map<string, MenuOption>()
+  const extensionItems: MenuOption[] = []
+  let deleteItem: MenuOption | undefined
+
+  // Separate items into core and extension categories
+  for (const option of deduplicated) {
+    // Skip dividers for now - we'll add them between sections later
+    if (option.type === 'divider') {
+      continue
+    }
+
+    // Skip category labels (they'll be added separately)
+    if (option.type === 'category') {
+      continue
+    }
+
+    // Check if this is the Delete/Remove item - save it for the end
+    const isDeleteItem = option.label === 'Delete' || option.label === 'Remove'
+    if (isDeleteItem && !option.hasSubmenu) {
+      console.log('[Structure] Found Delete item:', option.label)
+      deleteItem = option
+      continue
+    }
+
+    // Categorize based on label
+    if (option.label && isCoreMenuItem(option.label)) {
+      console.log('[Structure] Core item:', option.label)
+      coreItemsMap.set(option.label, option)
+    } else {
+      console.log('[Structure] Extension item:', option.label || '(no label)')
+      extensionItems.push(option)
+    }
+  }
+
+  console.log('[Structure] Core items:', coreItemsMap.size)
+  console.log('[Structure] Extension items:', extensionItems.length)
+  console.log('[Structure] Delete item:', deleteItem?.label || 'none')
+
+  // Build ordered core items based on MENU_ORDER
+  const orderedCoreItems: MenuOption[] = []
+  const coreLabels = Array.from(coreItemsMap.keys())
+  coreLabels.sort((a, b) => getMenuItemOrder(a) - getMenuItemOrder(b))
+
+  console.log('[Structure] Ordered core labels:', coreLabels)
+
+  // Section boundaries based on MENU_ORDER indices
+  // Section 1: 0-2 (Rename, Copy, Duplicate)
+  // Section 2: 3-8 (Run Branch, Pin, Unpin, Bypass, Remove Bypass, Mute)
+  // Section 3: 9-15 (Convert to Subgraph, Frame selection, Minimize Node, Expand, Collapse, Resize, Clone)
+  // Section 4: 16-17 (Node Info, Color)
+  // Section 5: 18+ (Image operations and fallback items)
+  const getSectionNumber = (index: number): number => {
+    if (index <= 2) return 1
+    if (index <= 8) return 2
+    if (index <= 15) return 3
+    if (index <= 17) return 4
+    return 5
+  }
+
+  let lastSection = 0
+  for (const label of coreLabels) {
+    const item = coreItemsMap.get(label)!
+    const itemIndex = getMenuItemOrder(label)
+    const currentSection = getSectionNumber(itemIndex)
+
+    // Add divider when moving to a new section
+    if (lastSection > 0 && currentSection !== lastSection) {
+      console.log(
+        `[Structure] Adding divider between section ${lastSection} and ${currentSection}`
+      )
+      orderedCoreItems.push({ type: 'divider' })
+    }
+
+    orderedCoreItems.push(item)
+    lastSection = currentSection
+  }
+
+  console.log(
+    '[Structure] Ordered core items:',
+    orderedCoreItems.map((o) => o.label || o.type)
+  )
+
+  // Build the final menu structure
+  const result: MenuOption[] = []
+
+  // Add ordered core items with their dividers
+  result.push(...orderedCoreItems)
+
+  // Add extensions section if there are extension items
+  if (extensionItems.length > 0) {
+    console.log('[Structure] Adding Extensions section')
+    // Add divider before Extensions section
+    result.push({ type: 'divider' })
+
+    // Add non-clickable Extensions label
+    result.push({
+      label: 'Extensions',
+      type: 'category',
+      disabled: true
+    })
+
+    // Add extension items
+    result.push(...extensionItems)
+  }
+
+  // Add Delete at the bottom if it exists
+  if (deleteItem) {
+    console.log('[Structure] Adding Delete at bottom')
+    result.push({ type: 'divider' })
+    result.push(deleteItem)
+  }
+
+  console.log('[Structure] Final result:', result.length)
+  console.log(
+    '[Structure] Final items:',
+    result.map((o) => o.label || o.type)
+  )
+  /* eslint-enable no-console */
+
+  return result
+}
+
+/**
+ * Convert LiteGraph IContextMenuValue items to Vue MenuOption format
+ * Used to bridge LiteGraph context menus into Vue node menus
+ * @param items - The LiteGraph menu items to convert
+ * @param node - The node context (optional)
+ * @param applyStructuring - Whether to apply menu structuring (core/extensions separation). Defaults to true.
+ */
+export function convertContextMenuToOptions(
+  items: (IContextMenuValue | null)[],
+  node?: any,
+  applyStructuring: boolean = true
+): MenuOption[] {
+  debug(
+    '[ContextMenuConverter] Converting context menu with',
+    items.length,
+    'items'
+  )
+  debug('[ContextMenuConverter] Items:', items)
+  debug('[ContextMenuConverter] Node context:', node)
+
+  const result: MenuOption[] = []
+
+  for (const item of items) {
+    // Null items are separators in LiteGraph
+    if (item === null) {
+      result.push({ type: 'divider' })
+      continue
+    }
+
+    // Skip items without content (shouldn't happen, but be safe)
+    if (!item.content) {
+      continue
+    }
+
+    // Skip hard blacklisted items
+    if (HARD_BLACKLIST.has(item.content)) {
+      debug(
+        '[ContextMenuConverter] Skipping hard blacklisted item:',
+        item.content
+      )
+      continue
+    }
+
+    // Skip if a similar item already exists in results
+    if (isDuplicateItem(item.content, result)) {
+      debug(
+        '[ContextMenuConverter] Skipping duplicate item:',
+        item.content,
+        '(similar item already exists)'
+      )
+      continue
+    }
+
+    const option: MenuOption = {
+      label: item.content,
+      source: 'litegraph'
+    }
+
+    // Pass through disabled state
+    if (item.disabled) {
+      option.disabled = true
+    }
+
+    // Handle submenus
+    if (item.has_submenu) {
+      // Static submenu with pre-defined options
+      if (item.submenu?.options) {
+        debug('[ContextMenuConverter] Static submenu detected:', item.content)
+        option.hasSubmenu = true
+        option.submenu = convertSubmenuToOptions(item.submenu.options)
+      }
+      // Dynamic submenu - callback creates it on-demand
+      else if (item.callback && !item.disabled) {
+        debug(
+          '[ContextMenuConverter] Dynamic submenu detected:',
+          item.content,
+          'callback:',
+          item.callback.name
+        )
+        option.hasSubmenu = true
+        // Intercept the callback to capture dynamic submenu items
+        const capturedSubmenu = captureDynamicSubmenu(item, node)
+        if (capturedSubmenu) {
+          debug(
+            '[ContextMenuConverter] Captured submenu items:',
+            capturedSubmenu.length,
+            'items for',
+            item.content
+          )
+          option.submenu = capturedSubmenu
+        } else {
+          console.warn(
+            '[ContextMenuConverter] Failed to capture submenu for:',
+            item.content
+          )
+        }
+      }
+    }
+    // Handle callback (only if not disabled and not a submenu)
+    else if (item.callback && !item.disabled) {
+      // Wrap the callback to match the () => void signature
+      option.action = () => {
+        try {
+          void item.callback?.call(
+            item as any,
+            item.value,
+            {},
+            null as any,
+            null as any,
+            item as any
+          )
+        } catch (error) {
+          console.error('Error executing context menu callback:', error)
+        }
+      }
+    }
+
+    result.push(option)
+  }
+
+  // Apply structured menu with core items and extensions section (if requested)
+  if (applyStructuring) {
+    return buildStructuredMenu(result)
+  }
+
+  return result
+}
+
+/**
+ * Capture submenu items from a dynamic submenu callback
+ * Intercepts ContextMenu constructor to extract items without creating HTML menu
+ */
+function captureDynamicSubmenu(
+  item: IContextMenuValue,
+  node?: any
+): SubMenuOption[] | undefined {
+  debug(
+    '[ContextMenuConverter] Starting capture for:',
+    item.content,
+    'item:',
+    item,
+    'node:',
+    node
+  )
+
+  let capturedItems: readonly (IContextMenuValue | string | null)[] | undefined
+  let capturedOptions: any
+
+  // Store original ContextMenu constructor
+  const OriginalContextMenu = LiteGraph.ContextMenu
+
+  try {
+    // Mock ContextMenu constructor to capture submenu items and options
+    LiteGraph.ContextMenu = function (
+      items: readonly (IContextMenuValue | string | null)[],
+      options?: any
+    ) {
+      debug(
+        '[ContextMenuConverter] ContextMenu constructor called with:',
+        items.length,
+        'items'
+      )
+      debug('[ContextMenuConverter] Raw items:', items)
+      debug('[ContextMenuConverter] Options:', options)
+      // Capture both items and options
+      capturedItems = items
+      capturedOptions = options
+      // Return a minimal mock object to prevent errors
+      return { close: () => {}, root: document.createElement('div') } as any
+    } as any
+
+    // Execute the callback to trigger submenu creation
+    try {
+      debug('[ContextMenuConverter] Executing callback:', item.callback?.name)
+
+      // Create a mock MouseEvent for the callback
+      const mockEvent = new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+        clientX: 0,
+        clientY: 0
+      })
+
+      // Create a mock parent menu
+      const mockMenu = {
+        close: () => {},
+        root: document.createElement('div')
+      } as any
+
+      // Call the callback which should trigger ContextMenu constructor
+      // Callback signature varies, but typically: (value, options, event, menu, node)
+      void item.callback?.call(
+        item as any,
+        item.value,
+        {},
+        mockEvent as any,
+        mockMenu,
+        node // Pass the node context for callbacks that need it
+      )
+
+      debug('[ContextMenuConverter] Callback executed successfully')
+    } catch (error) {
+      console.warn(
+        '[ContextMenuConverter] Error executing callback for:',
+        item.content,
+        error
+      )
+    }
+  } finally {
+    // Always restore original constructor
+    LiteGraph.ContextMenu = OriginalContextMenu
+    debug('[ContextMenuConverter] Restored original ContextMenu constructor')
+  }
+
+  // Convert captured items to Vue submenu format
+  if (capturedItems) {
+    debug(
+      '[ContextMenuConverter] Converting',
+      capturedItems.length,
+      'captured items to Vue format'
+    )
+    const converted = convertSubmenuToOptions(capturedItems, capturedOptions)
+    debug('[ContextMenuConverter] Converted result:', converted)
+    return converted
+  }
+
+  console.warn('[ContextMenuConverter] No items captured for:', item.content)
+  return undefined
+}
+
+/**
+ * Convert LiteGraph submenu items to Vue SubMenuOption format
+ */
+function convertSubmenuToOptions(
+  items: readonly (IContextMenuValue | string | null)[],
+  options?: any
+): SubMenuOption[] {
+  debug('[ContextMenuConverter] convertSubmenuToOptions called with:', items)
+  debug('[ContextMenuConverter] Options:', options)
+
+  const result: SubMenuOption[] = []
+
+  for (const item of items) {
+    // Skip null separators
+    if (item === null) {
+      debug('[ContextMenuConverter] Skipping null separator')
+      continue
+    }
+
+    // Handle string items (simple labels like in Mode/Shapes menus)
+    if (typeof item === 'string') {
+      debug('[ContextMenuConverter] Processing string item:', item)
+
+      const subOption: SubMenuOption = {
+        label: item,
+        action: () => {
+          try {
+            debug(
+              '[ContextMenuConverter] Executing string item action for:',
+              item
+            )
+            // Call the options callback with the string value
+            if (options?.callback) {
+              void options.callback.call(
+                null,
+                item,
+                options,
+                null,
+                null,
+                options.extra
+              )
+            }
+          } catch (error) {
+            console.error('Error executing string item callback:', error)
+          }
+        }
+      }
+
+      debug(
+        '[ContextMenuConverter] Created submenu option from string:',
+        subOption
+      )
+      result.push(subOption)
+      continue
+    }
+
+    // Handle object items
+    if (!item.content) {
+      debug('[ContextMenuConverter] Skipping item without content:', item)
+      continue
+    }
+
+    debug('[ContextMenuConverter] Processing object item:', {
+      content: item.content,
+      value: item.value,
+      disabled: item.disabled,
+      callback: item.callback?.name
+    })
+
+    // Extract text content from HTML if present
+    const content = stripHtmlTags(item.content)
+    debug('[ContextMenuConverter] Stripped HTML:', item.content, '->', content)
+
+    const subOption: SubMenuOption = {
+      label: content,
+      action: () => {
+        try {
+          debug(
+            '[ContextMenuConverter] Executing object item action for:',
+            content
+          )
+          void item.callback?.call(
+            item as any,
+            item.value,
+            {},
+            null as any,
+            null as any,
+            item as any
+          )
+        } catch (error) {
+          console.error('Error executing submenu callback:', error)
+        }
+      }
+    }
+
+    // Pass through disabled state
+    if (item.disabled) {
+      subOption.disabled = true
+    }
+
+    debug(
+      '[ContextMenuConverter] Created submenu option from object:',
+      subOption
+    )
+    result.push(subOption)
+  }
+
+  debug('[ContextMenuConverter] Final submenu options:', result)
+  return result
+}
+
+/**
+ * Strip HTML tags from content string
+ * LiteGraph menu items often include HTML for styling
+ */
+function stripHtmlTags(html: string): string {
+  // Create a temporary element to parse HTML
+  const temp = document.createElement('div')
+  temp.innerHTML = html
+  return temp.textContent || temp.innerText || html
+}
diff --git a/src/composables/graph/useMoreOptionsMenu.ts b/src/composables/graph/useMoreOptionsMenu.ts
index fcf8ab8c7d..00668e6fc5 100644
--- a/src/composables/graph/useMoreOptionsMenu.ts
+++ b/src/composables/graph/useMoreOptionsMenu.ts
@@ -2,8 +2,13 @@ import { computed, ref } from 'vue'
 import type { Ref } from 'vue'
 
 import type { LGraphGroup } from '@/lib/litegraph/src/litegraph'
+import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import { isLGraphGroup } from '@/utils/litegraphUtil'
 
+import {
+  buildStructuredMenu,
+  convertContextMenuToOptions
+} from './contextMenuConverter'
 import { useGroupMenuOptions } from './useGroupMenuOptions'
 import { useImageMenuOptions } from './useImageMenuOptions'
 import { useNodeMenuOptions } from './useNodeMenuOptions'
@@ -15,10 +20,12 @@ export interface MenuOption {
   icon?: string
   shortcut?: string
   hasSubmenu?: boolean
-  type?: 'divider'
+  type?: 'divider' | 'category'
   action?: () => void
   submenu?: SubMenuOption[]
   badge?: BadgeVariant
+  disabled?: boolean
+  source?: 'litegraph' | 'vue'
 }
 
 export interface SubMenuOption {
@@ -26,6 +33,7 @@ export interface SubMenuOption {
   icon?: string
   action: () => void
   color?: string
+  disabled?: boolean
 }
 
 export enum BadgeVariant {
@@ -74,6 +82,19 @@ export function registerNodeOptionsInstance(
   nodeOptionsInstance = instance
 }
 
+/**
+ * Mark menu options as coming from Vue hardcoded menu
+ */
+function markAsVueOptions(options: MenuOption[]): MenuOption[] {
+  return options.map((opt) => {
+    // Don't mark dividers or category labels
+    if (opt.type === 'divider' || opt.type === 'category') {
+      return opt
+    }
+    return { ...opt, source: 'vue' }
+  })
+}
+
 /**
  * Composable for managing the More Options menu configuration
  * Refactored to use smaller, focused composables for better maintainability
@@ -91,10 +112,11 @@ export function useMoreOptionsMenu() {
     computeSelectionFlags
   } = useSelectionState()
 
+  const canvasStore = useCanvasStore()
+
   const { getImageMenuOptions } = useImageMenuOptions()
   const {
     getNodeInfoOption,
-    getAdjustSizeOption,
     getNodeVisualOptions,
     getPinOption,
     getBypassOption,
@@ -102,16 +124,13 @@ export function useMoreOptionsMenu() {
   } = useNodeMenuOptions()
   const {
     getFitGroupToNodesOption,
-    getGroupShapeOptions,
     getGroupColorOptions,
     getGroupModeOptions
   } = useGroupMenuOptions()
   const {
     getBasicSelectionOptions,
     getSubgraphOptions,
-    getMultipleNodesOptions,
-    getDeleteOption,
-    getAlignmentOptions
+    getMultipleNodesOptions
   } = useSelectionMenuOptions()
 
   const hasSubgraphs = hasSubgraphsComputed
@@ -124,6 +143,7 @@ export function useMoreOptionsMenu() {
   }
 
   const menuOptions = computed((): MenuOption[] => {
+    /* eslint-disable no-console */
     // Reference selection flags to ensure re-computation when they change
     // eslint-disable-next-line @typescript-eslint/no-unused-expressions
     optionsVersion.value
@@ -138,80 +158,157 @@ export function useMoreOptionsMenu() {
         ? selectedGroups[0]
         : null
     const hasSubgraphsSelected = hasSubgraphs.value
+
+    // For single node selection, also get LiteGraph menu items to merge
+    const litegraphOptions: MenuOption[] = []
+    if (
+      selectedNodes.value.length === 1 &&
+      !groupContext &&
+      canvasStore.canvas
+    ) {
+      try {
+        const node = selectedNodes.value[0]
+        const rawItems = canvasStore.canvas.getNodeMenuOptions(node)
+        // Don't apply structuring yet - we'll do it after merging with Vue options
+        litegraphOptions.push(
+          ...convertContextMenuToOptions(rawItems, node, false)
+        )
+      } catch (error) {
+        console.error('Error getting LiteGraph menu items:', error)
+      }
+    }
+
     const options: MenuOption[] = []
 
+    console.log('[Menu] Building menu sections...')
+
     // Section 1: Basic selection operations (Rename, Copy, Duplicate)
-    options.push(...getBasicSelectionOptions())
+    const basicOps = getBasicSelectionOptions()
+    console.log(
+      '[Menu] Section 1 - Basic operations:',
+      basicOps.map((o) => o.label)
+    )
+    options.push(...basicOps)
     options.push({ type: 'divider' })
 
-    // Section 2: Node Info & Size Adjustment
-    if (nodeDef.value) {
-      options.push(getNodeInfoOption(showNodeHelp))
+    // Section 2: Node actions (Run Branch, Pin, Bypass, Mute)
+    console.log('[Menu] Section 2 - Node actions...')
+    if (hasOutputNodesSelected.value) {
+      const runBranch = getRunBranchOption()
+      console.log('[Menu]   - Run Branch:', runBranch.label)
+      options.push(runBranch)
+    }
+    if (!groupContext) {
+      const pin = getPinOption(states, bump)
+      const bypass = getBypassOption(states, bump)
+      console.log('[Menu]   - Pin:', pin.label)
+      console.log('[Menu]   - Bypass:', bypass.label)
+      options.push(pin)
+      options.push(bypass)
     }
-
     if (groupContext) {
-      options.push(getFitGroupToNodesOption(groupContext))
-    } else {
-      options.push(getAdjustSizeOption())
+      const groupModes = getGroupModeOptions(groupContext, bump)
+      console.log(
+        '[Menu]   - Group modes:',
+        groupModes.map((o) => o.label)
+      )
+      options.push(...groupModes)
     }
+    options.push({ type: 'divider' })
 
-    // Section 3: Collapse/Shape/Color
+    // Section 3: Structure operations (Convert to Subgraph, Frame selection, Minimize Node)
+    console.log('[Menu] Section 3 - Structure operations...')
+    const subgraphOps = getSubgraphOptions(hasSubgraphsSelected)
+    console.log(
+      '[Menu]   - Subgraph:',
+      subgraphOps.map((o) => o.label)
+    )
+    options.push(...subgraphOps)
+    if (hasMultipleNodes.value) {
+      const multiOps = getMultipleNodesOptions()
+      console.log(
+        '[Menu]   - Multiple nodes:',
+        multiOps.map((o) => o.label)
+      )
+      options.push(...multiOps)
+    }
     if (groupContext) {
-      // Group context: Shape, Color, Divider
-      options.push(getGroupShapeOptions(groupContext, bump))
-      options.push(getGroupColorOptions(groupContext, bump))
-      options.push({ type: 'divider' })
+      const fitGroup = getFitGroupToNodesOption(groupContext)
+      console.log('[Menu]   - Fit group:', fitGroup.label)
+      options.push(fitGroup)
     } else {
-      // Node context: Expand/Minimize, Shape, Color, Divider
-      options.push(...getNodeVisualOptions(states, bump))
-      options.push({ type: 'divider' })
+      // Add minimize/expand option only
+      const visualOptions = getNodeVisualOptions(states, bump)
+      if (visualOptions.length > 0) {
+        console.log('[Menu]   - Minimize/Expand:', visualOptions[0].label)
+        options.push(visualOptions[0]) // Minimize/Expand
+      }
     }
+    options.push({ type: 'divider' })
 
-    // Section 4: Image operations (if image node)
-    if (hasImageNode.value && selectedNodes.value.length > 0) {
-      options.push(...getImageMenuOptions(selectedNodes.value[0]))
+    // Section 4: Node properties (Node Info, Color)
+    console.log('[Menu] Section 4 - Node properties...')
+    if (nodeDef.value) {
+      const nodeInfo = getNodeInfoOption(showNodeHelp)
+      console.log('[Menu]   - Node Info:', nodeInfo.label)
+      options.push(nodeInfo)
     }
-
-    // Section 5: Subgraph operations
-    options.push(...getSubgraphOptions(hasSubgraphsSelected))
-
-    // Section 6: Multiple nodes operations
-    if (hasMultipleNodes.value) {
-      options.push(...getMultipleNodesOptions())
+    if (groupContext) {
+      const groupColor = getGroupColorOptions(groupContext, bump)
+      console.log('[Menu]   - Group Color:', groupColor.label)
+      options.push(groupColor)
+    } else {
+      // Add color option only (not shape)
+      const visualOptions = getNodeVisualOptions(states, bump)
+      if (visualOptions.length > 2) {
+        console.log('[Menu]   - Color:', visualOptions[2].label)
+        options.push(visualOptions[2]) // Color (index 2)
+      }
     }
-
-    // Section 7: Divider
     options.push({ type: 'divider' })
 
-    // Section 8: Pin/Unpin (non-group only)
-    if (!groupContext) {
-      options.push(getPinOption(states, bump))
+    // Section 5: Node-specific options (image operations)
+    if (hasImageNode.value && selectedNodes.value.length > 0) {
+      const imageOps = getImageMenuOptions(selectedNodes.value[0])
+      console.log(
+        '[Menu] Section 5 - Image operations:',
+        imageOps.map((o) => o.label)
+      )
+      options.push(...imageOps)
+      options.push({ type: 'divider' })
     }
 
-    // Section 9: Alignment (if multiple nodes)
-    if (hasMultipleNodes.value) {
-      options.push(...getAlignmentOptions())
-    }
+    console.log('[Menu] Total Vue options before marking:', options.length)
 
-    // Section 10: Mode operations
-    if (groupContext) {
-      // Group mode operations
-      options.push(...getGroupModeOptions(groupContext, bump))
-    } else {
-      // Bypass option for nodes
-      options.push(getBypassOption(states, bump))
-    }
+    // Section 6 & 7: Extensions and Delete are handled by buildStructuredMenu
 
-    // Section 11: Run Branch (if output nodes)
-    if (hasOutputNodesSelected.value) {
-      options.push(getRunBranchOption())
-    }
+    // Mark all Vue options with source
+    const markedVueOptions = markAsVueOptions(options)
+    console.log('[Menu] Marked Vue options:', markedVueOptions.length)
 
-    // Section 12: Final divider and Delete
-    options.push({ type: 'divider' })
-    options.push(getDeleteOption())
+    // For single node selection, merge LiteGraph options with Vue options
+    // Vue options will take precedence during deduplication in buildStructuredMenu
+    if (litegraphOptions.length > 0) {
+      console.log(
+        '[Menu] Merging with LiteGraph options:',
+        litegraphOptions.length
+      )
+      console.log(
+        '[Menu] LiteGraph items:',
+        litegraphOptions.map((o) => o.label || o.type)
+      )
+      // Merge: LiteGraph options first, then Vue options (Vue will win in dedup)
+      const merged = [...litegraphOptions, ...markedVueOptions]
+      console.log('[Menu] Merged total:', merged.length)
+      // Now apply structuring (which includes deduplication with Vue precedence)
+      return buildStructuredMenu(merged)
+    }
 
-    return options
+    console.log('[Menu] No LiteGraph options, using Vue only')
+    // For other cases, structure the Vue options
+    const result = buildStructuredMenu(markedVueOptions)
+    /* eslint-enable no-console */
+    return result
   })
 
   // Computed property to get only menu items with submenus
diff --git a/src/composables/graph/useViewportAwareMenuPositioning.ts b/src/composables/graph/useViewportAwareMenuPositioning.ts
new file mode 100644
index 0000000000..2d10d4f921
--- /dev/null
+++ b/src/composables/graph/useViewportAwareMenuPositioning.ts
@@ -0,0 +1,75 @@
+interface MenuPositionStyle {
+  position: 'fixed'
+  left: string
+  top?: string
+  bottom?: string
+  transform: string
+}
+
+interface MenuPositionOptions {
+  /** The trigger element that opened the menu */
+  triggerRect: DOMRect
+  /** The menu overlay element */
+  menuElement: HTMLElement
+  /** Whether the menu was triggered by the toolbox button */
+  isTriggeredByToolbox: boolean
+  /** Margin from trigger element */
+  marginY?: number
+}
+
+/**
+ * Calculates viewport-aware menu positioning that prevents overflow.
+ * When a menu would overflow the bottom of the viewport, it docks to the bottom instead.
+ *
+ * @returns Positioning style properties to apply to the menu element
+ */
+export function calculateMenuPosition(
+  options: MenuPositionOptions
+): MenuPositionStyle {
+  const {
+    triggerRect,
+    menuElement,
+    isTriggeredByToolbox,
+    marginY = 8
+  } = options
+
+  // Calculate horizontal position (same as before)
+  const left = isTriggeredByToolbox
+    ? triggerRect.left + triggerRect.width / 2
+    : triggerRect.right - triggerRect.width / 4
+
+  // Calculate initial top position
+  const initialTop = isTriggeredByToolbox
+    ? triggerRect.bottom + marginY
+    : triggerRect.top - marginY - 6
+
+  // Get menu dimensions
+  const menuHeight = menuElement.offsetHeight || menuElement.scrollHeight
+  const viewportHeight = window.innerHeight
+
+  // Calculate available space below the trigger point
+  const spaceBelow = viewportHeight - initialTop
+
+  // Check if menu would overflow viewport bottom
+  const wouldOverflow = menuHeight > spaceBelow
+
+  const baseStyle: MenuPositionStyle = {
+    position: 'fixed',
+    left: `${left}px`,
+    transform: 'translate(-50%, 0)'
+  }
+
+  if (wouldOverflow) {
+    // Dock to bottom of viewport
+    return {
+      ...baseStyle,
+      bottom: '0px'
+    }
+  } else {
+    // Position below trigger as normal
+    return {
+      ...baseStyle,
+      top: `${initialTop}px`
+    }
+  }
+}
diff --git a/src/composables/useContextMenuTranslation.ts b/src/composables/useContextMenuTranslation.ts
index cfcf5c809f..009ca3992a 100644
--- a/src/composables/useContextMenuTranslation.ts
+++ b/src/composables/useContextMenuTranslation.ts
@@ -58,6 +58,9 @@ export const useContextMenuTranslation = () => {
     LGraphCanvas.prototype
   )
 
+  // Install compatibility layer for getNodeMenuOptions
+  legacyMenuCompat.install(LGraphCanvas.prototype, 'getNodeMenuOptions')
+
   // Wrap getNodeMenuOptions to add new API items
   const nodeMenuFn = LGraphCanvas.prototype.getNodeMenuOptions
   const getNodeMenuOptionsWithExtensions = function (
@@ -73,11 +76,30 @@ export const useContextMenuTranslation = () => {
       res.push(item)
     }
 
+    // Add legacy monkey-patched items
+    const legacyItems = legacyMenuCompat.extractLegacyItems(
+      'getNodeMenuOptions',
+      this,
+      ...args
+    )
+    for (const item of legacyItems) {
+      res.push(item)
+    }
+
     return res
   }
 
   LGraphCanvas.prototype.getNodeMenuOptions = getNodeMenuOptionsWithExtensions
 
+  legacyMenuCompat.registerWrapper(
+    'getNodeMenuOptions',
+    getNodeMenuOptionsWithExtensions as (
+      ...args: unknown[]
+    ) => IContextMenuValue[],
+    nodeMenuFn as (...args: unknown[]) => IContextMenuValue[],
+    LGraphCanvas.prototype
+  )
+
   function translateMenus(
     values: readonly (IContextMenuValue | string | null)[] | undefined,
     options: IContextMenuOptions
diff --git a/src/locales/en/main.json b/src/locales/en/main.json
index 63a509b427..2c35214997 100644
--- a/src/locales/en/main.json
+++ b/src/locales/en/main.json
@@ -420,7 +420,8 @@
     "Horizontal": "Horizontal",
     "Vertical": "Vertical",
     "new": "new",
-    "deprecated": "deprecated"
+    "deprecated": "deprecated",
+    "Extensions": "Extensions"
   },
   "icon": {
     "bookmark": "Bookmark",