diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8223c5f6da5c..1d2c936456cd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,12 +9,15 @@
 - [Copy-pasting multiple nodes][10194].
 - The documentation editor has [formatting toolbars][10064].
 - The documentation editor supports [rendering images][10205].
+- [Fixed a bug where drop-down were not displayed for some arguments][10297].
+  For example, `locale` parameter of `Equal_Ignore_Case` kind in join component.
 
 [10064]: https://github.com/enso-org/enso/pull/10064
 [10179]: https://github.com/enso-org/enso/pull/10179
 [10194]: https://github.com/enso-org/enso/pull/10194
 [10198]: https://github.com/enso-org/enso/pull/10198
 [10205]: https://github.com/enso-org/enso/pull/10205
+[10297]: https://github.com/enso-org/enso/pull/10297
 
 #### Enso Standard Library
 
diff --git a/app/gui2/mock/engine.ts b/app/gui2/mock/engine.ts
index 83324aa0f7a8..2adc5dc7b0e7 100644
--- a/app/gui2/mock/engine.ts
+++ b/app/gui2/mock/engine.ts
@@ -170,13 +170,96 @@ const mockVizPreprocessors: Record<string, Uint8Array | ((params: string[]) => U
     'warning 1',
     "warning 2!!&<>;'\x22",
   ]),
