diff --git a/src/components/d-flow-data-type/DFlowDataType.service.ts b/src/components/d-flow-data-type/DFlowDataType.service.ts
index b1bd8ee9..a7d130da 100644
--- a/src/components/d-flow-data-type/DFlowDataType.service.ts
+++ b/src/components/d-flow-data-type/DFlowDataType.service.ts
@@ -5,14 +5,20 @@ import {
     DataTypeIdentifier,
     DataTypeRule,
     DataTypeRulesContainsKeyConfig,
-    DataTypeRulesInputTypesConfig, Flow,
+    DataTypeRulesInputTypesConfig,
+    Flow,
     GenericMapper,
     LiteralValue,
-    Maybe, Namespace, NamespaceProject,
-    NodeParameterValue, Runtime,
+    Maybe,
+    Namespace,
+    NamespaceProject,
+    NodeFunctionIdWrapper,
+    NodeParameterValue,
+    Runtime,
     Scalars
 } from "@code0-tech/sagittarius-graphql-types";
 import {useValueValidation} from "../d-flow-validation/DValueValidation.hook";
+import {findReturnNode} from "./rules/DFlowDataTypeReturnTypeRule";
 
 export type DFlowDataTypeDependencies = {
     namespaceId: Namespace['id']
@@ -103,8 +109,15 @@ export abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<
             if (ruleThatIncludesGenericKey
                 && ruleThatIncludesGenericKey.variant == "RETURN_TYPE"
                 && dataType.variant === "NODE") {
+
+                const foundReturnFunction = findReturnNode(value as NodeFunctionIdWrapper, flow!!)
+                const returnValue = foundReturnFunction?.parameters?.nodes?.[0]?.value;
+
                 return {
-                    sourceDataTypeIdentifiers: [this.getTypeFromValue(value, flow, dependencies)],
+                    sourceDataTypeIdentifiers: [this.getTypeFromValue(returnValue ?? {
+                        __typename: "LiteralValue",
+                        value: null
+                    }, flow, dependencies)],
                     target: genericKey
                 } as GenericMapper
             }
diff --git a/src/components/d-flow-data-type/rules/DFlowDataTypeRegexRule.ts b/src/components/d-flow-data-type/rules/DFlowDataTypeRegexRule.ts
index 4be782d4..438de22c 100644
--- a/src/components/d-flow-data-type/rules/DFlowDataTypeRegexRule.ts
+++ b/src/components/d-flow-data-type/rules/DFlowDataTypeRegexRule.ts
@@ -4,7 +4,7 @@ import type {DataTypeRulesRegexConfig, NodeParameterValue} from "@code0-tech/sag
 @staticImplements<DFlowDataTypeRule>()
 export class DFlowDataTypeRegexRule {
     public static validate(value: NodeParameterValue, config: DataTypeRulesRegexConfig): boolean {
-        if (value.__typename != 'LiteralValue') return false
+        if (value?.__typename != 'LiteralValue') return false
         if (!config.pattern) return false
         return new RegExp(config.pattern).test(String(value.value))
     }
diff --git a/src/components/d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.ts b/src/components/d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.ts
index bdbe465b..bb8e7dbf 100644
--- a/src/components/d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.ts
+++ b/src/components/d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.ts
@@ -30,10 +30,11 @@ export class DFlowDataTypeReturnTypeRule {
 
         if (value.__typename != "NodeFunctionIdWrapper") return false
 
+        if (config?.dataTypeIdentifier?.genericKey && !genericMapper && !service?.getDataType(config.dataTypeIdentifier)) return true
+
         const foundReturnFunction = findReturnNode(value, flow!!)
         if (!foundReturnFunction) return false
-
-        if (config?.dataTypeIdentifier?.genericKey && !genericMapper && !service?.getDataType(config.dataTypeIdentifier)) return true
+        if (!foundReturnFunction?.parameters?.nodes?.[0]?.value) return false
 
         if (!(service?.getDataType(config.dataTypeIdentifier!!) || genericMapper)) return false
 
@@ -43,13 +44,13 @@ export class DFlowDataTypeReturnTypeRule {
         //check if all generic combinations are set
         if (genericMapper && !(((genericCombination?.length ?? 0) + 1) == genericTypes!!.length)) return false
 
-        if (foundReturnFunction?.parameters?.nodes!![0]?.value!!.__typename === "ReferenceValue") {
+        if (foundReturnFunction?.parameters?.nodes?.[0]?.value?.__typename === "ReferenceValue") {
 
             //use generic given type for checking against value
             if (config?.dataTypeIdentifier?.genericKey && genericMapper && genericTypes) {
 
                 const checkAllTypes: boolean[] = genericTypes.map(genericType => {
-                    return useDataTypeValidation(service?.getDataType(genericType)!!, service?.getDataType((foundReturnFunction?.parameters?.nodes!![0]?.value!! as ReferenceValue).dataTypeIdentifier!!)!!)
+                    return useDataTypeValidation(service?.getDataType(genericType)!!, service?.getDataType((foundReturnFunction?.parameters?.nodes?.[0]?.value as ReferenceValue).dataTypeIdentifier!)!)
                 })
 
                 return checkAllTypes.length > 1 ? checkAllTypes.reduce((previousValue, currentValue, currentIndex) => {
@@ -62,10 +63,10 @@ export class DFlowDataTypeReturnTypeRule {
             }
 
             if (config?.dataTypeIdentifier?.dataType) {
-                return useDataTypeValidation(service?.getDataType(config.dataTypeIdentifier!!)!!, service?.getDataType(foundReturnFunction?.parameters?.nodes!![0]?.value?.dataTypeIdentifier!!)!!)
+                return useDataTypeValidation(service?.getDataType(config.dataTypeIdentifier!)!, service?.getDataType(foundReturnFunction?.parameters?.nodes?.[0]?.value?.dataTypeIdentifier!)!)
             }
 
-        } else if (foundReturnFunction?.parameters?.nodes!![0]?.value?.__typename == "NodeFunctionIdWrapper") {
+        } else if (foundReturnFunction?.parameters?.nodes?.[0]?.value?.__typename == "NodeFunctionIdWrapper") {
             //TODO : allow function as return value
         } else {
 
@@ -73,7 +74,7 @@ export class DFlowDataTypeReturnTypeRule {
             if (config?.dataTypeIdentifier?.genericKey && genericMapper && genericTypes) {
 
                 const checkAllTypes: boolean[] = genericTypes.map(genericType => {
-                    return useValueValidation(foundReturnFunction?.parameters?.nodes!![0]?.value!!, service?.getDataType(genericType)!!, service!!, flow, ((genericType.genericType as GenericType)!!.genericMappers as GenericMapper[]))
+                    return useValueValidation(foundReturnFunction?.parameters?.nodes?.[0]?.value!, service?.getDataType(genericType)!!, service!!, flow, ((genericType.genericType as GenericType)!!.genericMappers as GenericMapper[]))
                 })
 
                 return checkAllTypes.length > 1 ? checkAllTypes.reduce((previousValue, currentValue, currentIndex) => {
@@ -86,10 +87,10 @@ export class DFlowDataTypeReturnTypeRule {
             }
 
             if (config?.dataTypeIdentifier?.dataType) {
-                return useValueValidation(foundReturnFunction?.parameters?.nodes!![0]?.value!!, service?.getDataType(config.dataTypeIdentifier!!)!!, service!!)
+                return useValueValidation(foundReturnFunction?.parameters?.nodes?.[0]?.value!, service?.getDataType(config.dataTypeIdentifier!)!, service!!)
             }
 
-            return useValueValidation(foundReturnFunction?.parameters?.nodes!![0]?.value!!, service?.getDataType(config.dataTypeIdentifier!!)!!, service!!, flow, genericMapping(config.dataTypeIdentifier?.genericType?.genericMappers!!, generics))
+            return useValueValidation(foundReturnFunction?.parameters?.nodes?.[0]?.value!, service?.getDataType(config.dataTypeIdentifier!)!, service!!, flow, genericMapping(config.dataTypeIdentifier?.genericType?.genericMappers!, generics))
 
         }
 
@@ -98,13 +99,14 @@ export class DFlowDataTypeReturnTypeRule {
     }
 }
 
-const findReturnNode = (n: NodeFunctionIdWrapper, flow: Flow): NodeFunction | undefined => {
+export const findReturnNode = (n: NodeFunctionIdWrapper, flow: Flow): NodeFunction | undefined => {
 
 
     const node = flow.nodes?.nodes?.find(node => node?.id === n.id) as NodeFunction | undefined
-    if (node?.functionDefinition?.runtimeFunctionDefinition?.identifier === 'RETURN') return node
+    if (!node) return undefined
+    if (node?.functionDefinition?.runtimeFunctionDefinition?.identifier === 'std::control::return') return node
 
-    if (node) {
+    if (node && node.nextNodeId) {
         const found = findReturnNode({
             id: node.nextNodeId,
             __typename: "NodeFunctionIdWrapper"