diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/OutputDefItem.svelte b/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/OutputDefItem.svelte
index 4e94d154..3a4685ae 100644
--- a/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/OutputDefItem.svelte
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/OutputDefItem.svelte
@@ -5,14 +5,21 @@
   import {useNodesData, useSvelteFlow} from '@xyflow/svelte';
   import {parameterDataTypes} from '#consts';
   import {genShortId} from '../utils/IdGen';
-  import type {Parameter} from '#types';
+  import type {Parameter, ParameterChangeHandler} from '#types';
   import {deepClone} from '../utils/deepClone';
 
-  const { parameter, position, dataKeyName, placeholder = '请输入参数值' }: {
+  const {
+      parameter,
+      position,
+      dataKeyName,
+      placeholder = '请输入参数值',
+      onParametersChange,
+  }: {
         parameter: Parameter,
         position: number[],
         dataKeyName: string,
         placeholder?: string,
+        onParametersChange?: ParameterChangeHandler,
     } = $props();
 
 
@@ -50,9 +57,12 @@
 
     const updateAttribute = (key: string, value: any) => {
         updateNodeData(currentNodeId, (node) => {
-            const parameters = node.data?.[dataKeyName] as Array<Parameter>;
-            if (parameters && position.length > 0) {
-                let params = parameters as Parameter[];
+            const previousParameters = deepClone(
+                (node.data?.[dataKeyName] as Array<Parameter>) || []
+            );
+            const nextParameters = deepClone(previousParameters);
+            if (nextParameters.length > 0 && position.length > 0) {
+                let params = nextParameters;
                 for (let i = 0; i < position.length; i++) {
                     const pos = position[i];
                     if (i == position.length - 1) {
@@ -66,7 +76,12 @@
                 }
             }
             return {
-                [dataKeyName]: [...deepClone(parameters)]
+                [dataKeyName]: nextParameters,
+                ...onParametersChange?.(
+                    previousParameters,
+                    nextParameters,
+                    node.data
+                )
             };
         });
     };
@@ -87,9 +102,12 @@
     let triggerObject: any;
     const handleDelete = () => {
         updateNodeData(currentNodeId, (node) => {
-            let parameters = node.data?.[dataKeyName] as Array<Parameter>;
-            if (parameters && position.length > 0) {
-                let params = parameters as Array<Parameter>;
+            const previousParameters = deepClone(
+                (node.data?.[dataKeyName] as Array<Parameter>) || []
+            );
+            const nextParameters = deepClone(previousParameters);
+            if (nextParameters.length > 0 && position.length > 0) {
+                let params = nextParameters;
                 for (let i = 0; i < position.length; i++) {
                     const pos = position[i];
                     if (i == position.length - 1) {
@@ -100,7 +118,12 @@
                 }
             }
             return {
-                [dataKeyName]: [...deepClone(parameters)]
+                [dataKeyName]: nextParameters,
+                ...onParametersChange?.(
+                    previousParameters,
+                    nextParameters,
+                    node.data
+                )
             };
         });
         triggerObject?.hide();
@@ -109,9 +132,12 @@
 
     const handleAddChildParameter = () => {
         updateNodeData(currentNodeId, (node) => {
-            let parameters = node.data?.[dataKeyName] as Array<Parameter>;
-            if (parameters && position.length > 0) {
-                let params = parameters as Array<Parameter>;
+            const previousParameters = deepClone(
+                (node.data?.[dataKeyName] as Array<Parameter>) || []
+            );
+            const nextParameters = deepClone(previousParameters);
+            if (nextParameters.length > 0 && position.length > 0) {
+                let params = nextParameters;
                 for (let i = 0; i < position.length; i++) {
                     const pos = position[i];
                     if (i == position.length - 1) {
@@ -137,7 +163,12 @@
             }
 
             return {
-                [dataKeyName]: [...deepClone(parameters)]
+                [dataKeyName]: nextParameters,
+                ...onParametersChange?.(
+                    previousParameters,
+                    nextParameters,
+                    node.data
+                )
             };
         });
     };
diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/OutputDefList.svelte b/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/OutputDefList.svelte
index 276d9930..1e649a82 100644
--- a/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/OutputDefList.svelte
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/OutputDefList.svelte
@@ -1,17 +1,19 @@
 <script lang="ts">
   import {useNodesData} from '@xyflow/svelte';
   import {getCurrentNodeId} from '#components/utils/NodeUtils';
-  import type {Parameter} from '#types';
+  import type {Parameter, ParameterChangeHandler} from '#types';
   import OutputDefItem from './OutputDefItem.svelte';
 
   const {
         noneParameterText = '无输出参数',
         dataKeyName = 'outputDefs',
         placeholder = '请输入参数名称',
+        onParametersChange,
     }: {
         noneParameterText?: string;
         dataKeyName?: string;
-        placeholder?: string
+        placeholder?: string;
+        onParametersChange?: ParameterChangeHandler;
     } = $props();
 
     let currentNodeId = getCurrentNodeId();
@@ -24,7 +26,13 @@
 
 {#snippet parameterList(params: Parameter[], position: number[])}
     {#each params as param, index (`${param.id}_${param.children ? param.children.length : 0}`)}
-        <OutputDefItem parameter={param} position={[...position, index]} {dataKeyName} {placeholder} />
+        <OutputDefItem
+            parameter={param}
+            position={[...position, index]}
+            {dataKeyName}
+            {placeholder}
+            {onParametersChange}
+        />
         {#if param.children}
             {@render parameterList(param.children, [...position, index])}
         {/if}
diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/RefParameterItem.svelte b/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/RefParameterItem.svelte
index 64167914..062ec971 100644
--- a/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/RefParameterItem.svelte
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/RefParameterItem.svelte
@@ -6,7 +6,8 @@
   import {contentTypes, parameterRefTypes} from '#consts';
   import {useRefOptions} from '../utils/useRefOptions.svelte';
   import {onMount} from 'svelte';
-  import type {Parameter} from '#types';
+  import type {Parameter, ParameterChangeHandler} from '#types';
+  import {deepClone} from '../utils/deepClone';
   import {
     isArrayDataType,
     resolveLoopOutputDataType,
@@ -27,7 +28,8 @@
         fixedNumberMin,
         fixedNumberMax,
         acceptedContentTypes = [],
-        loopOutputAggregation = false
+        loopOutputAggregation = false,
+        onParametersChange
     }: {
         parameter: Parameter,
         index: number,
@@ -38,6 +40,7 @@
         fixedNumberMax?: number,
         acceptedContentTypes?: string[],
         loopOutputAggregation?: boolean,
+        onParametersChange?: ParameterChangeHandler,
     } = $props();
 
 
@@ -54,13 +57,21 @@
 
     const updateParams = (patch: Partial<Parameter>) => {
         updateNodeData(currentNodeId, (node) => {
-            let parameters = node.data?.[dataKeyName] as Array<Parameter>;
-            parameters[index] = {
-                ...parameters[index],
+            const previousParameters = deepClone(
+                (node.data?.[dataKeyName] as Array<Parameter>) || []
+            );
+            const nextParameters = deepClone(previousParameters);
+            nextParameters[index] = {
+                ...nextParameters[index],
                 ...patch
             };
             return {
-                [dataKeyName]: [...parameters]
+                [dataKeyName]: nextParameters,
+                ...onParametersChange?.(
+                    previousParameters,
+                    nextParameters,
+                    node.data
+                )
             };
         });
     };
@@ -150,10 +161,18 @@
     let triggerObject: any;
     const handleDelete = () => {
         updateNodeData(currentNodeId, (node) => {
-            let parameters = node.data?.[dataKeyName] as Array<Parameter>;
-            parameters.splice(index, 1);
+            const previousParameters = deepClone(
+                (node.data?.[dataKeyName] as Array<Parameter>) || []
+            );
+            const nextParameters = deepClone(previousParameters);
+            nextParameters.splice(index, 1);
             return {
-                [dataKeyName]: [...parameters]
+                [dataKeyName]: nextParameters,
+                ...onParametersChange?.(
+                    previousParameters,
+                    nextParameters,
+                    node.data
+                )
             };
         });
         triggerObject?.hide();
diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/RefParameterList.svelte b/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/RefParameterList.svelte
index b64c4565..e204a4de 100644
--- a/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/RefParameterList.svelte
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/components/core/RefParameterList.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
   import {useNodesData} from '@xyflow/svelte';
   import {getCurrentNodeId} from '#components/utils/NodeUtils';
+  import type {ParameterChangeHandler} from '#types';
   import RefParameterItem from './RefParameterItem.svelte';
 
   const {
@@ -11,7 +12,8 @@
         fixedNumberMin,
         fixedNumberMax,
         acceptedContentTypes = [],
-        loopOutputAggregation = false
+        loopOutputAggregation = false,
+        onParametersChange
     }: {
         noneParameterText?: string;
         dataKeyName?: string;
@@ -21,6 +23,7 @@
         fixedNumberMax?: number,
         acceptedContentTypes?: string[],
         loopOutputAggregation?: boolean,
+        onParametersChange?: ParameterChangeHandler,
     } = $props();
 
     let currentNodeId = getCurrentNodeId();
@@ -49,6 +52,7 @@
             {fixedNumberMax}
             {acceptedContentTypes}
             {loopOutputAggregation}
+            {onParametersChange}
         />
     {:else }
         <div class="none-params">{noneParameterText}</div>
diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/components/nodes/CodeNode.svelte b/easyflow-ui-admin/packages/tinyflow-ui/src/components/nodes/CodeNode.svelte
index 7b37e690..dcd8701e 100644
--- a/easyflow-ui-admin/packages/tinyflow-ui/src/components/nodes/CodeNode.svelte
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/components/nodes/CodeNode.svelte
@@ -8,9 +8,22 @@
   import {getCurrentNodeId, getOptions} from '#components/utils/NodeUtils';
   import {useAddParameter} from '../utils/useAddParameter.svelte';
   import OutputDefList from '../core/OutputDefList.svelte';
-  import {onMount} from 'svelte';
-  import type {SelectItem, TinyflowNodeData} from '#types';
+  import {onDestroy, onMount} from 'svelte';
+  import type {
+    Parameter,
+    ParameterChangeHandler,
+    SelectItem,
+    TinyflowNodeData,
+  } from '#types';
   import CodeScriptEditor from '../core/CodeScriptEditor.svelte';
+  import {genShortId} from '../utils/IdGen';
+  import {createCodeNodeScaffold} from '../utils/codeNodeScaffold';
+  import {
+    analyzeCodeNodeOutputs,
+    reconcileInferredCodeNodeOutputs,
+    syncCodeNodeInputParameters,
+    syncCodeNodeOutputDefinitions,
+  } from '../utils/codeNodeSync';
 
   const { data, ...rest }: {
         data: TinyflowNodeData,
@@ -22,32 +35,36 @@
     let currentNode = useNodesData(currentNodeId);
     const { addParameter } = useAddParameter();
     const { updateNodeData } = useSvelteFlow();
+    let syncHint = $state('');
     const codeNodeHelp = `代码如何返回结果
-- JavaScript 定义 main 函数并返回对象；Python 定义 main 函数并返回 dict，系统会自动执行。
-- main 接收由输入参数组成的对象。
+- 输入参数会按名称传入 main，例如输入参数 data 对应 main(data)。
+- JavaScript 的 main 返回对象；Python 的 main 返回 dict。
+- 保留 _result = main(...)，运行时会读取 _result 作为节点结果。
 
 输出参数如何配置
-- 在“输出参数”中新增字段（如 answer、score）。
-- 字段名与 main 返回对象的 key 保持一致。
+- return 中的静态字段会自动补全到“输出参数”，并推断 String、Number、Boolean、File、Object、Array。
+- 在“输出参数”中新增或改名，也会同步 main 的 return 字段。
 - 下游节点可引用：代码节点ID.输出参数名。
 
 JavaScript 示例
-  function main({ input }) {
-    return { answer: input, score: 95 };
+  function main(data) {
+    return { answer: data, score: 95 };
   }
+  _result = main(data);
 
 Python 示例
-  def main(inputs):
-      return {'answer': inputs.get('input'), 'score': 95}
+  def main(data):
+      return {'answer': data, 'score': 95}
+  _result = main(data)
 
 - 输出参数配置：answer(String)、score(Number)
-- 结束节点输出参数可引用：代码节点ID.answer、代码节点ID.score
-
-兼容说明
-- 历史 JavaScript、Python 的 _result 写法仍然支持。`;
+- 结束节点输出参数可引用：代码节点ID.answer、代码节点ID.score`;
 
+    const nodeData = $derived.by(() => {
+        return (currentNode?.current?.data || data) as TinyflowNodeData;
+    });
     const editorParameters = $derived.by(() => {
-        return (currentNode?.current?.data?.parameters as Array<any>) || data.parameters || [];
+        return (nodeData.parameters as Parameter[]) || [];
     });
 
     let engines = $state<SelectItem[]>([
@@ -58,30 +75,132 @@ Python 示例
         return firstAvailable?.value || 'js';
     });
     const codePlaceholder = $derived.by(() => {
-        const engine = String(data.engine || defaultEngine).trim().toLowerCase();
+        const engine = String(nodeData.engine || defaultEngine).trim().toLowerCase();
         if (engine === 'python' || engine === 'py') {
-            return "请输入代码，例如：def main(inputs):\n    return {'output': inputs.get('input')}";
+            return "请输入代码，例如：def main(data):\n    return {'output': data}\n\n_result = main(data)";
         }
-        return '请输入代码，例如：function main({ input }) { return { output: input }; }';
+        return '请输入代码，例如：function main(data) { return { output: data }; }\n_result = main(data);';
     });
 
+    const reconcileOutputs = (
+        code: string,
+        engine: string,
+        parameters: Parameter[],
+        outputDefs: Parameter[],
+    ) => {
+        const inferred = analyzeCodeNodeOutputs(code, engine, parameters);
+        return inferred
+            ? reconcileInferredCodeNodeOutputs(
+                outputDefs,
+                inferred,
+                genShortId
+            )
+            : outputDefs;
+    };
+
+    const handleInputParametersChange: ParameterChangeHandler = (
+        previousParameters,
+        nextParameters,
+        currentData,
+    ) => {
+        const engine = String(currentData.engine || defaultEngine);
+        const syncResult = syncCodeNodeInputParameters(
+            String(currentData.code || ''),
+            engine,
+            previousParameters,
+            nextParameters,
+        );
+        syncHint = syncResult.synced ? '' : (syncResult.reason || '');
+        return {
+            code: syncResult.code,
+            parameters: syncResult.parameters,
+            outputDefs: reconcileOutputs(
+                syncResult.code,
+                engine,
+                syncResult.parameters,
+                (currentData.outputDefs as Parameter[]) || [],
+            ),
+        };
+    };
+
+    const handleOutputDefinitionsChange: ParameterChangeHandler = (
+        previousParameters,
+        nextParameters,
+        currentData,
+    ) => {
+        const syncResult = syncCodeNodeOutputDefinitions(
+            String(currentData.code || ''),
+            String(currentData.engine || defaultEngine),
+            previousParameters,
+            nextParameters,
+        );
+        syncHint = syncResult.synced ? '' : (syncResult.reason || '');
+        return {
+            code: syncResult.code,
+            outputDefs: syncResult.outputDefs,
+        };
+    };
+
+    let analysisTimer: ReturnType<typeof setTimeout> | undefined;
+    const scheduleOutputAnalysis = (code: string) => {
+        if (analysisTimer) {
+            clearTimeout(analysisTimer);
+        }
+        analysisTimer = setTimeout(() => {
+            updateNodeData(currentNodeId, (node) => {
+                if (String(node.data.code || '') !== code) {
+                    return {};
+                }
+                const outputDefs = reconcileOutputs(
+                    code,
+                    String(node.data.engine || defaultEngine),
+                    (node.data.parameters as Parameter[]) || [],
+                    (node.data.outputDefs as Parameter[]) || [],
+                );
+                if (
+                    JSON.stringify(outputDefs) ===
+                    JSON.stringify(node.data.outputDefs || [])
+                ) {
+                    return {};
+                }
+                return { outputDefs };
+            });
+        }, 300);
+    };
+
+    const updateEngine = (engine: string) => {
+        syncHint = '';
+        updateNodeData(currentNodeId, (node) => {
+            const patch: TinyflowNodeData = { engine };
+            if (node.data.codeScaffoldManaged === true) {
+                patch.code = createCodeNodeScaffold(
+                    engine,
+                    (node.data.parameters as Parameter[]) || [],
+                    (node.data.outputDefs as Parameter[]) || [],
+                );
+            }
+            return patch;
+        });
+    };
+
     onMount(async () => {
         const codeEngines = await options.provider?.codeEngine?.();
         if (codeEngines && codeEngines.length > 0) {
             engines = codeEngines;
         }
 
-        const currentEngine = data.engine;
+        const currentEngine = nodeData.engine;
         const currentEngineSupported = engines.some((item) => item.value === currentEngine && item.selectable !== false);
         if (!currentEngine || !currentEngineSupported) {
-            updateNodeData(currentNodeId, () => {
-                return {
-                    engine: defaultEngine
-                };
-            });
+            updateEngine(String(defaultEngine));
         }
     });
 
+    onDestroy(() => {
+        if (analysisTimer) {
+            clearTimeout(analysisTimer);
+        }
+    });
 
 </script>
 
@@ -109,19 +228,14 @@ Python 示例
             </svg>
         </Button>
     </div>
-    <RefParameterList />
+    <RefParameterList onParametersChange={handleInputParametersChange} />
 
     <Heading level={3} mt="10px">代码</Heading>
     <div class="setting-title">执行引擎</div>
     <div class="setting-item">
         <Select items={engines} style="width: 100%" placeholder="请选择执行引擎" onSelect={(item)=>{
-              const newValue = item.value;
-              updateNodeData(currentNodeId, ()=>{
-                  return {
-                      engine: newValue
-                  }
-              })
-        }} value={data.engine ? [data.engine] : [defaultEngine]} />
+              updateEngine(String(item.value));
+        }} value={nodeData.engine ? [nodeData.engine] : [defaultEngine]} />
     </div>
 
     <div class="setting-title">执行代码</div>
@@ -131,18 +245,25 @@ Python 示例
                   rows={10}
                   placeholder={codePlaceholder}
                   style="width: 100%"
-                  engine={(data.engine as string) || (defaultEngine as string)}
+                  engine={(nodeData.engine as string) || (defaultEngine as string)}
                   parameters={editorParameters}
                   oninput={(e:any)=>{
+            const code = String(e.target.value || '');
+            syncHint = '';
             updateNodeData(currentNodeId, ()=>{
                 return {
-                    code: e.target.value
+                    code,
+                    codeScaffoldManaged: false
                 }
-            })
+            });
+            scheduleOutputAnalysis(code);
         }}
-                  value={data.code as string||""}
+                  value={nodeData.code as string||""}
         />
     </div>
+    {#if syncHint}
+        <div class="sync-hint" role="status">{syncHint}</div>
+    {/if}
 
 
     <div class="heading">
@@ -155,7 +276,7 @@ Python 示例
             </svg>
         </Button>
     </div>
-    <OutputDefList />
+    <OutputDefList onParametersChange={handleOutputDefinitionsChange} />
 
 </NodeWrapper>
 
@@ -180,4 +301,11 @@ Python 示例
         gap: 10px;
     }
 
+    .sync-hint {
+        color: var(--tf-warning-soft-text);
+        font-size: 12px;
+        line-height: 18px;
+        margin: -4px 0 8px;
+    }
+
 </style>
diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/codeNodeScaffold.ts b/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/codeNodeScaffold.ts
new file mode 100644
index 00000000..f158a104
--- /dev/null
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/codeNodeScaffold.ts
@@ -0,0 +1,168 @@
+import type { Parameter } from '#types';
+
+export type CodeNodeEngine = 'javascript' | 'python';
+
+const PYTHON_RESERVED_WORDS = new Set([
+  'False',
+  'None',
+  'True',
+  'and',
+  'as',
+  'assert',
+  'async',
+  'await',
+  'break',
+  'class',
+  'continue',
+  'def',
+  'del',
+  'elif',
+  'else',
+  'except',
+  'finally',
+  'for',
+  'from',
+  'global',
+  'if',
+  'import',
+  'in',
+  'is',
+  'lambda',
+  'nonlocal',
+  'not',
+  'or',
+  'pass',
+  'raise',
+  'return',
+  'try',
+  'while',
+  'with',
+  'yield',
+]);
+
+const JAVASCRIPT_RESERVED_WORDS = new Set([
+  'await',
+  'break',
+  'case',
+  'catch',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'else',
+  'enum',
+  'export',
+  'extends',
+  'false',
+  'finally',
+  'for',
+  'function',
+  'if',
+  'implements',
+  'import',
+  'in',
+  'instanceof',
+  'interface',
+  'let',
+  'new',
+  'null',
+  'package',
+  'private',
+  'protected',
+  'public',
+  'return',
+  'static',
+  'super',
+  'switch',
+  'this',
+  'throw',
+  'true',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'while',
+  'with',
+  'yield',
+]);
+
+/**
+ * 将代码节点执行引擎别名归一化为编辑器使用的语言名称。
+ */
+export function normalizeCodeNodeEngine(rawEngine?: string): CodeNodeEngine {
+  const normalized = (rawEngine || 'js').trim().toLowerCase();
+  return normalized === 'python' || normalized === 'py'
+    ? 'python'
+    : 'javascript';
+}
+
+/**
+ * 判断参数名称能否安全写入目标语言的函数签名。
+ */
+export function isValidCodeNodeParameterName(name: string, rawEngine?: string) {
+  const engine = normalizeCodeNodeEngine(rawEngine);
+  if (engine === 'python') {
+    return /^[A-Za-z_]\w*$/.test(name) && !PYTHON_RESERVED_WORDS.has(name);
+  }
+  return (
+    /^[A-Za-z_$][\w$]*$/.test(name) && !JAVASCRIPT_RESERVED_WORDS.has(name)
+  );
+}
+
+/**
+ * 为新代码节点生成与当前运行时兼容的 main 脚手架。
+ */
+export function createCodeNodeScaffold(
+  rawEngine?: string,
+  parameters: Parameter[] = [],
+  outputDefs: Parameter[] = [],
+) {
+  const engine = normalizeCodeNodeEngine(rawEngine);
+  const parameterNames = [
+    ...new Set(
+      parameters
+        .map((parameter) => String(parameter.name || '').trim())
+        .filter((name) => isValidCodeNodeParameterName(name, engine)),
+    ),
+  ];
+  const outputNames = [
+    ...new Set(
+      outputDefs
+        .map((parameter) => String(parameter.name || '').trim())
+        .filter(Boolean),
+    ),
+  ];
+  const argumentsText = parameterNames.join(', ');
+
+  if (engine === 'python') {
+    const outputLines = outputNames.map(
+      (name) => `        ${JSON.stringify(name)}: None,`,
+    );
+    return [
+      `def main(${argumentsText}):`,
+      '    return {',
+      ...outputLines,
+      '    }',
+      '',
+      `_result = main(${argumentsText})`,
+    ].join('\n');
+  }
+
+  const outputLines = outputNames.map(
+    (name) => `    ${JSON.stringify(name)}: null,`,
+  );
+  return [
+    `function main(${argumentsText}) {`,
+    '  return {',
+    ...outputLines,
+    '  };',
+    '}',
+    '',
+    `_result = main(${argumentsText});`,
+  ].join('\n');
+}
+
+export const DEFAULT_CODE_NODE_JAVASCRIPT = createCodeNodeScaffold('js');
diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/codeNodeSync.test.ts b/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/codeNodeSync.test.ts
new file mode 100644
index 00000000..80eccf6f
--- /dev/null
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/codeNodeSync.test.ts
@@ -0,0 +1,544 @@
+import { describe, expect, it } from 'vitest';
+
+import type { Parameter } from '#types';
+
+import { createCodeNodeScaffold } from './codeNodeScaffold';
+import { getAvailableNodes } from './nodePalette';
+import {
+  analyzeCodeNodeOutputs,
+  reconcileInferredCodeNodeOutputs,
+  syncCodeNodeInputParameters,
+  syncCodeNodeOutputDefinitions,
+} from './codeNodeSync';
+
+describe('code node scaffold', () => {
+  it('is attached to newly created code nodes', () => {
+    const codeNode = getAvailableNodes().find(
+      (node) => node.type === 'codeNode',
+    );
+
+    expect(codeNode?.extra).toMatchObject({
+      code: createCodeNodeScaffold('js'),
+      codeScaffoldManaged: true,
+      codeScaffoldVersion: 1,
+      engine: 'js',
+    });
+  });
+
+  it('creates an explicit javascript main call', () => {
+    expect(
+      createCodeNodeScaffold('js', [{ name: 'data' }], [{ name: 'result' }]),
+    ).toBe(
+      [
+        'function main(data) {',
+        '  return {',
+        '    "result": null,',
+        '  };',
+        '}',
+        '',
+        '_result = main(data);',
+      ].join('\n'),
+    );
+  });
+
+  it('creates an explicit python main call', () => {
+    expect(
+      createCodeNodeScaffold(
+        'python',
+        [{ name: 'data' }],
+        [{ name: 'result' }],
+      ),
+    ).toBe(
+      [
+        'def main(data):',
+        '    return {',
+        '        "result": None,',
+        '    }',
+        '',
+        '_result = main(data)',
+      ].join('\n'),
+    );
+  });
+
+  it('does not generate invalid or duplicate function parameters', () => {
+    const code = createCodeNodeScaffold('python', [
+      { name: 'data' },
+      { name: 'class' },
+      { name: 'data' },
+    ]);
+
+    expect(code).toContain('def main(data):');
+    expect(code).toContain('_result = main(data)');
+  });
+});
+
+describe.each([
+  {
+    engine: 'js',
+    emptyCode: createCodeNodeScaffold('js'),
+    mainWithData: 'function main(data)',
+    callWithData: '_result = main(data);',
+    mainWithQuery: 'function main(query)',
+    callWithQuery: '_result = main(query);',
+  },
+  {
+    engine: 'python',
+    emptyCode: createCodeNodeScaffold('python'),
+    mainWithData: 'def main(data):',
+    callWithData: '_result = main(data)',
+    mainWithQuery: 'def main(query):',
+    callWithQuery: '_result = main(query)',
+  },
+])('code node input sync for $engine', (fixture) => {
+  it('syncs a newly configured input name to main and its call', () => {
+    const blankParameter: Parameter = {
+      id: 'input-1',
+      name: '',
+      dataType: 'String',
+    };
+    const blankResult = syncCodeNodeInputParameters(
+      fixture.emptyCode,
+      fixture.engine,
+      [],
+      [blankParameter],
+    );
+
+    expect(blankResult.synced).toBe(false);
+    expect(blankResult.code).toBe(fixture.emptyCode);
+
+    const namedResult = syncCodeNodeInputParameters(
+      blankResult.code,
+      fixture.engine,
+      blankResult.parameters,
+      [{ ...blankResult.parameters[0], name: 'data' }],
+    );
+
+    expect(namedResult.synced).toBe(true);
+    expect(namedResult.code).toContain(fixture.mainWithData);
+    expect(namedResult.code).toContain(fixture.callWithData);
+    expect(namedResult.parameters[0].codeSyncName).toBe('data');
+  });
+
+  it('keeps the previous binding while the user clears and renames it', () => {
+    const initial = syncCodeNodeInputParameters(
+      fixture.emptyCode,
+      fixture.engine,
+      [],
+      [{ id: 'input-1', name: 'data', dataType: 'String' }],
+    );
+    const cleared = syncCodeNodeInputParameters(
+      initial.code,
+      fixture.engine,
+      initial.parameters,
+      [{ ...initial.parameters[0], name: '' }],
+    );
+    const renamed = syncCodeNodeInputParameters(
+      cleared.code,
+      fixture.engine,
+      cleared.parameters,
+      [{ ...cleared.parameters[0], name: 'query' }],
+    );
+
+    expect(cleared.synced).toBe(false);
+    expect(cleared.parameters[0].codeSyncName).toBe('data');
+    expect(renamed.synced).toBe(true);
+    expect(renamed.code).toContain(fixture.mainWithQuery);
+    expect(renamed.code).toContain(fixture.callWithQuery);
+  });
+
+  it('does not overwrite a user-managed main signature', () => {
+    const initial = syncCodeNodeInputParameters(
+      fixture.emptyCode,
+      fixture.engine,
+      [],
+      [{ id: 'input-1', name: 'data' }],
+    );
+    const manualCode = initial.code.replace(
+      fixture.mainWithData,
+      fixture.engine === 'python'
+        ? 'def main(custom):'
+        : 'function main(custom)',
+    );
+    const result = syncCodeNodeInputParameters(
+      manualCode,
+      fixture.engine,
+      initial.parameters,
+      [{ ...initial.parameters[0], name: 'query' }],
+    );
+
+    expect(result.synced).toBe(false);
+    expect(result.code).toBe(manualCode);
+  });
+
+  it('does not partially update multiple explicit main calls', () => {
+    const initial = syncCodeNodeInputParameters(
+      fixture.emptyCode,
+      fixture.engine,
+      [],
+      [{ id: 'input-1', name: 'data' }],
+    );
+    const duplicatedCall = [
+      initial.code,
+      fixture.engine === 'python'
+        ? '_result = main(data)'
+        : '_result = main(data);',
+    ].join('\n');
+    const result = syncCodeNodeInputParameters(
+      duplicatedCall,
+      fixture.engine,
+      initial.parameters,
+      [{ ...initial.parameters[0], name: 'query' }],
+    );
+
+    expect(result.synced).toBe(false);
+    expect(result.code).toBe(duplicatedCall);
+  });
+
+  it('syncs input ordering and deletion', () => {
+    const initial = syncCodeNodeInputParameters(
+      fixture.emptyCode,
+      fixture.engine,
+      [],
+      [
+        { id: 'input-1', name: 'data' },
+        { id: 'input-2', name: 'question' },
+      ],
+    );
+    const reordered = syncCodeNodeInputParameters(
+      initial.code,
+      fixture.engine,
+      initial.parameters,
+      [initial.parameters[1], initial.parameters[0]],
+    );
+    const deleted = syncCodeNodeInputParameters(
+      reordered.code,
+      fixture.engine,
+      reordered.parameters,
+      [reordered.parameters[0]],
+    );
+
+    expect(reordered.code).toContain('main(question, data)');
+    expect(deleted.code).toContain('main(question)');
+    expect(deleted.code).not.toContain('main(question, data)');
+  });
+});
+
+describe.each([
+  {
+    engine: 'js',
+    emptyCode: createCodeNodeScaffold('js'),
+    expectedEntry: '"answer": null',
+  },
+  {
+    engine: 'python',
+    emptyCode: createCodeNodeScaffold('python'),
+    expectedEntry: '"answer": None',
+  },
+])('code node output sync for $engine', (fixture) => {
+  it('adds a configured output name to the return object', () => {
+    const blankOutput: Parameter = {
+      id: 'output-1',
+      name: '',
+      dataType: 'String',
+    };
+    const blankResult = syncCodeNodeOutputDefinitions(
+      fixture.emptyCode,
+      fixture.engine,
+      [],
+      [blankOutput],
+    );
+    const namedResult = syncCodeNodeOutputDefinitions(
+      blankResult.code,
+      fixture.engine,
+      blankResult.outputDefs,
+      [{ ...blankResult.outputDefs[0], name: 'answer' }],
+    );
+
+    expect(namedResult.synced).toBe(true);
+    expect(namedResult.code).toContain(fixture.expectedEntry);
+    expect(namedResult.outputDefs[0].codeSyncName).toBe('answer');
+  });
+
+  it('renames the matching return key', () => {
+    const initial = syncCodeNodeOutputDefinitions(
+      fixture.emptyCode,
+      fixture.engine,
+      [],
+      [{ id: 'output-1', name: 'answer', dataType: 'String' }],
+    );
+    const renamed = syncCodeNodeOutputDefinitions(
+      initial.code,
+      fixture.engine,
+      initial.outputDefs,
+      [{ ...initial.outputDefs[0], name: 'message' }],
+    );
+
+    expect(renamed.synced).toBe(true);
+    expect(renamed.code).toContain(
+      fixture.engine === 'python' ? '"message": None' : '"message": null',
+    );
+    expect(renamed.code).not.toContain(fixture.expectedEntry);
+  });
+
+  it('adds the renamed key when the previous return key is absent', () => {
+    const renamed = syncCodeNodeOutputDefinitions(
+      fixture.emptyCode,
+      fixture.engine,
+      [
+        {
+          id: 'output-1',
+          name: 'answer',
+          dataType: 'String',
+          codeSyncName: 'answer',
+        },
+      ],
+      [
+        {
+          id: 'output-1',
+          name: 'message',
+          dataType: 'String',
+          codeSyncName: 'answer',
+        },
+      ],
+    );
+
+    expect(renamed.code).toContain(
+      fixture.engine === 'python' ? '"message": None' : '"message": null',
+    );
+  });
+});
+
+describe('code node output inference', () => {
+  it.each([
+    {
+      engine: 'js',
+      code: [
+        'function main(data) {',
+        '  const answer = data;',
+        '  return { answer };',
+        '}',
+        '_result = main(data);',
+      ].join('\n'),
+    },
+    {
+      engine: 'python',
+      code: [
+        'def main(data):',
+        '    answer = data',
+        '    return {"answer": answer}',
+        '_result = main(data)',
+      ].join('\n'),
+    },
+  ])(
+    'preserves the return expression when renaming for $engine',
+    ({ code, engine }) => {
+      const renamed = syncCodeNodeOutputDefinitions(
+        code,
+        engine,
+        [
+          {
+            id: 'output-1',
+            name: 'answer',
+            dataType: 'String',
+            codeSyncName: 'answer',
+          },
+        ],
+        [
+          {
+            id: 'output-1',
+            name: 'message',
+            dataType: 'String',
+            codeSyncName: 'answer',
+          },
+        ],
+      );
+
+      expect(renamed.code).toContain('"message": answer');
+    },
+  );
+
+  it('infers the python return fields used by the executable example', () => {
+    const code = [
+      'import json',
+      'def main(data):',
+      '    r1 = data + "111"',
+      '    r2 = "222"',
+      '    return {',
+      '        "r1": r1,',
+      '        "r2": r2,',
+      '    }',
+      '_result = main(data)',
+    ].join('\n');
+
+    expect(
+      analyzeCodeNodeOutputs(code, 'python', [
+        { name: 'data', dataType: 'String' },
+      ]),
+    ).toEqual([
+      { name: 'r1', dataType: 'String' },
+      { name: 'r2', dataType: 'String' },
+    ]);
+  });
+
+  it('infers supported python primitive and container types', () => {
+    const code = [
+      'def main(data, count, file):',
+      '    text = f"{data}-ok"',
+      '    total = count + 1',
+      '    return {',
+      '        "text": text,',
+      '        "total": total,',
+      '        "ok": True,',
+      '        "file": file,',
+      '        "objectValue": {},',
+      '        "arrayValue": [],',
+      '    }',
+      '_result = main(data, count, file)',
+    ].join('\n');
+
+    expect(
+      analyzeCodeNodeOutputs(code, 'python', [
+        { name: 'data', dataType: 'String' },
+        { name: 'count', dataType: 'Number' },
+        { name: 'file', dataType: 'File' },
+      ]),
+    ).toEqual([
+      { name: 'text', dataType: 'String' },
+      { name: 'total', dataType: 'Number' },
+      { name: 'ok', dataType: 'Boolean' },
+      { name: 'file', dataType: 'File' },
+      { name: 'objectValue', dataType: 'Object' },
+      { name: 'arrayValue', dataType: 'Array' },
+    ]);
+  });
+
+  it('infers supported javascript primitive and container types', () => {
+    const code = [
+      'function main(data, count, file) {',
+      '  const text = data + "x";',
+      '  const total = count + 1;',
+      '  return {',
+      '    text,',
+      '    total,',
+      '    ok: true,',
+      '    file,',
+      '    objectValue: {},',
+      '    arrayValue: [],',
+      '  };',
+      '}',
+      '_result = main(data, count, file);',
+    ].join('\n');
+
+    expect(
+      analyzeCodeNodeOutputs(code, 'js', [
+        { name: 'data', dataType: 'String' },
+        { name: 'count', dataType: 'Number' },
+        { name: 'file', dataType: 'File' },
+      ]),
+    ).toEqual([
+      { name: 'text', dataType: 'String' },
+      { name: 'total', dataType: 'Number' },
+      { name: 'ok', dataType: 'Boolean' },
+      { name: 'file', dataType: 'File' },
+      { name: 'objectValue', dataType: 'Object' },
+      { name: 'arrayValue', dataType: 'Array' },
+    ]);
+  });
+
+  it('falls back to String for a static key with a dynamic value', () => {
+    const code = [
+      'function main(data) {',
+      '  return { answer: externalCall(data) };',
+      '}',
+      '_result = main(data);',
+    ].join('\n');
+
+    expect(analyzeCodeNodeOutputs(code, 'js', [])).toEqual([
+      { name: 'answer', dataType: 'String' },
+    ]);
+  });
+
+  it('does not infer assignment types across complex control flow', () => {
+    const code = [
+      'function main(data) {',
+      '  let value = 1;',
+      '  if (data) {',
+      '    value = true;',
+      '  }',
+      '  return { value };',
+      '}',
+      '_result = main(data);',
+    ].join('\n');
+
+    expect(analyzeCodeNodeOutputs(code, 'js', [])).toEqual([
+      { name: 'value', dataType: 'String' },
+    ]);
+  });
+
+  it.each([
+    {
+      engine: 'js',
+      code: [
+        'function main(data) {',
+        '  return { fixed: 1, ...data };',
+        '}',
+        '_result = main(data);',
+      ].join('\n'),
+    },
+    {
+      engine: 'python',
+      code: [
+        'def main(data):',
+        '    return {"fixed": 1, **data}',
+        '_result = main(data)',
+      ].join('\n'),
+    },
+  ])(
+    'does not infer fields from a spread return object for $engine',
+    ({ code, engine }) => {
+      expect(analyzeCodeNodeOutputs(code, engine, [])).toBeNull();
+    },
+  );
+
+  it('preserves manual output types and removes stale inferred fields', () => {
+    const outputs = reconcileInferredCodeNodeOutputs(
+      [
+        {
+          id: 'manualized',
+          name: 'answer',
+          dataType: 'Number',
+          codeInferred: true,
+          codeInferredDataType: 'String',
+        },
+        {
+          id: 'stale',
+          name: 'oldField',
+          dataType: 'String',
+          codeInferred: true,
+          codeInferredDataType: 'String',
+        },
+      ],
+      [
+        { name: 'answer', dataType: 'String' },
+        { name: 'newField', dataType: 'Boolean' },
+      ],
+      () => 'generated',
+    );
+
+    expect(outputs).toEqual([
+      {
+        id: 'manualized',
+        name: 'answer',
+        dataType: 'Number',
+      },
+      {
+        id: 'generated',
+        name: 'newField',
+        dataType: 'Boolean',
+        codeInferred: true,
+        codeInferredDataType: 'Boolean',
+        codeSyncName: 'newField',
+      },
+    ]);
+  });
+});
diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/codeNodeSync.ts b/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/codeNodeSync.ts
new file mode 100644
index 00000000..030aa583
--- /dev/null
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/codeNodeSync.ts
@@ -0,0 +1,1121 @@
+import { javascript } from '@codemirror/lang-javascript';
+import { python } from '@codemirror/lang-python';
+import { ensureSyntaxTree, syntaxTree } from '@codemirror/language';
+import { EditorState } from '@codemirror/state';
+
+import type { Parameter } from '#types';
+
+import {
+  type CodeNodeEngine,
+  isValidCodeNodeParameterName,
+  normalizeCodeNodeEngine,
+} from './codeNodeScaffold';
+
+type SyntaxNode = ReturnType<typeof syntaxTree>['topNode'];
+
+export type CodeNodeDataType =
+  | 'Array'
+  | 'Boolean'
+  | 'File'
+  | 'Number'
+  | 'Object'
+  | 'String';
+
+export type CodeNodeSyncResult = {
+  code: string;
+  reason?: string;
+  synced: boolean;
+};
+
+export type InferredCodeNodeOutput = {
+  dataType: CodeNodeDataType;
+  name: string;
+};
+
+type SourceEdit = {
+  from: number;
+  insert: string;
+  to: number;
+};
+
+type ParsedDocument = {
+  engine: CodeNodeEngine;
+  source: string;
+  topNode: SyntaxNode;
+};
+
+type MainFunction = {
+  body: SyntaxNode;
+  node: SyntaxNode;
+  paramList: SyntaxNode;
+};
+
+type ReturnEntry = {
+  keyFrom: number;
+  keyTo: number;
+  name: string;
+  propertyFrom: number;
+  propertyTo: number;
+  shorthand: boolean;
+  valueNode: SyntaxNode;
+};
+
+type ReturnObject = {
+  closeBraceFrom: number;
+  entries: ReturnEntry[];
+  node: SyntaxNode;
+};
+
+const SUPPORTED_DATA_TYPES = new Set<CodeNodeDataType>([
+  'String',
+  'Number',
+  'Boolean',
+  'File',
+  'Object',
+  'Array',
+]);
+
+const PUNCTUATION_NODE_NAMES = new Set([
+  '(',
+  ')',
+  '[',
+  ']',
+  '{',
+  '}',
+  ',',
+  ':',
+  ';',
+  '=',
+  'AssignOp',
+  'Equals',
+]);
+
+const COMPLEX_CONTROL_FLOW_NODE_NAMES = new Set([
+  'DoStatement',
+  'ForInStatement',
+  'ForOfStatement',
+  'ForStatement',
+  'IfStatement',
+  'SwitchStatement',
+  'TryStatement',
+  'WhileStatement',
+  'WithStatement',
+]);
+
+function childNodes(node: SyntaxNode) {
+  const result: SyntaxNode[] = [];
+  for (let child = node.firstChild; child; child = child.nextSibling) {
+    result.push(child);
+  }
+  return result;
+}
+
+function nodeText(node: SyntaxNode, source: string) {
+  return source.slice(node.from, node.to);
+}
+
+function hasParseError(node: SyntaxNode): boolean {
+  if (node.type.isError) {
+    return true;
+  }
+  return childNodes(node).some(hasParseError);
+}
+
+function parseDocument(
+  source: string,
+  rawEngine?: string,
+): ParsedDocument | null {
+  const engine = normalizeCodeNodeEngine(rawEngine);
+  const state = EditorState.create({
+    doc: source,
+    extensions: [engine === 'python' ? python() : javascript()],
+  });
+  const tree = ensureSyntaxTree(state, source.length, 100) || syntaxTree(state);
+  if (tree.length < source.length || hasParseError(tree.topNode)) {
+    return null;
+  }
+  return {
+    engine,
+    source,
+    topNode: tree.topNode,
+  };
+}
+
+function findMainFunction(document: ParsedDocument): MainFunction | null {
+  const functionNodeName =
+    document.engine === 'python' ? 'FunctionDefinition' : 'FunctionDeclaration';
+  const candidates = childNodes(document.topNode).filter(
+    (node) => node.name === functionNodeName,
+  );
+  const matched = candidates.filter((node) => {
+    const nameNode = childNodes(node).find(
+      (child) =>
+        child.name === 'VariableName' || child.name === 'VariableDefinition',
+    );
+    return nameNode && nodeText(nameNode, document.source) === 'main';
+  });
+  if (matched.length !== 1) {
+    return null;
+  }
+
+  const node = matched[0];
+  const children = childNodes(node);
+  const paramList = children.find((child) => child.name === 'ParamList');
+  const body = children.find(
+    (child) => child.name === 'Body' || child.name === 'Block',
+  );
+  if (!paramList || !body) {
+    return null;
+  }
+  return {
+    body,
+    node,
+    paramList,
+  };
+}
+
+function significantChildren(node: SyntaxNode) {
+  return childNodes(node).filter(
+    (child) => !PUNCTUATION_NODE_NAMES.has(child.name),
+  );
+}
+
+function readSimpleNames(
+  listNode: SyntaxNode,
+  source: string,
+  allowedNodeNames: Set<string>,
+) {
+  const children = significantChildren(listNode);
+  if (children.some((child) => !allowedNodeNames.has(child.name))) {
+    return null;
+  }
+  return children.map((child) => nodeText(child, source));
+}
+
+function findExplicitMainCall(document: ParsedDocument) {
+  const matches: SyntaxNode[] = [];
+  for (const statement of childNodes(document.topNode)) {
+    if (statement.name === 'FunctionDefinition') {
+      continue;
+    }
+    if (statement.name === 'FunctionDeclaration') {
+      continue;
+    }
+
+    const assignment =
+      document.engine === 'python'
+        ? statement.name === 'AssignStatement'
+          ? statement
+          : null
+        : statement.name === 'ExpressionStatement'
+          ? significantChildren(statement).find(
+              (child) => child.name === 'AssignmentExpression',
+            ) || null
+          : null;
+    if (!assignment) {
+      continue;
+    }
+
+    const assignmentChildren = significantChildren(assignment);
+    const target = assignmentChildren[0];
+    const call = assignmentChildren.find(
+      (child) => child.name === 'CallExpression',
+    );
+    if (!target || nodeText(target, document.source) !== '_result' || !call) {
+      continue;
+    }
+
+    const callChildren = childNodes(call);
+    const callee = callChildren.find(
+      (child) =>
+        child.name === 'VariableName' || child.name === 'VariableDefinition',
+    );
+    const argList = callChildren.find((child) => child.name === 'ArgList');
+    if (callee && nodeText(callee, document.source) === 'main' && argList) {
+      matches.push(argList);
+    }
+  }
+  return matches.length === 1 ? matches[0] : null;
+}
+
+function arraysEqual(left: string[], right: string[]) {
+  return (
+    left.length === right.length &&
+    left.every((value, index) => value === right[index])
+  );
+}
+
+function applySourceEdits(source: string, edits: SourceEdit[]) {
+  if (edits.length === 0) {
+    return source;
+  }
+  const sorted = [...edits].sort(
+    (left, right) => right.from - left.from || right.to - left.to,
+  );
+  let boundary = source.length;
+  let result = source;
+  for (const edit of sorted) {
+    if (
+      edit.from < 0 ||
+      edit.to < edit.from ||
+      edit.to > source.length ||
+      edit.to > boundary
+    ) {
+      return source;
+    }
+    result = result.slice(0, edit.from) + edit.insert + result.slice(edit.to);
+    boundary = edit.from;
+  }
+  return result;
+}
+
+function parameterNames(
+  parameters: Parameter[],
+  engine: CodeNodeEngine,
+  field: 'codeSyncName' | 'name',
+) {
+  const names = parameters.map((parameter) =>
+    String(parameter[field] || '').trim(),
+  );
+  if (names.some((name) => !name)) {
+    return null;
+  }
+  if (names.some((name) => !isValidCodeNodeParameterName(name, engine))) {
+    return null;
+  }
+  if (new Set(names).size !== names.length) {
+    return null;
+  }
+  return names;
+}
+
+function withPreviousSyncNames(previous: Parameter[], next: Parameter[]) {
+  const previousById = new Map(
+    previous
+      .filter((parameter) => parameter.id)
+      .map((parameter) => [parameter.id, parameter]),
+  );
+  return next.map((parameter, index) => {
+    const oldParameter = parameter.id
+      ? previousById.get(parameter.id)
+      : previous[index];
+    const previousSyncName = String(
+      oldParameter?.codeSyncName || oldParameter?.name || '',
+    ).trim();
+    if (parameter.codeSyncName || !previousSyncName) {
+      return { ...parameter };
+    }
+    return {
+      ...parameter,
+      codeSyncName: previousSyncName,
+    };
+  });
+}
+
+/**
+ * 在 main 签名和显式调用仍受控时，同步代码节点输入参数。
+ */
+export function syncCodeNodeInputParameters(
+  source: string,
+  rawEngine: string | undefined,
+  previous: Parameter[],
+  next: Parameter[],
+) {
+  const engine = normalizeCodeNodeEngine(rawEngine);
+  const nextWithSyncNames = withPreviousSyncNames(previous, next);
+  const nextNames = parameterNames(nextWithSyncNames, engine, 'name');
+  if (!nextNames) {
+    return {
+      code: source,
+      parameters: nextWithSyncNames,
+      reason: '输入参数名称为空、重复或不是合法变量名',
+      synced: false,
+    };
+  }
+
+  const previousNames = parameterNames(
+    previous
+      .map((parameter) => ({
+        ...parameter,
+        codeSyncName: parameter.codeSyncName || parameter.name,
+      }))
+      .filter((parameter) => String(parameter.codeSyncName || '').trim()),
+    engine,
+    'codeSyncName',
+  );
+  const document = parseDocument(source, engine);
+  const mainFunction = document && findMainFunction(document);
+  const explicitCall = document && findExplicitMainCall(document);
+  if (!document || !mainFunction || !explicitCall) {
+    return {
+      code: source,
+      parameters: nextWithSyncNames,
+      reason: '未找到可安全同步的 main 函数和显式调用',
+      synced: false,
+    };
+  }
+
+  const currentParams = readSimpleNames(
+    mainFunction.paramList,
+    source,
+    new Set(['VariableDefinition', 'VariableName']),
+  );
+  const currentArguments = readSimpleNames(
+    explicitCall,
+    source,
+    new Set(['VariableName']),
+  );
+  if (
+    !currentParams ||
+    !currentArguments ||
+    !previousNames ||
+    !arraysEqual(currentParams, previousNames) ||
+    !arraysEqual(currentArguments, previousNames)
+  ) {
+    return {
+      code: source,
+      parameters: nextWithSyncNames,
+      reason: 'main 参数已由用户接管',
+      synced: false,
+    };
+  }
+
+  const replacement = nextNames.join(', ');
+  const code = applySourceEdits(source, [
+    {
+      from: mainFunction.paramList.from + 1,
+      to: mainFunction.paramList.to - 1,
+      insert: replacement,
+    },
+    {
+      from: explicitCall.from + 1,
+      to: explicitCall.to - 1,
+      insert: replacement,
+    },
+  ]);
+  return {
+    code,
+    parameters: nextWithSyncNames.map((parameter) => ({
+      ...parameter,
+      codeSyncName: String(parameter.name || '').trim(),
+    })),
+    synced: code !== source || arraysEqual(previousNames, nextNames),
+  };
+}
+
+function parseQuotedString(rawValue: string) {
+  const raw = rawValue.trim();
+  if (raw.length < 2) {
+    return null;
+  }
+  if (raw.startsWith('"') && raw.endsWith('"')) {
+    try {
+      return JSON.parse(raw) as string;
+    } catch {
+      return null;
+    }
+  }
+  if (raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1).replace(/\\\\/g, '\\').replace(/\\'/g, "'");
+  }
+  return null;
+}
+
+function parseJavaScriptReturnObject(
+  node: SyntaxNode,
+  source: string,
+): ReturnObject | null {
+  const entries: ReturnEntry[] = [];
+  let closeBraceFrom = node.to - 1;
+  for (const child of childNodes(node)) {
+    if (child.name === '}') {
+      closeBraceFrom = child.from;
+      continue;
+    }
+    if (PUNCTUATION_NODE_NAMES.has(child.name)) {
+      continue;
+    }
+    if (child.name !== 'Property') {
+      return null;
+    }
+    const propertyChildren = childNodes(child);
+    const keyNode = propertyChildren.find(
+      (propertyChild) =>
+        propertyChild.name === 'PropertyDefinition' ||
+        propertyChild.name === 'String',
+    );
+    const propertySource = nodeText(child, source);
+    if (!keyNode || propertySource.trim().startsWith('[')) {
+      return null;
+    }
+    const keyRaw = nodeText(keyNode, source);
+    const name = parseQuotedString(keyRaw) || keyRaw;
+    if (!name) {
+      return null;
+    }
+    const colonIndex = propertyChildren.findIndex(
+      (propertyChild) => propertyChild.name === ':',
+    );
+    const shorthand = colonIndex < 0;
+    const valueNode = shorthand
+      ? keyNode
+      : propertyChildren
+          .slice(colonIndex + 1)
+          .find(
+            (propertyChild) => !PUNCTUATION_NODE_NAMES.has(propertyChild.name),
+          );
+    if (!valueNode) {
+      return null;
+    }
+    entries.push({
+      name,
+      keyFrom: keyNode.from,
+      keyTo: keyNode.to,
+      propertyFrom: child.from,
+      propertyTo: child.to,
+      shorthand,
+      valueNode,
+    });
+  }
+  return {
+    node,
+    closeBraceFrom,
+    entries,
+  };
+}
+
+function parsePythonReturnObject(
+  node: SyntaxNode,
+  source: string,
+): ReturnObject | null {
+  const children = childNodes(node);
+  const entries: ReturnEntry[] = [];
+  let closeBraceFrom = node.to - 1;
+  for (let index = 0; index < children.length; index += 1) {
+    const child = children[index];
+    if (child.name === '}') {
+      closeBraceFrom = child.from;
+      continue;
+    }
+    if (PUNCTUATION_NODE_NAMES.has(child.name)) {
+      continue;
+    }
+    if (child.name !== 'String') {
+      return null;
+    }
+    const colon = children[index + 1];
+    const valueNode = children[index + 2];
+    if (!colon || colon.name !== ':' || !valueNode) {
+      return null;
+    }
+    const name = parseQuotedString(nodeText(child, source));
+    if (!name) {
+      return null;
+    }
+    entries.push({
+      name,
+      keyFrom: child.from,
+      keyTo: child.to,
+      propertyFrom: child.from,
+      propertyTo: valueNode.to,
+      shorthand: false,
+      valueNode,
+    });
+    index += 2;
+  }
+  return {
+    node,
+    closeBraceFrom,
+    entries,
+  };
+}
+
+function collectReturnObjects(
+  document: ParsedDocument,
+  mainFunction: MainFunction,
+) {
+  const result: ReturnObject[] = [];
+  const expectedObjectName =
+    document.engine === 'python' ? 'DictionaryExpression' : 'ObjectExpression';
+
+  function visit(node: SyntaxNode) {
+    if (
+      node !== mainFunction.node &&
+      (node.name === 'FunctionDefinition' ||
+        node.name === 'FunctionDeclaration')
+    ) {
+      return;
+    }
+    if (node.name === 'ReturnStatement') {
+      const valueNode = significantChildren(node).find(
+        (child) => child.name !== 'return',
+      );
+      if (valueNode?.name === expectedObjectName) {
+        const returnObject =
+          document.engine === 'python'
+            ? parsePythonReturnObject(valueNode, document.source)
+            : parseJavaScriptReturnObject(valueNode, document.source);
+        if (returnObject) {
+          result.push(returnObject);
+        }
+      }
+      return;
+    }
+    childNodes(node).forEach(visit);
+  }
+
+  visit(mainFunction.body);
+  return result;
+}
+
+function normalizeDataType(value?: string) {
+  return SUPPORTED_DATA_TYPES.has(value as CodeNodeDataType)
+    ? (value as CodeNodeDataType)
+    : undefined;
+}
+
+function inferExpressionType(
+  node: SyntaxNode,
+  source: string,
+  environment: Map<string, CodeNodeDataType>,
+): CodeNodeDataType | undefined {
+  if (
+    node.name === 'String' ||
+    node.name === 'TemplateString' ||
+    node.name === 'FormatString'
+  ) {
+    return 'String';
+  }
+  if (node.name === 'Number') {
+    return 'Number';
+  }
+  if (node.name === 'Boolean' || node.name === 'BooleanLiteral') {
+    return 'Boolean';
+  }
+  if (
+    node.name === 'ObjectExpression' ||
+    node.name === 'DictionaryExpression'
+  ) {
+    return 'Object';
+  }
+  if (
+    node.name === 'ArrayExpression' ||
+    node.name === 'ListExpression' ||
+    node.name === 'SetExpression' ||
+    node.name === 'TupleExpression'
+  ) {
+    return 'Array';
+  }
+  if (
+    node.name === 'VariableName' ||
+    node.name === 'VariableDefinition' ||
+    node.name === 'PropertyDefinition'
+  ) {
+    return environment.get(nodeText(node, source));
+  }
+  if (node.name === 'ParenthesizedExpression') {
+    const inner = significantChildren(node)[0];
+    return inner ? inferExpressionType(inner, source, environment) : undefined;
+  }
+  if (node.name === 'BinaryExpression') {
+    const children = childNodes(node);
+    const operatorNode = children.find(
+      (child) =>
+        child.name === 'ArithOp' ||
+        child.name === 'CompareOp' ||
+        child.name === 'LogicOp',
+    );
+    const expressionNodes = children.filter(
+      (child) =>
+        !PUNCTUATION_NODE_NAMES.has(child.name) && child !== operatorNode,
+    );
+    const left = expressionNodes[0]
+      ? inferExpressionType(expressionNodes[0], source, environment)
+      : undefined;
+    const right = expressionNodes[1]
+      ? inferExpressionType(expressionNodes[1], source, environment)
+      : undefined;
+    const operator = operatorNode ? nodeText(operatorNode, source).trim() : '';
+    if (
+      operatorNode?.name === 'CompareOp' ||
+      ['==', '!=', '<', '<=', '>', '>=', 'in', 'is'].includes(operator)
+    ) {
+      return 'Boolean';
+    }
+    if (operator === '+' && (left === 'String' || right === 'String')) {
+      return 'String';
+    }
+    if (
+      left === 'Number' &&
+      right === 'Number' &&
+      ['+', '-', '*', '/', '//', '%', '**'].includes(operator)
+    ) {
+      return 'Number';
+    }
+    return undefined;
+  }
+  if (node.name === 'BooleanExpression' || node.name === 'CompareExpression') {
+    return 'Boolean';
+  }
+  if (node.name === 'UnaryExpression') {
+    const raw = nodeText(node, source).trim();
+    if (raw.startsWith('!') || raw.startsWith('not ')) {
+      return 'Boolean';
+    }
+    const child = significantChildren(node).at(-1);
+    return child && inferExpressionType(child, source, environment) === 'Number'
+      ? 'Number'
+      : undefined;
+  }
+  if (node.name === 'CallExpression') {
+    const callee = childNodes(node)[0];
+    const name = callee ? nodeText(callee, source) : '';
+    if (['String', 'str'].includes(name)) {
+      return 'String';
+    }
+    if (['Number', 'float', 'int'].includes(name)) {
+      return 'Number';
+    }
+    if (['Boolean', 'bool'].includes(name)) {
+      return 'Boolean';
+    }
+    if (['Array', 'list', 'set', 'tuple'].includes(name)) {
+      return 'Array';
+    }
+    if (['Object', 'dict'].includes(name)) {
+      return 'Object';
+    }
+  }
+  return undefined;
+}
+
+function collectAssignmentNodes(body: SyntaxNode) {
+  const result: SyntaxNode[] = [];
+  for (const node of childNodes(body)) {
+    if (
+      node.name === 'AssignStatement' ||
+      node.name === 'VariableDeclaration'
+    ) {
+      result.push(node);
+      continue;
+    }
+    if (node.name === 'ExpressionStatement') {
+      const assignment = significantChildren(node).find(
+        (child) => child.name === 'AssignmentExpression',
+      );
+      if (assignment) {
+        result.push(assignment);
+      }
+    }
+  }
+  return result.sort((left, right) => left.from - right.from);
+}
+
+function hasComplexControlFlow(body: SyntaxNode) {
+  function visit(node: SyntaxNode): boolean {
+    if (
+      node !== body &&
+      (node.name === 'FunctionDefinition' ||
+        node.name === 'FunctionDeclaration')
+    ) {
+      return false;
+    }
+    if (COMPLEX_CONTROL_FLOW_NODE_NAMES.has(node.name)) {
+      return true;
+    }
+    return childNodes(node).some(visit);
+  }
+
+  return visit(body);
+}
+
+function applyAssignmentType(
+  node: SyntaxNode,
+  source: string,
+  environment: Map<string, CodeNodeDataType>,
+) {
+  const children = childNodes(node);
+  const definitionNodes = children.filter(
+    (child) =>
+      child.name === 'VariableDefinition' || child.name === 'VariableName',
+  );
+  if (definitionNodes.length !== 1) {
+    return;
+  }
+  const equalsIndex = children.findIndex(
+    (child) => child.name === 'Equals' || child.name === 'AssignOp',
+  );
+  if (equalsIndex < 0) {
+    return;
+  }
+  const valueNode = children
+    .slice(equalsIndex + 1)
+    .find((child) => !PUNCTUATION_NODE_NAMES.has(child.name));
+  if (!valueNode) {
+    return;
+  }
+  const inferred = inferExpressionType(valueNode, source, environment);
+  const name = nodeText(definitionNodes[0], source);
+  if (inferred) {
+    environment.set(name, inferred);
+  } else {
+    environment.delete(name);
+  }
+}
+
+/**
+ * 分析 main 静态返回对象，并在受限范围内推断输出类型。
+ */
+export function analyzeCodeNodeOutputs(
+  source: string,
+  rawEngine: string | undefined,
+  parameters: Parameter[],
+) {
+  const document = parseDocument(source, rawEngine);
+  const mainFunction = document && findMainFunction(document);
+  if (!document || !mainFunction) {
+    return null;
+  }
+  const returnObjects = collectReturnObjects(document, mainFunction);
+  if (returnObjects.length === 0) {
+    return null;
+  }
+
+  const environment = new Map<string, CodeNodeDataType>();
+  for (const parameter of parameters) {
+    const name = String(parameter.name || '').trim();
+    const dataType = normalizeDataType(parameter.dataType);
+    if (name && dataType) {
+      environment.set(name, dataType);
+    }
+  }
+  if (!hasComplexControlFlow(mainFunction.body)) {
+    for (const assignment of collectAssignmentNodes(mainFunction.body)) {
+      applyAssignmentType(assignment, source, environment);
+    }
+  }
+
+  const inferredByName = new Map<
+    string,
+    { conflicted: boolean; dataType?: CodeNodeDataType }
+  >();
+  for (const returnObject of returnObjects) {
+    for (const entry of returnObject.entries) {
+      const inferred = inferExpressionType(
+        entry.valueNode,
+        source,
+        environment,
+      );
+      const current = inferredByName.get(entry.name);
+      if (!current) {
+        inferredByName.set(entry.name, {
+          dataType: inferred,
+          conflicted: false,
+        });
+      } else if (
+        !current.dataType ||
+        !inferred ||
+        current.dataType !== inferred
+      ) {
+        current.conflicted = true;
+        current.dataType = undefined;
+      }
+    }
+  }
+
+  return [...inferredByName.entries()].map(([name, inferred]) => ({
+    name,
+    dataType:
+      !inferred.conflicted && inferred.dataType ? inferred.dataType : 'String',
+  })) satisfies InferredCodeNodeOutput[];
+}
+
+/**
+ * 将代码分析结果合并到输出参数，仅自动维护仍由代码推断管理的项。
+ */
+export function reconcileInferredCodeNodeOutputs(
+  current: Parameter[],
+  inferred: InferredCodeNodeOutput[],
+  createId: () => string,
+) {
+  const inferredByName = new Map(
+    inferred.map((output) => [output.name, output]),
+  );
+  const existingNames = new Set<string>();
+  const result: Parameter[] = [];
+
+  for (const parameter of current) {
+    const name = String(parameter.name || '').trim();
+    const inferredOutput = inferredByName.get(name);
+    if (
+      parameter.codeInferred === true &&
+      parameter.codeInferredDataType &&
+      parameter.dataType !== parameter.codeInferredDataType
+    ) {
+      const {
+        codeInferred: _codeInferred,
+        codeInferredDataType: _codeInferredDataType,
+        ...manualParameter
+      } = parameter;
+      result.push(manualParameter);
+      if (name) {
+        existingNames.add(name);
+      }
+      continue;
+    }
+    if (parameter.codeInferred === true && !inferredOutput) {
+      continue;
+    }
+    if (parameter.codeInferred === true && inferredOutput) {
+      result.push({
+        ...parameter,
+        dataType: inferredOutput.dataType,
+        codeInferredDataType: inferredOutput.dataType,
+        codeSyncName: name,
+      });
+    } else {
+      result.push({ ...parameter });
+    }
+    if (name) {
+      existingNames.add(name);
+    }
+  }
+
+  for (const output of inferred) {
+    if (existingNames.has(output.name)) {
+      continue;
+    }
+    result.push({
+      id: createId(),
+      name: output.name,
+      dataType: output.dataType,
+      codeInferred: true,
+      codeInferredDataType: output.dataType,
+      codeSyncName: output.name,
+    });
+    existingNames.add(output.name);
+  }
+  return result;
+}
+
+function closeLineIndent(source: string, closeBraceFrom: number) {
+  const lineStart = source.lastIndexOf('\n', closeBraceFrom - 1) + 1;
+  const prefix = source.slice(lineStart, closeBraceFrom);
+  return /^\s*$/.test(prefix)
+    ? {
+        indent: prefix,
+        lineStart,
+      }
+    : null;
+}
+
+function buildOutputInsertEdits(
+  returnObject: ReturnObject,
+  names: string[],
+  document: ParsedDocument,
+) {
+  if (names.length === 0) {
+    return [] as SourceEdit[];
+  }
+  const defaultValue = document.engine === 'python' ? 'None' : 'null';
+  const indentUnit = document.engine === 'python' ? '    ' : '  ';
+  const lineIndent = closeLineIndent(
+    document.source,
+    returnObject.closeBraceFrom,
+  );
+  const edits: SourceEdit[] = [];
+
+  if (lineIndent) {
+    const entryIndent = lineIndent.indent + indentUnit;
+    const lines = names.map(
+      (name) => `${entryIndent}${JSON.stringify(name)}: ${defaultValue},`,
+    );
+    if (returnObject.entries.length > 0) {
+      const lastEntry = returnObject.entries[returnObject.entries.length - 1];
+      const afterLastEntry = document.source.slice(
+        lastEntry.propertyTo,
+        returnObject.closeBraceFrom,
+      );
+      if (!afterLastEntry.includes(',')) {
+        edits.push({
+          from: lastEntry.propertyTo,
+          to: lastEntry.propertyTo,
+          insert: ',',
+        });
+      }
+    }
+    edits.push({
+      from: lineIndent.lineStart,
+      to: returnObject.closeBraceFrom,
+      insert: `${lines.join('\n')}\n${lineIndent.indent}`,
+    });
+    return edits;
+  }
+
+  const prefix = returnObject.entries.length > 0 ? ', ' : '';
+  edits.push({
+    from: returnObject.closeBraceFrom,
+    to: returnObject.closeBraceFrom,
+    insert: `${prefix}${names
+      .map((name) => `${JSON.stringify(name)}: ${defaultValue}`)
+      .join(', ')}`,
+  });
+  return edits;
+}
+
+/**
+ * 将输出参数新增和改名安全同步到 main 的静态返回对象。
+ */
+export function syncCodeNodeOutputDefinitions(
+  source: string,
+  rawEngine: string | undefined,
+  previous: Parameter[],
+  next: Parameter[],
+) {
+  const nextWithSyncNames = withPreviousSyncNames(previous, next).map(
+    (parameter) => {
+      const oldParameter = previous.find(
+        (candidate) => candidate.id && candidate.id === parameter.id,
+      );
+      if (
+        oldParameter?.codeInferred === true &&
+        oldParameter.dataType !== parameter.dataType
+      ) {
+        const {
+          codeInferred: _codeInferred,
+          codeInferredDataType: _codeInferredDataType,
+          ...manualParameter
+        } = parameter;
+        return manualParameter;
+      }
+      return parameter;
+    },
+  );
+  const nextNames = nextWithSyncNames.map((parameter) =>
+    String(parameter.name || '').trim(),
+  );
+  if (
+    nextNames.some((name) => !name) ||
+    new Set(nextNames).size !== nextNames.length
+  ) {
+    return {
+      code: source,
+      outputDefs: nextWithSyncNames,
+      reason: '输出参数名称为空或重复',
+      synced: false,
+    };
+  }
+
+  const document = parseDocument(source, rawEngine);
+  const mainFunction = document && findMainFunction(document);
+  if (!document || !mainFunction) {
+    return {
+      code: source,
+      outputDefs: nextWithSyncNames,
+      reason: '未找到可安全同步的 main 函数',
+      synced: false,
+    };
+  }
+  const returnObjects = collectReturnObjects(document, mainFunction);
+  if (returnObjects.length === 0) {
+    return {
+      code: source,
+      outputDefs: nextWithSyncNames,
+      reason: 'main 中没有静态对象返回值',
+      synced: false,
+    };
+  }
+
+  const previousById = new Map(
+    previous
+      .filter((parameter) => parameter.id)
+      .map((parameter) => [parameter.id, parameter]),
+  );
+  const renames: Array<{ from: string; to: string }> = [];
+  const additions: string[] = [];
+  for (const parameter of nextWithSyncNames) {
+    const previousParameter = parameter.id
+      ? previousById.get(parameter.id)
+      : undefined;
+    const oldName = String(
+      previousParameter?.codeSyncName || previousParameter?.name || '',
+    ).trim();
+    const newName = String(parameter.name || '').trim();
+    if (oldName && oldName !== newName) {
+      renames.push({
+        from: oldName,
+        to: newName,
+      });
+    } else if (!oldName && newName) {
+      additions.push(newName);
+    }
+  }
+
+  const edits: SourceEdit[] = [];
+  for (const returnObject of returnObjects) {
+    const namesAfterRename = new Set(
+      returnObject.entries.map((entry) => {
+        const rename = renames.find(
+          (candidate) => candidate.from === entry.name,
+        );
+        return rename?.to || entry.name;
+      }),
+    );
+    for (const rename of renames) {
+      if (
+        rename.from !== rename.to &&
+        namesAfterRename.has(rename.to) &&
+        returnObject.entries.some(
+          (entry) => entry.name === rename.to && entry.name !== rename.from,
+        )
+      ) {
+        return {
+          code: source,
+          outputDefs: nextWithSyncNames,
+          reason: `return 中已存在输出字段 ${rename.to}`,
+          synced: false,
+        };
+      }
+      const entry = returnObject.entries.find(
+        (candidate) => candidate.name === rename.from,
+      );
+      if (!entry) {
+        continue;
+      }
+      if (entry.shorthand) {
+        edits.push({
+          from: entry.propertyFrom,
+          to: entry.propertyTo,
+          insert: `${JSON.stringify(rename.to)}: ${rename.from}`,
+        });
+      } else {
+        edits.push({
+          from: entry.keyFrom,
+          to: entry.keyTo,
+          insert: JSON.stringify(rename.to),
+        });
+      }
+    }
+    const missingRenameTargets = renames
+      .filter(
+        (rename) =>
+          !returnObject.entries.some((entry) => entry.name === rename.from),
+      )
+      .map((rename) => rename.to);
+    const missing = [...additions, ...missingRenameTargets].filter(
+      (name, index, names) =>
+        !namesAfterRename.has(name) && names.indexOf(name) === index,
+    );
+    edits.push(...buildOutputInsertEdits(returnObject, missing, document));
+  }
+
+  const code = applySourceEdits(source, edits);
+  return {
+    code,
+    outputDefs: nextWithSyncNames.map((parameter) => ({
+      ...parameter,
+      codeSyncName: String(parameter.name || '').trim(),
+    })),
+    synced: true,
+  };
+}
diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/nodePalette.ts b/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/nodePalette.ts
index 79c19819..398eaa56 100644
--- a/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/nodePalette.ts
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/components/utils/nodePalette.ts
@@ -2,6 +2,8 @@ import type { Node } from '@xyflow/svelte';
 
 import type { TinyflowOptions } from '#types';
 
+import { DEFAULT_CODE_NODE_JAVASCRIPT } from './codeNodeScaffold';
+
 export type NodePaletteItem = {
   icon?: string;
   title: string;
@@ -76,6 +78,12 @@ const BUILT_IN_NODES: NodePaletteItem[] = [
     sortNo: 700,
     description: '动态执行代码',
     category: '逻辑',
+    extra: {
+      code: DEFAULT_CODE_NODE_JAVASCRIPT,
+      codeScaffoldManaged: true,
+      codeScaffoldVersion: 1,
+      engine: 'js',
+    },
   },
   {
     icon: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path d="M2 4C2 3.44772 2.44772 3 3 3H21C21.5523 3 22 3.44772 22 4V20C22 20.5523 21.5523 21 21 21H3C2.44772 21 2 20.5523 2 20V4ZM4 5V19H20V5H4ZM7 8H17V11H15V10H13V14H14.5V16H9.5V14H11V10H9V11H7V8Z"></path></svg>',
diff --git a/easyflow-ui-admin/packages/tinyflow-ui/src/types.ts b/easyflow-ui-admin/packages/tinyflow-ui/src/types.ts
index e371d703..501ccc57 100644
--- a/easyflow-ui-admin/packages/tinyflow-ui/src/types.ts
+++ b/easyflow-ui-admin/packages/tinyflow-ui/src/types.ts
@@ -1,5 +1,5 @@
-import type {Snippet} from 'svelte';
-import type {Node, useSvelteFlow} from '@xyflow/svelte';
+import type { Snippet } from 'svelte';
+import type { Node, useSvelteFlow } from '@xyflow/svelte';
 
 export type TinyflowData = Partial<
   ReturnType<ReturnType<typeof useSvelteFlow>['toObject']>
@@ -135,10 +135,7 @@ export type TinyflowOptions = {
   onRunTest?: () => void | Promise<void>;
   hiddenNodes?: string[] | (() => string[]);
   onDataChange?: (data: TinyflowData) => void;
-  onDataCommit?: (
-    data: TinyflowData,
-    reason: TinyflowDataCommitReason,
-  ) => void;
+  onDataCommit?: (data: TinyflowData, reason: TinyflowDataCommitReason) => void;
 };
 
 export type Parameter = {
@@ -171,5 +168,14 @@ export type Parameter = {
   requiredDisabled?: boolean;
   systemReserved?: boolean;
   autoManaged?: boolean;
+  codeInferred?: boolean;
+  codeInferredDataType?: string;
+  codeSyncName?: string;
   flattenAggregation?: boolean;
 };
+
+export type ParameterChangeHandler = (
+  previousParameters: Parameter[],
+  nextParameters: Parameter[],
+  nodeData: TinyflowNodeData,
+) => Partial<TinyflowNodeData> | void;