-  'Standard.Visualization.Widgets.get_widget_json': (params) => {
-    switch (params[0]) {
-      case '.read':
-        return encodeJSON([
-          [
-            'path',
-            {
+  'Standard.Visualization.Widgets.get_widget_json': (params) => mockWidgetConfiguration(params[0]),
+
+  // The following visualizations do not have unique transformation methods, and as such are only kept
+  // for posterity.
+  Image: encodeJSON({
+    mediaType: 'image/svg+xml',
+    base64: `PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI0MCIgaGVpZ2h0PSI0\
+MCI+PGcgY2xpcC1wYXRoPSJ1cmwoI2EpIj48cGF0aCBkPSJNMjAuMDUgMEEyMCAyMCAwIDAgMCAwIDIwLjA1IDIwLjA2IDIwLjA\
+2IDAgMSAwIDIwLjA1IDBabTAgMzYuMDVjLTguOTMgMC0xNi4xLTcuMTctMTYuMS0xNi4xIDAtOC45NCA3LjE3LTE2LjEgMTYuMS\
+0xNi4xIDguOTQgMCAxNi4xIDcuMTYgMTYuMSAxNi4xYTE2LjE4IDE2LjE4IDAgMCAxLTE2LjEgMTYuMVoiLz48cGF0aCBkPSJNM\
+jcuMTIgMTcuNzdhNC42OCA0LjY4IDAgMCAxIDIuMzkgNS45MiAxMC4yMiAxMC4yMiAwIDAgMS05LjU2IDYuODZBMTAuMiAxMC4y\
+IDAgMCAxIDkuNzcgMjAuMzZzMS41NSAyLjA4IDQuNTcgMi4wOGMzLjAxIDAgNC4zNi0xLjE0IDUuNi0yLjA4IDEuMjUtLjkzIDI\
+uMDktMyA1LjItMyAuNzMgMCAxLjQ2LjIgMS45OC40WiIvPjwvZz48ZGVmcz48Y2xpcFBhdGggaWQ9ImEiPjxwYXRoIGZpbGw9Ii\
+NmZmYiIGQ9Ik0wIDBoNDB2NDBIMHoiLz48L2NsaXBQYXRoPjwvZGVmcz48L3N2Zz4=`,
+  }),
+  Heatmap: encodeJSON([
+    ['A', 'B', 'C', 'D', 'A'],
+    ['D', 'E', 'D', 'X', 'Z'],
+    [50, 25, 40, 20, 10],
+  ]),
+}
+
+function mockWidgetConfiguration(method: string | undefined) {
+  switch (method) {
+    case '.read':
+      return encodeJSON([
+        [
+          'path',
+          {
+            type: 'Widget',
+            constructor: 'Single_Choice',
+            label: null,
+            values: [
+              {
+                type: 'Choice',
+                constructor: 'Option',
+                value: '"File 1"',
+                label: 'File 1',
+                parameters: [],
+              },
+              {
+                type: 'Choice',
+                constructor: 'Option',
+                value: '"File 2"',
+                label: 'File 2',
+                parameters: [],
+              },
+            ],
+            display: { type: 'Display', constructor: 'Always' },
+          },
+        ],
+      ])
+    case '.select_columns':
+      return encodeJSON([
+        [
+          'columns',
+          {
+            type: 'Widget',
+            constructor: 'Multiple_Choice',
+            label: null,
+            values: [
+              {
+                type: 'Choice',
+                constructor: 'Option',
+                value: "'Column A'",
+                label: 'Column A',
+                parameters: [],
+              },
+              {
+                type: 'Choice',
+                constructor: 'Option',
+                value: "'Column B'",
+                label: 'Column B',
+                parameters: [],
+              },
+            ],
+            display: { type: 'Display', constructor: 'Always' },
+          },
+        ],
+      ])
+    case '.aggregate':
+      return encodeJSON([
+        [
+          'columns',
+          {
+            type: 'Widget',
+            constructor: 'Vector_Editor',
+            /* eslint-disable camelcase */
+            item_default: 'Aggregate_Column.Group_By',
+            item_editor: {
               type: 'Widget',
               constructor: 'Single_Choice',
               label: null,
@@ -184,168 +267,87 @@ const mockVizPreprocessors: Record<string, Uint8Array | ((params: string[]) => U
                 {
                   type: 'Choice',
                   constructor: 'Option',
-                  value: '"File 1"',
-                  label: 'File 1',
-                  parameters: [],
+                  value: 'Standard.Table.Aggregate_Column.Aggregate_Column.Group_By',
+                  label: null,
+                  parameters: [
+                    [
+                      'column',
+                      {
+                        type: 'Widget',
+                        constructor: 'Single_Choice',
+                        label: null,
+                        values: [
+                          {
+                            type: 'Choice',
+                            constructor: 'Option',
+                            value: '"column 1"',
+                            label: 'column 1',
+                            parameters: [],
+                          },
+                          {
+                            type: 'Choice',
+                            constructor: 'Option',
+                            value: '"column 2"',
+                            label: 'column 2',
+                            parameters: [],
+                          },
+                        ],
+                        display: { type: 'Display', constructor: 'Always' },
+                      },
+                    ],
+                  ],
                 },
                 {
                   type: 'Choice',
                   constructor: 'Option',
-                  value: '"File 2"',
-                  label: 'File 2',
-                  parameters: [],
-                },
-              ],
-              display: { type: 'Display', constructor: 'Always' },
-            },
-          ],
-        ])
-      case '.select_columns':
-        return encodeJSON([
-          [
-            'columns',
-            {
-              type: 'Widget',
-              constructor: 'Multiple_Choice',
-              label: null,
-              values: [
-                {
-                  type: 'Choice',
-                  constructor: 'Option',
-                  value: "'Column A'",
-                  label: 'Column A',
+                  value: 'Standard.Table.Aggregate_Column.Aggregate_Column.Count',
+                  label: null,
                   parameters: [],
                 },
                 {
                   type: 'Choice',
                   constructor: 'Option',
-                  value: "'Column B'",
-                  label: 'Column B',
-                  parameters: [],
+                  value: 'Standard.Table.Aggregate_Column.Aggregate_Column.Count_Distinct',
+                  label: null,
+                  parameters: [
+                    [
+                      'columns',
+                      {
+                        type: 'Widget',
+                        constructor: 'Single_Choice',
+                        label: null,
+                        values: [
+                          {
+                            type: 'Choice',
+                            constructor: 'Option',
+                            value: '"column 1"',
+                            label: 'column 1',
+                            parameters: [],
+                          },
+                          {
+                            type: 'Choice',
+                            constructor: 'Option',
+                            value: '"column 2"',
+                            label: 'column 2',
+                            parameters: [],
+                          },
+                        ],
+                        display: { type: 'Display', constructor: 'Always' },
+                      },
+                    ],
+                  ],
                 },
               ],
               display: { type: 'Display', constructor: 'Always' },
             },
-          ],
-        ])
-      case '.aggregate':
-        return encodeJSON([
-          [
-            'columns',
-            {
-              type: 'Widget',
-              constructor: 'Vector_Editor',
-              /* eslint-disable camelcase */
-              item_default: 'Aggregate_Column.Group_By',
-              item_editor: {
-                type: 'Widget',
-                constructor: 'Single_Choice',
-                label: null,
-                values: [
-                  {
-                    type: 'Choice',
-                    constructor: 'Option',
-                    value: 'Standard.Table.Aggregate_Column.Aggregate_Column.Group_By',
-                    label: null,
-                    parameters: [
-                      [
-                        'column',
-                        {
-                          type: 'Widget',
-                          constructor: 'Single_Choice',
-                          label: null,
-                          values: [
-                            {
-                              type: 'Choice',
-                              constructor: 'Option',
-                              value: '"column 1"',
-                              label: 'column 1',
-                              parameters: [],
-                            },
-                            {
-                              type: 'Choice',
-                              constructor: 'Option',
-                              value: '"column 2"',
-                              label: 'column 2',
-                              parameters: [],
-                            },
-                          ],
-                          display: { type: 'Display', constructor: 'Always' },
-                        },
-                      ],
-                    ],
-                  },
-                  {
-                    type: 'Choice',
-                    constructor: 'Option',
-                    value: 'Standard.Table.Aggregate_Column.Aggregate_Column.Count',
-                    label: null,
-                    parameters: [],
-                  },
-                  {
-                    type: 'Choice',
-                    constructor: 'Option',
-                    value: 'Standard.Table.Aggregate_Column.Aggregate_Column.Count_Distinct',
-                    label: null,
-                    parameters: [
-                      [
-                        'columns',
-                        {
-                          type: 'Widget',
-                          constructor: 'Single_Choice',
-                          label: null,
-                          values: [
-                            {
-                              type: 'Choice',
-                              constructor: 'Option',
-                              value: '"column 1"',
-                              label: 'column 1',
-                              parameters: [],
-                            },
-                            {
-                              type: 'Choice',
-                              constructor: 'Option',
-                              value: '"column 2"',
-                              label: 'column 2',
-                              parameters: [],
-                            },
-                          ],
-                          display: { type: 'Display', constructor: 'Always' },
-                        },
-                      ],
-                    ],
-                  },
-                ],
-                display: { type: 'Display', constructor: 'Always' },
-              },
-              /* eslint-enable camelcase */
-              display: { type: 'Display', constructor: 'Always' },
-            },
-          ],
-        ])
-      default:
-        return encodeJSON([])
-    }
-  },
-
-  // The following visualizations do not have unique transformation methods, and as such are only kept
-  // for posterity.
-  Image: encodeJSON({
-    mediaType: 'image/svg+xml',
-    base64: `PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI0MCIgaGVpZ2h0PSI0\
-MCI+PGcgY2xpcC1wYXRoPSJ1cmwoI2EpIj48cGF0aCBkPSJNMjAuMDUgMEEyMCAyMCAwIDAgMCAwIDIwLjA1IDIwLjA2IDIwLjA\
-2IDAgMSAwIDIwLjA1IDBabTAgMzYuMDVjLTguOTMgMC0xNi4xLTcuMTctMTYuMS0xNi4xIDAtOC45NCA3LjE3LTE2LjEgMTYuMS\
-0xNi4xIDguOTQgMCAxNi4xIDcuMTYgMTYuMSAxNi4xYTE2LjE4IDE2LjE4IDAgMCAxLTE2LjEgMTYuMVoiLz48cGF0aCBkPSJNM\
-jcuMTIgMTcuNzdhNC42OCA0LjY4IDAgMCAxIDIuMzkgNS45MiAxMC4yMiAxMC4yMiAwIDAgMS05LjU2IDYuODZBMTAuMiAxMC4y\
-IDAgMCAxIDkuNzcgMjAuMzZzMS41NSAyLjA4IDQuNTcgMi4wOGMzLjAxIDAgNC4zNi0xLjE0IDUuNi0yLjA4IDEuMjUtLjkzIDI\
-uMDktMyA1LjItMyAuNzMgMCAxLjQ2LjIgMS45OC40WiIvPjwvZz48ZGVmcz48Y2xpcFBhdGggaWQ9ImEiPjxwYXRoIGZpbGw9Ii\
-NmZmYiIGQ9Ik0wIDBoNDB2NDBIMHoiLz48L2NsaXBQYXRoPjwvZGVmcz48L3N2Zz4=`,
-  }),
-  Heatmap: encodeJSON([
-    ['A', 'B', 'C', 'D', 'A'],
-    ['D', 'E', 'D', 'X', 'Z'],
-    [50, 25, 40, 20, 10],
-  ]),
+            /* eslint-enable camelcase */
+            display: { type: 'Display', constructor: 'Always' },
+          },
+        ],
+      ])
+    default:
+      return encodeJSON([])
+  }
 }
 
 function createMessageId(builder: Builder) {
@@ -361,11 +363,13 @@ function createId(id: Uuid) {
 
 function sendVizData(id: Uuid, config: VisualizationConfiguration, expressionId?: Uuid) {
   const vizDataHandler =
-    mockVizPreprocessors[
-      typeof config.expression === 'string' ?
-        `${config.visualizationModule}.${config.expression}`
-      : `${config.expression.definedOnType}.${config.expression.name}`
-    ]
+    typeof config.expression === 'string' ?
+      // Getting widget configuration is a special case, where we sometimes pass lambda as
+      // expression to discard the input value
+      /^[a-z_]+ *->.*get_widget_json/.test(config.expression) ?
+        mockWidgetConfiguration(config.positionalArgumentsExpressions?.at(0))
+      : mockVizPreprocessors[`${config.visualizationModule}.${config.expression}`]
+    : mockVizPreprocessors[`${config.expression.definedOnType}.${config.expression.name}`]
   if (!vizDataHandler || !sendData) return
   const vizData =
     vizDataHandler instanceof Uint8Array ? vizDataHandler : (
diff --git a/app/gui2/src/components/GraphEditor/widgets/WidgetFunction.vue b/app/gui2/src/components/GraphEditor/widgets/WidgetFunction.vue
index 084f795f34d9..2229af583b50 100644
--- a/app/gui2/src/components/GraphEditor/widgets/WidgetFunction.vue
+++ b/app/gui2/src/components/GraphEditor/widgets/WidgetFunction.vue
@@ -1,5 +1,7 @@
 <script setup lang="ts">
 import NodeWidget from '@/components/GraphEditor/NodeWidget.vue'
+import { useWidgetFunctionCallInfo } from '@/components/GraphEditor/widgets/WidgetFunction/widgetFunctionCallInfo'
+import { FunctionName } from '@/components/GraphEditor/widgets/WidgetFunctionName.vue'
 import { injectFunctionInfo, provideFunctionInfo } from '@/providers/functionInfo'
 import {
   Score,
@@ -8,14 +10,8 @@ import {
   widgetProps,
   type WidgetUpdate,
 } from '@/providers/widgetRegistry'
-import {
-  argsWidgetConfigurationSchema,
-  functionCallConfiguration,
-} from '@/providers/widgetRegistry/configuration'
 import { useGraphStore } from '@/stores/graph'
 import { useProjectStore } from '@/stores/project'
-import { type NodeVisualizationConfiguration } from '@/stores/project/executionContext'
-import { entryQn } from '@/stores/suggestionDatabase/entry'
 import { assert, assertUnreachable } from '@/util/assert'
 import { Ast } from '@/util/ast'
 import type { AstId } from '@/util/ast/abstract'
@@ -24,16 +20,11 @@ import {
   ArgumentApplicationKey,
   ArgumentAst,
   ArgumentPlaceholder,
-  getAccessOprSubject,
   getMethodCallInfoRecursively,
-  interpretCall,
 } from '@/util/callTree'
 import { partitionPoint } from '@/util/data/array'
-import type { Opt } from '@/util/data/opt'
 import { isIdentifier } from '@/util/qualifiedName.ts'
-import type { ExternalId } from 'shared/yjsModel.ts'
 import { computed, proxyRefs } from 'vue'
-import { FunctionName } from './WidgetFunctionName.vue'
 
 const props = defineProps(widgetProps(widgetDefinition))
 const graph = useGraphStore()
@@ -53,51 +44,11 @@ provideFunctionInfo(
   }),
 )
 
-const methodCallInfo = computed(() => {
-  return getMethodCallInfoRecursively(props.input.value, graph.db)
-})
-
-const interpreted = computed(() => {
-  return interpretCall(props.input.value, methodCallInfo.value == null)
-})
-
-const subjectInfo = computed(() => {
-  const analyzed = interpreted.value
-  if (analyzed.kind !== 'prefix') return
-  const subject = getAccessOprSubject(analyzed.func)
-  if (!subject) return
-  return graph.db.getExpressionInfo(subject.id)
-})
-
-const selfArgumentPreapplied = computed(() => {
-  const info = methodCallInfo.value
-  const funcType = info?.methodCall.methodPointer.definedOnType
-  return funcType != null && subjectInfo.value?.typename !== `${funcType}.type`
-})
-
-const subjectTypeMatchesMethod = computed(() => {
-  const funcType = methodCallInfo.value?.methodCall.methodPointer.definedOnType
-  return funcType != null && subjectInfo.value?.typename === `${funcType}.type`
-})
-
-const application = computed(() => {
-  const call = interpreted.value
-  if (!call) return null
-  const noArgsCall = call.kind === 'prefix' ? graph.db.getMethodCall(call.func.id) : undefined
-
-  return ArgumentApplication.FromInterpretedWithInfo(call, {
-    suggestion: methodCallInfo.value?.suggestion,
-    widgetCfg: widgetConfiguration.value,
-    subjectAsSelf: selfArgumentPreapplied.value,
-    notAppliedArguments:
-      (
-        noArgsCall != null &&
-        (!subjectTypeMatchesMethod.value || noArgsCall.notAppliedArguments.length > 0)
-      ) ?
-        noArgsCall.notAppliedArguments
-      : undefined,
-  })
-})
+const { methodCallInfo, application } = useWidgetFunctionCallInfo(
+  () => props.input,
+  graph.db,
+  project,
+)
 
 const innerInput = computed(() => {
   if (application.value instanceof ArgumentApplication) {
@@ -115,80 +66,6 @@ const innerInput = computed(() => {
   return props.input
 })
 
-const selfArgumentExternalId = computed<Opt<ExternalId>>(() => {
-  const analyzed = interpretCall(props.input.value, true)
-  if (analyzed.kind === 'infix') {
-    return analyzed.lhs?.externalId
-  } else {
-    const knownArguments = methodCallInfo.value?.suggestion?.arguments
-    const hasSelfArgument = knownArguments?.[0]?.name === 'self'
-    const selfArgument =
-      hasSelfArgument && !selfArgumentPreapplied.value ?
-        analyzed.args.find((a) => a.argName === 'self' || a.argName == null)?.argument
-      : getAccessOprSubject(analyzed.func) ?? analyzed.args[0]?.argument
-
-    return selfArgument?.externalId
-  }
-})
-
-const visualizationConfig = computed<Opt<NodeVisualizationConfiguration>>(() => {
-  // Even if we inherit dynamic config in props.input.dynamicConfig, we should also read it for
-  // the current call and then merge them.
-
-  let m = ArgumentApplication.collectArgumentNamesAndUuids(interpreted.value, methodCallInfo.value)
-
-  const expressionId = selfArgumentExternalId.value
-  const astId = props.input.value.id
-  if (astId == null || expressionId == null) return null
-  const info = methodCallInfo.value
-  if (!info) return null
-  const args = info.suggestion.annotations
-  if (args.length === 0) return null
-  const name = info.suggestion.name
-  return {
-    expressionId,
-    visualizationModule: 'Standard.Visualization.Widgets',
-    expression: {
-      module: 'Standard.Visualization.Widgets',
-      definedOnType: 'Standard.Visualization.Widgets',
-      name: 'get_widget_json',
-    },
-    positionalArgumentsExpressions: [
-      `.${name}`,
-      Ast.Vector.build(args, Ast.TextLiteral.new).code(),
-      Ast.TextLiteral.new(JSON.stringify(m)).code(),
-    ],
-  }
-})
-
-const inheritedConfig = computed(() => {
-  if (props.input.dynamicConfig?.kind === 'FunctionCall') return props.input.dynamicConfig
-  if (props.input.dynamicConfig?.kind === 'OneOfFunctionCalls' && methodCallInfo.value != null) {
-    const cfg = props.input.dynamicConfig
-    const info = methodCallInfo.value
-    const fullName = entryQn(info?.suggestion)
-    const autoscopedName = '..' + info?.suggestion.name
-    return cfg.possibleFunctions.get(fullName) ?? cfg.possibleFunctions.get(autoscopedName)
-  }
-  return undefined
-})
-
-const visualizationData = project.useVisualizationData(visualizationConfig)
-const widgetConfiguration = computed(() => {
-  const data = visualizationData.value
-  if (data?.ok) {
-    const parseResult = argsWidgetConfigurationSchema.safeParse(data.value)
-    if (parseResult.success) {
-      return functionCallConfiguration(parseResult.data, inheritedConfig.value)
-    } else {
-      console.error('Unable to parse widget configuration.', data, parseResult.error)
-    }
-  } else if (data != null && !data.ok) {
-    data.error.log('Cannot load dynamic configuration')
-  }
-  return inheritedConfig.value
-})
-
 /**
  * Process an argument value update. Takes care of inserting assigned placeholder values, as well as
  * handling deletions of arguments and rewriting the applications to named as appropriate.
diff --git a/app/gui2/src/components/GraphEditor/widgets/WidgetFunction/__tests__/widgetFunctionCallInfo.test.ts b/app/gui2/src/components/GraphEditor/widgets/WidgetFunction/__tests__/widgetFunctionCallInfo.test.ts
new file mode 100644
index 000000000000..42fb050fcc20
--- /dev/null
+++ b/app/gui2/src/components/GraphEditor/widgets/WidgetFunction/__tests__/widgetFunctionCallInfo.test.ts
@@ -0,0 +1,112 @@
+import { WidgetInput } from '@/providers/widgetRegistry'
+import { parseWithSpans } from '@/stores/graph/__tests__/graphDatabase.test'
+import type { NodeVisualizationConfiguration } from '@/stores/project/executionContext'
+import {
+  entryMethodPointer,
+  makeArgument,
+  makeConstructor,
+  makeMethod,
+  makeStaticMethod,
+} from '@/stores/suggestionDatabase/entry'
+import { assert } from '@/util/assert'
+import type { Opt } from 'shared/util/data/opt'
+import { expect, test } from 'vitest'
+import { ref, type Ref } from 'vue'
+import {
+  GET_WIDGETS_METHOD,
+  WIDGETS_ENSO_MODULE,
+  useWidgetFunctionCallInfo,
+} from '../widgetFunctionCallInfo'
+
+const moduleMethod = {
+  ...makeMethod('local.Project.module_method', 'Text'),
+  arguments: [makeArgument('arg')],
+  annotations: ['arg'],
+}
+const con = {
+  ...makeConstructor('local.Project.Type.Con'),
+  arguments: [makeArgument('arg')],
+  annotations: ['arg'],
+}
+const method = {
+  ...makeMethod('local.Project.Type.method', 'Text'),
+  arguments: [makeArgument('self'), makeArgument('arg')],
+  annotations: ['arg'],
+}
+const staticMethod = {
+  ...makeStaticMethod('local.Project.Type.static_method', 'Text'),
+  arguments: [makeArgument('arg')],
+  annotations: ['arg'],
+}
+
+test.each`
+  code                                       | callSuggestion  | subjectSpan | selfSpan    | subjectType                  | methodName
+  ${'val1.method val2'}                      | ${method}       | ${[0, 4]}   | ${[0, 4]}   | ${'local.Project.Type'}      | ${'.method'}
+  ${'local.Project.Type.method val1 val2'}   | ${method}       | ${[0, 18]}  | ${[26, 30]} | ${'local.Project.Type.type'} | ${'.method'}
+  ${'Type.method val1'}                      | ${method}       | ${[0, 4]}   | ${[12, 16]} | ${'local.Project.Type.type'} | ${'.method'}
+  ${'local.Project.Type.method'}             | ${method}       | ${[0, 18]}  | ${[0, 18]}  | ${'local.Project.Type.type'} | ${'.method'}
+  ${'local.Project.Type.static_method val1'} | ${staticMethod} | ${[0, 18]}  | ${[0, 18]}  | ${'local.Project.Type.type'} | ${'.static_method'}
+  ${'Type.Con val1'}                         | ${con}          | ${[0, 4]}   | ${[0, 4]}   | ${'local.Project.Type.type'} | ${'.Con'}
+  ${'..Con val1'}                            | ${con}          | ${null}     | ${null}     | ${null}                      | ${'.Con'}
+  ${'local.Project.module_method val1'}      | ${moduleMethod} | ${[0, 13]}  | ${[0, 13]}  | ${'local.Project'}           | ${'.module_method'}
+`(
+  'Visualization config for $code',
+  ({ code, callSuggestion, subjectSpan, selfSpan, subjectType, methodName }) => {
+    const spans = {
+      entireFunction: [0, code.length] as [number, number],
+      ...(subjectSpan != null ? { subject: subjectSpan as [number, number] } : {}),
+      ...(selfSpan != null ? { self: selfSpan as [number, number] } : {}),
+    }
+    const { ast, eid, id } = parseWithSpans(code, spans)
+    const line = ast.lines[0]?.expression
+    assert(line != null)
+    expect(line.node.externalId).toBe(eid('entireFunction'))
+
+    let visConfig: Ref<Opt<NodeVisualizationConfiguration>> | undefined
+    useWidgetFunctionCallInfo(
+      WidgetInput.FromAst(line.node),
+      {
+        getMethodCallInfo(astId) {
+          if (astId === id('entireFunction')) {
+            return {
+              suggestion: callSuggestion,
+              methodCall: {
+                notAppliedArguments: [],
+                methodPointer: entryMethodPointer(callSuggestion)!,
+              },
+            }
+          }
+        },
+        getExpressionInfo(astId) {
+          if (subjectSpan != null && astId === id('subject')) {
+            return {
+              typename: subjectType,
+              methodCall: undefined,
+              payload: { type: 'Value' },
+              profilingInfo: [],
+            }
+          }
+        },
+      },
+      {
+        useVisualizationData(config) {
+          expect(visConfig, 'Only one visualizaiton is expected').toBeUndefined()
+          visConfig = config
+          return ref(null)
+        },
+      },
+    )
+    assert(visConfig != null)
+    assert(visConfig.value != null)
+    if (typeof visConfig.value.expression === 'string') {
+      expect(visConfig.value.expressionId).toBe(eid('entireFunction'))
+      expect(visConfig.value.expression).toBe(
+        `_ -> ${WIDGETS_ENSO_MODULE}.${GET_WIDGETS_METHOD} ${callSuggestion.definedIn}`,
+      )
+    } else {
+      expect(visConfig.value.expressionId).toBe(eid('self'))
+    }
+    expect(visConfig.value.positionalArgumentsExpressions![0]).toBe(methodName)
+    expect(visConfig.value.positionalArgumentsExpressions![1]).toBe("['arg']")
+  },
+)
diff --git a/app/gui2/src/components/GraphEditor/widgets/WidgetFunction/widgetFunctionCallInfo.ts b/app/gui2/src/components/GraphEditor/widgets/WidgetFunction/widgetFunctionCallInfo.ts
new file mode 100644
index 000000000000..611723528966
--- /dev/null
+++ b/app/gui2/src/components/GraphEditor/widgets/WidgetFunction/widgetFunctionCallInfo.ts
@@ -0,0 +1,179 @@
+import type { WidgetInput } from '@/providers/widgetRegistry'
+import {
+  argsWidgetConfigurationSchema,
+  functionCallConfiguration,
+} from '@/providers/widgetRegistry/configuration'
+import type { MethodCallInfo } from '@/stores/graph/graphDatabase'
+import type { ExpressionInfo } from '@/stores/project/computedValueRegistry'
+import type { NodeVisualizationConfiguration } from '@/stores/project/executionContext'
+import { entryQn } from '@/stores/suggestionDatabase/entry'
+import { Ast } from '@/util/ast'
+import type { AstId } from '@/util/ast/abstract'
+import {
+  ArgumentApplication,
+  getAccessOprSubject,
+  getMethodCallInfoRecursively,
+  interpretCall,
+} from '@/util/callTree'
+import type { Result } from '@/util/data/result'
+import type { ToValue } from '@/util/reactivity'
+import type { Opt } from 'shared/util/data/opt'
+import type { ExternalId } from 'shared/yjsModel'
+import { computed, toValue, type Ref } from 'vue'
+
+export const WIDGETS_ENSO_MODULE = 'Standard.Visualization.Widgets'
+export const GET_WIDGETS_METHOD = 'get_widget_json'
+
+/**
+ * A composable gathering information about call for WidgetFunction basing on AST and
+ * expression updates.
+ */
+export function useWidgetFunctionCallInfo(
+  input: ToValue<WidgetInput & { value: Ast.Ast }>,
+  graphDb: {
+    getMethodCallInfo(id: AstId): MethodCallInfo | undefined
+    getExpressionInfo(id: AstId): ExpressionInfo | undefined
+  },
+  project: {
+    useVisualizationData(config: Ref<Opt<NodeVisualizationConfiguration>>): Ref<Result<any> | null>
+  },
+) {
+  const methodCallInfo = computed(() => {
+    return getMethodCallInfoRecursively(toValue(input).value, graphDb)
+  })
+
+  const interpreted = computed(() => {
+    return interpretCall(toValue(input).value, methodCallInfo.value == null)
+  })
+
+  const subjectInfo = computed(() => {
+    const analyzed = interpreted.value
+    if (analyzed.kind !== 'prefix') return
+    const subject = getAccessOprSubject(analyzed.func)
+    if (!subject) return
+    return graphDb.getExpressionInfo(subject.id)
+  })
+
+  const selfArgumentPreapplied = computed(() => {
+    const info = methodCallInfo.value
+    const funcType = info?.methodCall.methodPointer.definedOnType
+    return funcType != null && subjectInfo.value?.typename !== `${funcType}.type`
+  })
+
+  const selfArgumentExternalId = computed<Opt<ExternalId>>(() => {
+    const analyzed = interpreted.value
+    if (analyzed.kind === 'infix') {
+      return analyzed.lhs?.externalId
+    } else if (methodCallInfo.value?.suggestion.selfType != null) {
+      const knownArguments = methodCallInfo.value?.suggestion?.arguments
+      const hasSelfArgument = knownArguments?.[0]?.name === 'self'
+      const selfArgument =
+        hasSelfArgument && !selfArgumentPreapplied.value ?
+          analyzed.args.find((a) => a.argName === 'self' || a.argName == null)?.argument
+        : getAccessOprSubject(analyzed.func) ?? analyzed.args[0]?.argument
+
+      return selfArgument?.externalId
+    } else {
+      return null
+    }
+  })
+
+  const visualizationConfig = computed<Opt<NodeVisualizationConfiguration>>(() => {
+    const args = ArgumentApplication.collectArgumentNamesAndUuids(
+      interpreted.value,
+      methodCallInfo.value,
+    )
+
+    const selfArgId = selfArgumentExternalId.value
+    const info = methodCallInfo.value
+    if (!info) return null
+    const annotatedArgs = info.suggestion.annotations
+    if (annotatedArgs.length === 0) return null
+    const name = info.suggestion.name
+    const positionalArgumentsExpressions = [
+      `.${name}`,
+      Ast.Vector.build(annotatedArgs, Ast.TextLiteral.new).code(),
+      Ast.TextLiteral.new(JSON.stringify(args)).code(),
+    ]
+    if (selfArgId != null) {
+      return {
+        expressionId: selfArgId,
+        visualizationModule: WIDGETS_ENSO_MODULE,
+        expression: {
+          module: WIDGETS_ENSO_MODULE,
+          definedOnType: WIDGETS_ENSO_MODULE,
+          name: GET_WIDGETS_METHOD,
+        },
+        positionalArgumentsExpressions,
+      }
+    } else {
+      // In the case when no self argument is present (for example in autoscoped constructor),
+      // we assume that this is a static function call.
+      return {
+        expressionId: toValue(input).value.externalId,
+        visualizationModule: WIDGETS_ENSO_MODULE,
+        expression: `_ -> ${WIDGETS_ENSO_MODULE}.${GET_WIDGETS_METHOD} ${info.suggestion.definedIn}`,
+        positionalArgumentsExpressions,
+      }
+    }
+  })
+
+  const subjectTypeMatchesMethod = computed(() => {
+    const funcType = methodCallInfo.value?.methodCall.methodPointer.definedOnType
+    return funcType != null && subjectInfo.value?.typename === `${funcType}.type`
+  })
+
+  const inheritedConfig = computed(() => {
+    const cfg = toValue(input).dynamicConfig
+    if (!cfg) return undefined
+    if (cfg.kind === 'FunctionCall') return cfg
+    if (cfg.kind === 'OneOfFunctionCalls' && methodCallInfo.value != null) {
+      const info = methodCallInfo.value
+      const fullName = entryQn(info?.suggestion)
+      const autoscopedName = '..' + info?.suggestion.name
+      return cfg.possibleFunctions.get(fullName) ?? cfg.possibleFunctions.get(autoscopedName)
+    }
+    return undefined
+  })
+
+  const visualizationData = project.useVisualizationData(visualizationConfig)
+
+  const widgetConfiguration = computed(() => {
+    const data = visualizationData.value
+    if (data?.ok) {
+      const parseResult = argsWidgetConfigurationSchema.safeParse(data.value)
+      if (parseResult.success) {
+        return functionCallConfiguration(parseResult.data, inheritedConfig.value)
+      } else {
+        console.error('Unable to parse widget configuration.', data, parseResult.error)
+      }
+    } else if (data != null && !data.ok) {
+      data.error.log('Cannot load dynamic configuration')
+    }
+    return inheritedConfig.value
+  })
+
+  const application = computed(() => {
+    const call = interpreted.value
+    if (!call) return null
+    const noArgsCall = call.kind === 'prefix' ? graphDb.getMethodCallInfo(call.func.id) : undefined
+
+    return ArgumentApplication.FromInterpretedWithInfo(call, {
+      suggestion: methodCallInfo.value?.suggestion,
+      widgetCfg: widgetConfiguration.value,
+      subjectAsSelf: selfArgumentPreapplied.value,
+      notAppliedArguments:
+        (
+          noArgsCall != null &&
+          (!subjectTypeMatchesMethod.value || noArgsCall.methodCall.notAppliedArguments.length > 0)
+        ) ?
+          noArgsCall.methodCall.notAppliedArguments
+        : undefined,
+    })
+  })
+
+  return {
+    methodCallInfo,
+    application,
+  }
+}
diff --git a/app/gui2/src/providers/widgetRegistry.ts b/app/gui2/src/providers/widgetRegistry.ts
index ed2eb94d1ce1..518f6c018d55 100644
--- a/app/gui2/src/providers/widgetRegistry.ts
+++ b/app/gui2/src/providers/widgetRegistry.ts
@@ -12,7 +12,7 @@ import type { WidgetEditHandler } from './widgetRegistry/editHandler'
 export type WidgetComponent<T extends WidgetInput> = Component<WidgetProps<T>>
 
 export namespace WidgetInput {
-  export function FromAst(ast: Ast.Ast | Ast.Token): WidgetInput {
+  export function FromAst<A extends Ast.Ast | Ast.Token>(ast: A): WidgetInput & { value: A } {
     return {
       portId: ast.id,
       value: ast,
diff --git a/app/gui2/src/stores/graph/__tests__/graphDatabase.test.ts b/app/gui2/src/stores/graph/__tests__/graphDatabase.test.ts
index d85387e140ab..7c65a2b739e2 100644
--- a/app/gui2/src/stores/graph/__tests__/graphDatabase.test.ts
+++ b/app/gui2/src/stores/graph/__tests__/graphDatabase.test.ts
@@ -4,20 +4,36 @@ import { initializePrefixes } from '@/util/ast/node'
 import assert from 'assert'
 import type { AstId } from 'shared/ast'
 import { initializeFFI } from 'shared/ast/ffi'
-import { IdMap, type ExternalId } from 'shared/yjsModel'
+import { IdMap, type ExternalId, type SourceRange } from 'shared/yjsModel'
 import { expect, test } from 'vitest'
 
 await initializeFFI()
 initializePrefixes()
 
-/**
- * Create a predictable fake UUID which contains given number in decimal at the end.
- * @param x sequential value, e.g. 15
- * @returns fake uuid, e.g. 00000000-0000-0000-0000-000000000015
- */
-function eid(x: number): ExternalId {
-  const xStr = `${x}`
-  return ('00000000-0000-0000-0000-000000000000'.slice(0, -xStr.length) + xStr) as ExternalId
+export function parseWithSpans<T extends Record<string, SourceRange>>(code: string, spans: T) {
+  const nameToEid = new Map<keyof T, ExternalId>()
+  const eid = (name: keyof T) => nameToEid.get(name)!
+
+  const idMap = IdMap.Mock()
+  let nextIndex = 0
+  for (const name in spans) {
+    const span = spans[name]!
+    const indexStr = `${nextIndex++}`
+    const eid =
+      idMap.getIfExist(span) ??
+      (('00000000-0000-0000-0000-000000000000'.slice(0, -indexStr.length) + indexStr) as ExternalId)
+    nameToEid.set(name, eid)
+    idMap.insertKnownId(span, eid)
+  }
+
+  const { root: ast, toRaw, getSpan } = Ast.parseExtended(code, idMap)
+  const idFromExternal = new Map<ExternalId, AstId>()
+  ast.visitRecursiveAst((ast) => {
+    idFromExternal.set(ast.externalId, ast.id)
+  })
+  const id = (name: keyof T) => idFromExternal.get(eid(name))!
+
+  return { ast, id, eid, toRaw, getSpan }
 }
 
 test('Reading graph from definition', () => {
@@ -25,23 +41,24 @@ test('Reading graph from definition', () => {
     node1 = a + 4
     node2 = node1 + 4
     node3 = node2 + 1`
+  const spans = {
+    functionName: [0, 8] as [number, number],
+    parameter: [9, 10] as [number, number],
+    node1Id: [17, 22] as [number, number],
+    node1Content: [25, 30] as [number, number],
+    node1LParam: [25, 26] as [number, number],
+    node1RParam: [29, 30] as [number, number],
+    node2Id: [35, 40] as [number, number],
+    node2Content: [43, 52] as [number, number],
+    node2LParam: [43, 48] as [number, number],
+    node2RParam: [51, 52] as [number, number],
+    node3Id: [57, 62] as [number, number],
+    node3Content: [65, 74] as [number, number],
+  }
 
-  const idMap = IdMap.Mock()
-  idMap.insertKnownId([0, 8], eid(1)) // function
-  idMap.insertKnownId([9, 10], eid(2)) // a
-  idMap.insertKnownId([17, 22], eid(3)) // node1
-  idMap.insertKnownId([25, 30], eid(4)) // a + 4
-  idMap.insertKnownId([25, 26], eid(5)) // a
-  idMap.insertKnownId([29, 30], eid(6)) // 4
-  idMap.insertKnownId([35, 40], eid(7)) // node2
-  idMap.insertKnownId([43, 52], eid(8)) // node1 + 4
-  idMap.insertKnownId([43, 48], eid(9)) // node1
-  idMap.insertKnownId([51, 52], eid(10)) // 4
-  idMap.insertKnownId([57, 62], eid(11)) // node3
-  idMap.insertKnownId([65, 74], eid(12)) // node2 + 1
+  const { ast, id, toRaw, getSpan } = parseWithSpans(code, spans)
 
   const db = GraphDb.Mock()
-  const { root: ast, toRaw, getSpan } = Ast.parseExtended(code, idMap)
   const expressions = Array.from(ast.statements())
   const func = expressions[0]
   assert(func instanceof Ast.Function)
@@ -49,37 +66,48 @@ test('Reading graph from definition', () => {
   assert(rawFunc?.type === RawAst.Tree.Type.Function)
   db.readFunctionAst(func, rawFunc, code, getSpan, new Set())
 
-  const idFromExternal = new Map<ExternalId, AstId>()
-  ast.visitRecursiveAst((ast) => {
-    idFromExternal.set(ast.externalId, ast.id)
-  })
-  const id = (x: number) => idFromExternal.get(eid(x))!
-
-  expect(Array.from(db.nodeIdToNode.keys())).toEqual([id(4), id(8), id(12)])
-  expect(db.getExpressionNodeId(id(4))).toBe(id(4))
-  expect(db.getExpressionNodeId(id(5))).toBe(id(4))
-  expect(db.getExpressionNodeId(id(6))).toBe(id(4))
-  expect(db.getExpressionNodeId(id(7))).toBeUndefined()
-  expect(db.getExpressionNodeId(id(9))).toBe(id(8))
-  expect(db.getExpressionNodeId(id(10))).toBe(id(8))
-  expect(db.getPatternExpressionNodeId(id(3))).toBe(id(4))
-  expect(db.getPatternExpressionNodeId(id(4))).toBeUndefined()
-  expect(db.getPatternExpressionNodeId(id(7))).toBe(id(8))
-  expect(db.getPatternExpressionNodeId(id(10))).toBeUndefined()
-  expect(db.getIdentDefiningNode('node1')).toBe(id(4))
-  expect(db.getIdentDefiningNode('node2')).toBe(id(8))
+  expect(Array.from(db.nodeIdToNode.keys())).toEqual([
+    id('node1Content'),
+    id('node2Content'),
+    id('node3Content'),
+  ])
+  expect(db.getExpressionNodeId(id('node1Content'))).toBe(id('node1Content'))
+  expect(db.getExpressionNodeId(id('node1LParam'))).toBe(id('node1Content'))
+  expect(db.getExpressionNodeId(id('node1RParam'))).toBe(id('node1Content'))
+  expect(db.getExpressionNodeId(id('node2Id'))).toBeUndefined()
+  expect(db.getExpressionNodeId(id('node2LParam'))).toBe(id('node2Content'))
+  expect(db.getExpressionNodeId(id('node2RParam'))).toBe(id('node2Content'))
+  expect(db.getPatternExpressionNodeId(id('node1Id'))).toBe(id('node1Content'))
+  expect(db.getPatternExpressionNodeId(id('node1Content'))).toBeUndefined()
+  expect(db.getPatternExpressionNodeId(id('node2Id'))).toBe(id('node2Content'))
+  expect(db.getPatternExpressionNodeId(id('node2RParam'))).toBeUndefined()
+  expect(db.getIdentDefiningNode('node1')).toBe(id('node1Content'))
+  expect(db.getIdentDefiningNode('node2')).toBe(id('node2Content'))
   expect(db.getIdentDefiningNode('function')).toBeUndefined()
-  expect(db.getOutputPortIdentifier(db.getNodeFirstOutputPort(asNodeId(id(4))))).toBe('node1')
-  expect(db.getOutputPortIdentifier(db.getNodeFirstOutputPort(asNodeId(id(8))))).toBe('node2')
-  expect(db.getOutputPortIdentifier(db.getNodeFirstOutputPort(asNodeId(id(3))))).toBe('node1')
+  expect(db.getOutputPortIdentifier(db.getNodeFirstOutputPort(asNodeId(id('node1Content'))))).toBe(
+    'node1',
+  )
+  expect(db.getOutputPortIdentifier(db.getNodeFirstOutputPort(asNodeId(id('node2Content'))))).toBe(
+    'node2',
+  )
+  expect(db.getOutputPortIdentifier(db.getNodeFirstOutputPort(asNodeId(id('node1Id'))))).toBe(
+    'node1',
+  )
 
   // Commented the connection from input node, as we don't support them yet.
-  expect(Array.from(db.connections.allForward(), ([key]) => key)).toEqual([id(3), id(7)])
-  // expect(Array.from(db.connections.lookup(id(2)))).toEqual([id(5)])
-  expect(Array.from(db.connections.lookup(id(3)))).toEqual([id(9)])
-  // expect(db.getOutputPortIdentifier(id(2))).toBe('a')
-  expect(db.getOutputPortIdentifier(id(3))).toBe('node1')
-  expect(Array.from(db.nodeDependents.lookup(asNodeId(id(4))))).toEqual([id(8)])
-  expect(Array.from(db.nodeDependents.lookup(asNodeId(id(8))))).toEqual([id(12)])
-  expect(Array.from(db.nodeDependents.lookup(asNodeId(id(12))))).toEqual([])
+  expect(Array.from(db.connections.allForward(), ([key]) => key)).toEqual([
+    id('node1Id'),
+    id('node2Id'),
+  ])
+  // expect(Array.from(db.connections.lookup(id('parameter')))).toEqual([id('node1LParam)])
+  expect(Array.from(db.connections.lookup(id('node1Id')))).toEqual([id('node2LParam')])
+  // expect(db.getOutputPortIdentifier(id('parameter'))).toBe('a')
+  expect(db.getOutputPortIdentifier(id('node1Id'))).toBe('node1')
+  expect(Array.from(db.nodeDependents.lookup(asNodeId(id('node1Content'))))).toEqual([
+    id('node2Content'),
+  ])
+  expect(Array.from(db.nodeDependents.lookup(asNodeId(id('node2Content'))))).toEqual([
+    id('node3Content'),
+  ])
+  expect(Array.from(db.nodeDependents.lookup(asNodeId(id('node3Content'))))).toEqual([])
 })
diff --git a/app/gui2/src/util/ast/__tests__/callTree.test.ts b/app/gui2/src/util/__tests__/callTree.test.ts
similarity index 99%
rename from app/gui2/src/util/ast/__tests__/callTree.test.ts
rename to app/gui2/src/util/__tests__/callTree.test.ts
index 48bb9f0b66ca..97297bce431a 100644
--- a/app/gui2/src/util/ast/__tests__/callTree.test.ts
+++ b/app/gui2/src/util/__tests__/callTree.test.ts
@@ -12,6 +12,7 @@ import {
   type SuggestionEntry,
 } from '@/stores/suggestionDatabase/entry'
 import { Ast } from '@/util/ast'
+import type { AstId } from '@/util/ast/abstract'
 import {
   ArgumentApplication,
   ArgumentAst,
@@ -24,7 +25,6 @@ import { initializeFFI } from 'shared/ast/ffi'
 import type { ExpressionUpdatePayload, MethodCall } from 'shared/languageServerTypes'
 import { assertEqual, assertNotEqual } from 'shared/util/assert'
 import { assert, expect, test } from 'vitest'
-import type { AstId } from '../abstract'
 
 await initializeFFI()
 
diff --git a/app/gui2/src/util/callTree.ts b/app/gui2/src/util/callTree.ts
index df5607259ecf..5f4dedf071b3 100644
--- a/app/gui2/src/util/callTree.ts
+++ b/app/gui2/src/util/callTree.ts
@@ -3,9 +3,10 @@ import { WidgetInput } from '@/providers/widgetRegistry'
 import type { WidgetConfiguration } from '@/providers/widgetRegistry/configuration'
 import * as widgetCfg from '@/providers/widgetRegistry/configuration'
 import { DisplayMode } from '@/providers/widgetRegistry/configuration'
-import type { GraphDb, MethodCallInfo } from '@/stores/graph/graphDatabase'
+import type { MethodCallInfo } from '@/stores/graph/graphDatabase'
 import type { SuggestionEntry, SuggestionEntryArgument } from '@/stores/suggestionDatabase/entry'
 import { Ast } from '@/util/ast'
+import type { AstId } from '@/util/ast/abstract'
 import { findLastIndex, tryGetIndex } from '@/util/data/array'
 import type { ExternalId } from 'shared/yjsModel'
 import { assert } from './assert'
@@ -134,7 +135,7 @@ export class ArgumentAst extends Argument {
   }
 }
 
-type InterpretedCall = InterpretedInfix | InterpretedPrefix
+export type InterpretedCall = InterpretedInfix | InterpretedPrefix
 
 interface InterpretedInfix {
   kind: 'infix'
@@ -478,12 +479,12 @@ export function getAccessOprSubject(app: Ast.Ast): Ast.Ast | undefined {
  * We also don’t consider infix applications here, as using them inside a prefix chain would require additional syntax (like parenthesis). */
 export function getMethodCallInfoRecursively(
   ast: Ast.Ast,
-  db: GraphDb,
+  graphDb: { getMethodCallInfo(id: AstId): MethodCallInfo | undefined },
 ): MethodCallInfo | undefined {
   let appliedArgs = 0
   const appliedNamedArgs: string[] = []
   for (;;) {
-    const info = db.getMethodCallInfo(ast.id)
+    const info = graphDb.getMethodCallInfo(ast.id)
     if (info) {
       // There is an info available! Stop the recursion and adjust `notAppliedArguments`.
       // Indices of all named arguments applied so far.
diff --git a/app/gui2/stories/mockSuggestions.json b/app/gui2/stories/mockSuggestions.json
index 7b1428b7df6d..24b86942d25b 100644
--- a/app/gui2/stories/mockSuggestions.json
+++ b/app/gui2/stories/mockSuggestions.json
@@ -1025,7 +1025,7 @@
     "type": "module",
     "module": "Standard.Table.Excel.Excel_Range",
     "documentation": null,
-    "reexport": "Standard.Table.Excel "
+    "reexport": "Standard.Table.Excel"
   },
   {
     "type": "type",