@awesome-flow/noise 0.3.0 → 0.4.0

package/dist/nodes/index.js

@@ -71,150 +71,15 @@ var require_fast_deep_equal = __commonJS({
 
 // src/nodes/generators/noise-billow-node.tsx
 import { NodeContainer, NodeTrackConnections } from "@awesome-flow/core/layout";
-import { useCallback as useCallback2, useMemo as useMemo2 } from "react";
+import { useCallback, useMemo } from "react";
 import { Billow } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData } from "@awesome-flow/core/hooks";
-import { nodeDataPropertyExcept as nodeDataPropertyExcept2 } from "@awesome-flow/core/abstract";
-
-// src/layout/node-property-variables.tsx
-import { useIncomingNodeData, useUpdateNodeData } from "@awesome-flow/core/hooks";
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { Group, Stack } from "@mantine/core";
-import { getObjectKeys } from "@awesome-flow/core/utils";
-import { nodeDataPropertyExcept } from "@awesome-flow/core/abstract";
-
-// src/layout/node-value-input.tsx
-import { Input, NumberInput, Switch } from "@mantine/core";
-import { Fragment, jsx } from "react/jsx-runtime";
-function NodeValueInput({ value, disabled, step, onChange }) {
-  if (value === void 0 || value === null) {
-    return /* @__PURE__ */ jsx(Fragment, {});
-  }
-  switch (typeof value) {
-    case "boolean": {
-      return /* @__PURE__ */ jsx(
-        Switch,
-        {
-          checked: value,
-          disabled,
-          onChange: (e) => onChange(e.currentTarget.checked)
-        }
-      );
-    }
-    case "number": {
-      return /* @__PURE__ */ jsx(NumberInput, { value, disabled, step, onChange: (e) => onChange(e) });
-    }
-    case "string": {
-      return /* @__PURE__ */ jsx(
-        Input,
-        {
-          value,
-          disabled,
-          onChange: (e) => onChange(e.currentTarget.value)
-        }
-      );
-    }
-    default:
-      throw new Error(`Unknown input node for value of type: ${typeof value} (${value})`);
-  }
-}
-var node_value_input_default = NodeValueInput;
-
-// src/layout/node-property-input.tsx
-import { Fragment as Fragment2, jsx as jsx2 } from "react/jsx-runtime";
-function NodePropertyInput({ property, onChange }) {
-  if (!property) {
-    return /* @__PURE__ */ jsx2(Fragment2, {});
-  }
-  return /* @__PURE__ */ jsx2(
-    node_value_input_default,
-    {
-      value: property.value,
-      disabled: property.disabled,
-      step: property.step,
-      onChange: (value) => onChange(property.name, value)
-    }
-  );
-}
-var node_property_input_default = NodePropertyInput;
-
-// src/layout/node-property-variables.tsx
-import { jsx as jsx3, jsxs } from "react/jsx-runtime";
-function NodePropertyVariables({
-  data,
-  nodeId,
-  onPropertiesChange,
-  except = nodeDataPropertyExcept
-}) {
-  const [properties, setProperties] = useState(() => {
-    const keys = getObjectKeys(data, except);
-    const dataProps = {};
-    for (const key of keys) {
-      dataProps[key] = {
-        name: key,
-        value: data[key]
-      };
-    }
-    return dataProps;
-  });
-  const updateNodeData = useUpdateNodeData();
-  const incoming = useIncomingNodeData(nodeId);
-  const resetAllDisabled = useCallback(() => {
-    const keys = Object.keys(properties);
-    keys.forEach((k) => {
-      properties[k].disabled = false;
-    });
-    setProperties(properties);
-  }, []);
-  const updatePropertyValue = useCallback((name, value, disabled) => {
-    let property = properties[name];
-    if (property) {
-      property.value = value;
-    } else {
-      property = {
-        name,
-        value
-      };
-    }
-    property.disabled = disabled;
-    setProperties({ ...properties, [name]: property });
-    updateNodeData(nodeId, { [name]: value });
-  }, []);
-  useEffect(() => {
-    resetAllDisabled();
-    if (incoming?.length) {
-      for (const connection of incoming) {
-        if (connection.property && properties[connection.property.name] !== void 0) {
-          updatePropertyValue(connection.property.name, connection.property.value, true);
-        }
-      }
-    }
-  }, [incoming]);
-  useEffect(() => {
-    if (onPropertiesChange) {
-      onPropertiesChange(properties);
-    }
-  }, [onPropertiesChange, properties]);
-  const nodes = useMemo(() => {
-    return Object.keys(properties).map((key) => {
-      const property = properties[key];
-      return /* @__PURE__ */ jsxs(Group, { children: [
-        property.name,
-        ":",
-        /* @__PURE__ */ jsx3(node_property_input_default, { property, onChange: updatePropertyValue })
-      ] }, key);
-    });
-  }, [properties, updatePropertyValue]);
-  return /* @__PURE__ */ jsx3(Stack, { children: nodes });
-}
-var node_property_variables_default = NodePropertyVariables;
-
-// src/nodes/generators/noise-billow-node.tsx
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+import { NodePropertyVariables } from "@awesome-flow/core/components";
+import { jsx, jsxs } from "react/jsx-runtime";
 function NoiseBillowNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData();
-  const module = useMemo2(() => new Billow(), []);
-  const onPropertiesChange = useCallback2(
+  const module = useMemo(() => new Billow(), []);
+  const onPropertiesChange = useCallback(
     (properties) => {
       Object.keys(properties).forEach((k) => {
         module[k] = properties[k].value;
@@ -223,65 +88,57 @@ function NoiseBillowNode({ id, selected, data, type }) {
     },
     [id, module, updateComputedData]
   );
-  return /* @__PURE__ */ jsxs2(NodeContainer, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx4(
-      node_property_variables_default,
-      {
-        data,
-        except: nodeDataPropertyExcept2,
-        nodeId: id,
-        onPropertiesChange
-      }
-    ),
-    /* @__PURE__ */ jsx4(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs(NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx(NodePropertyVariables, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_billow_node_default = NoiseBillowNode;
 
 // src/nodes/generators/noise-checkerboard-node.tsx
 import { NodeContainer as NodeContainer2 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect2, useMemo as useMemo3 } from "react";
+import { useEffect, useMemo as useMemo2 } from "react";
 import { Checkerboard } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData2 } from "@awesome-flow/core/hooks";
-import { jsx as jsx5 } from "react/jsx-runtime";
+import { jsx as jsx2 } from "react/jsx-runtime";
 function NoiseCheckerboardNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData2();
-  const module = useMemo3(() => new Checkerboard(), []);
-  useEffect2(() => {
+  const module = useMemo2(() => new Checkerboard(), []);
+  useEffect(() => {
     updateComputedData(id, { module });
   }, [id, module, updateComputedData]);
-  return /* @__PURE__ */ jsx5(NodeContainer2, { id, selected, data, type });
+  return /* @__PURE__ */ jsx2(NodeContainer2, { id, selected, data, type });
 }
 var noise_checkerboard_node_default = NoiseCheckerboardNode;
 
 // src/nodes/generators/noise-const-node.tsx
 import { NodeContainer as NodeContainer3 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect3, useMemo as useMemo4, useState as useState2 } from "react";
-import { Group as Group2, NumberInput as NumberInput2, Stack as Stack2 } from "@mantine/core";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData3, useUpdateNodeData as useUpdateNodeData2 } from "@awesome-flow/core/hooks";
+import { useEffect as useEffect2, useMemo as useMemo3, useState } from "react";
+import { Group, NumberInput, Stack } from "@mantine/core";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData3, useUpdateNodeData } from "@awesome-flow/core/hooks";
 import { Const } from "libnoise-ts/module/generator";
-import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 function NoiseConstNode({ id, selected, data, type }) {
-  const [min, setMin] = useState2(data.min);
-  const [max, setMax] = useState2(data.max);
-  const [noise, setNoise] = useState2(data.noise);
-  const updateNodeData = useUpdateNodeData2();
+  const [min, setMin] = useState(data.min);
+  const [max, setMax] = useState(data.max);
+  const [noise, setNoise] = useState(data.noise);
+  const updateNodeData = useUpdateNodeData();
   const updateComputedData = useUpdateNodeComputedData3();
-  const module = useMemo4(() => new Const(), []);
-  useEffect3(() => {
+  const module = useMemo3(() => new Const(), []);
+  useEffect2(() => {
     module.value = noise;
     updateNodeData(id, { noise, min, max });
     updateComputedData(id, { module });
   }, [noise, min, max, module, updateNodeData, id, updateComputedData]);
-  return /* @__PURE__ */ jsx6(NodeContainer3, { id, selected, data, type, children: /* @__PURE__ */ jsxs3(Stack2, { children: [
-    /* @__PURE__ */ jsxs3(Group2, { children: [
-      /* @__PURE__ */ jsx6(NumberInput2, { size: "xs", w: 100, value: min, onChange: (e) => setMin(Number(e)) }),
-      /* @__PURE__ */ jsx6(NumberInput2, { size: "xs", w: 100, value: max, onChange: (e) => setMax(Number(e)) })
+  return /* @__PURE__ */ jsx3(NodeContainer3, { id, selected, data, type, children: /* @__PURE__ */ jsxs2(Stack, { children: [
+    /* @__PURE__ */ jsxs2(Group, { children: [
+      /* @__PURE__ */ jsx3(NumberInput, { size: "xs", w: 100, value: min, onChange: (e) => setMin(Number(e)) }),
+      /* @__PURE__ */ jsx3(NumberInput, { size: "xs", w: 100, value: max, onChange: (e) => setMax(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs3(Group2, { children: [
+    /* @__PURE__ */ jsxs2(Group, { children: [
       "noise:",
-      /* @__PURE__ */ jsx6(
-        NumberInput2,
+      /* @__PURE__ */ jsx3(
+        NumberInput,
         {
           size: "xs",
           value: noise,
@@ -298,14 +155,15 @@ var noise_const_node_default = NoiseConstNode;
 
 // src/nodes/generators/noise-cylinders-node.tsx
 import { NodeContainer as NodeContainer4, NodeTrackConnections as NodeTrackConnections2 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback3, useMemo as useMemo5 } from "react";
+import { useCallback as useCallback2, useMemo as useMemo4 } from "react";
 import { Cylinders } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData4 } from "@awesome-flow/core/hooks";
-import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables2 } from "@awesome-flow/core/components";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 function NoiseCylindersNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData4();
-  const module = useMemo5(() => new Cylinders(), []);
-  const onPropertiesChange = useCallback3(
+  const module = useMemo4(() => new Cylinders(), []);
+  const onPropertiesChange = useCallback2(
     (properties) => {
       Object.keys(properties).forEach((k) => {
         module[k] = properties[k].value;
@@ -314,23 +172,24 @@ function NoiseCylindersNode({ id, selected, data, type }) {
     },
     [id, module, updateComputedData]
   );
-  return /* @__PURE__ */ jsxs4(NodeContainer4, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx7(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx7(NodeTrackConnections2, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs3(NodeContainer4, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx4(NodePropertyVariables2, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx4(NodeTrackConnections2, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_cylinders_node_default = NoiseCylindersNode;
 
 // src/nodes/generators/noise-perlin-node.tsx
 import { NodeContainer as NodeContainer5, NodeTrackConnections as NodeTrackConnections3 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback4, useMemo as useMemo6 } from "react";
+import { useCallback as useCallback3, useMemo as useMemo5 } from "react";
 import { Perlin } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData5 } from "@awesome-flow/core/hooks";
-import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables3 } from "@awesome-flow/core/components";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 function NoisePerlinNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData5();
-  const module = useMemo6(() => new Perlin(), []);
-  const onPropertiesChange = useCallback4(
+  const module = useMemo5(() => new Perlin(), []);
+  const onPropertiesChange = useCallback3(
     (properties) => {
       Object.keys(properties).forEach((k) => {
         module[k] = properties[k].value;
@@ -339,36 +198,37 @@ function NoisePerlinNode({ id, selected, data, type }) {
     },
     [id, module, updateComputedData]
   );
-  return /* @__PURE__ */ jsxs5(NodeContainer5, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx8(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx8(NodeTrackConnections3, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs4(NodeContainer5, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx5(NodePropertyVariables3, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx5(NodeTrackConnections3, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_perlin_node_default = NoisePerlinNode;
 
 // src/nodes/generators/noise-ridgedmulti-node.tsx
 import { NodeContainer as NodeContainer6, NodeTrackConnections as NodeTrackConnections4 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback5, useMemo as useMemo7 } from "react";
+import { useCallback as useCallback4, useMemo as useMemo6 } from "react";
 import { RidgedMulti } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData6 } from "@awesome-flow/core/hooks";
-import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables4 } from "@awesome-flow/core/components";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 function NoiseRidgedMultiNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData6();
-  const module = useMemo7(() => new RidgedMulti(), []);
-  const onPropertiesChange = useCallback5((properties) => {
+  const module = useMemo6(() => new RidgedMulti(), []);
+  const onPropertiesChange = useCallback4((properties) => {
     Object.keys(properties).forEach((k) => module[k] = properties[k].value);
     updateComputedData(id, { module });
   }, []);
-  return /* @__PURE__ */ jsxs6(NodeContainer6, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx9(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx9(NodeTrackConnections4, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs5(NodeContainer6, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx6(NodePropertyVariables4, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx6(NodeTrackConnections4, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_ridgedmulti_node_default = NoiseRidgedMultiNode;
 
 // src/nodes/generators/noise-simplex-node.tsx
 import { NodeContainer as NodeContainer7 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect4, useMemo as useMemo8 } from "react";
+import { useEffect as useEffect3, useMemo as useMemo7 } from "react";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData7 } from "@awesome-flow/core/hooks";
 
 // src/modules/simplex-module.ts
@@ -386,46 +246,48 @@ var SimplexModule = class extends Module {
 };
 
 // src/nodes/generators/noise-simplex-node.tsx
-import { jsx as jsx10 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 function NoiseSimplexNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData7();
-  const module = useMemo8(() => new SimplexModule(), []);
-  useEffect4(() => {
+  const module = useMemo7(() => new SimplexModule(), []);
+  useEffect3(() => {
     updateComputedData(id, { module });
   }, []);
-  return /* @__PURE__ */ jsx10(NodeContainer7, { id, selected, data, type });
+  return /* @__PURE__ */ jsx7(NodeContainer7, { id, selected, data, type });
 }
 var noise_simplex_node_default = NoiseSimplexNode;
 
 // src/nodes/generators/noise-spheres-node.tsx
 import { NodeContainer as NodeContainer8, NodeTrackConnections as NodeTrackConnections5 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback6, useMemo as useMemo9 } from "react";
+import { useCallback as useCallback5, useMemo as useMemo8 } from "react";
 import { Spheres } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData8 } from "@awesome-flow/core/hooks";
-import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables5 } from "@awesome-flow/core/components";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 function NoiseSpheresNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData8();
-  const module = useMemo9(() => new Spheres(), []);
-  const onPropertiesChange = useCallback6((properties) => {
+  const module = useMemo8(() => new Spheres(), []);
+  const onPropertiesChange = useCallback5((properties) => {
     Object.keys(properties).forEach((k) => module[k] = properties[k].value);
     updateComputedData(id, { module });
   }, []);
-  return /* @__PURE__ */ jsxs7(NodeContainer8, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx11(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx11(NodeTrackConnections5, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs6(NodeContainer8, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx8(NodePropertyVariables5, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx8(NodeTrackConnections5, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_spheres_node_default = NoiseSpheresNode;
 
 // src/nodes/generators/noise-voronoi-node.tsx
 import { NodeContainer as NodeContainer9, NodeTrackConnections as NodeTrackConnections6 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback7 } from "react";
+import { useCallback as useCallback6 } from "react";
 import { Voronoi } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData9 } from "@awesome-flow/core/hooks";
-import { jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables6 } from "@awesome-flow/core/components";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 function NoiseVoronoiNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData9();
-  const onPropertiesChange = useCallback7(
+  const onPropertiesChange = useCallback6(
     (properties) => {
       const module = new Voronoi(
         properties.frequency.value,
@@ -437,27 +299,27 @@ function NoiseVoronoiNode({ id, selected, data, type }) {
     },
     []
   );
-  return /* @__PURE__ */ jsxs8(NodeContainer9, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx12(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx12(NodeTrackConnections6, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs7(NodeContainer9, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx9(NodePropertyVariables6, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx9(NodeTrackConnections6, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_voronoi_node_default = NoiseVoronoiNode;
 
 // src/nodes/generators/position-const-node.tsx
 import { NodeContainer as NodeContainer10 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect5, useState as useState3 } from "react";
-import { Group as Group3, NumberInput as NumberInput3, Stack as Stack3 } from "@mantine/core";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData10, useUpdateNodeData as useUpdateNodeData3 } from "@awesome-flow/core/hooks";
-import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+import { useEffect as useEffect4, useState as useState2 } from "react";
+import { Group as Group2, NumberInput as NumberInput2, Stack as Stack2 } from "@mantine/core";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData10, useUpdateNodeData as useUpdateNodeData2 } from "@awesome-flow/core/hooks";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
 function PositionConstNode({ id, selected, data, type }) {
   const position = data.position ?? { x: 0, y: 0, z: 0 };
-  const [x, setX] = useState3(position.x);
-  const [y, setY] = useState3(position.y);
-  const [z, setZ] = useState3(position.z);
-  const updateNodeData = useUpdateNodeData3();
+  const [x, setX] = useState2(position.x);
+  const [y, setY] = useState2(position.y);
+  const [z, setZ] = useState2(position.z);
+  const updateNodeData = useUpdateNodeData2();
   const updateComputedData = useUpdateNodeComputedData10();
-  useEffect5(() => {
+  useEffect4(() => {
     const position2 = { x, y, z };
     updateNodeData(id, {
       position: position2
@@ -466,18 +328,18 @@ function PositionConstNode({ id, selected, data, type }) {
       positions: [position2]
     });
   }, [x, y, z]);
-  return /* @__PURE__ */ jsx13(NodeContainer10, { id, selected, data, type, children: /* @__PURE__ */ jsxs9(Stack3, { children: [
-    /* @__PURE__ */ jsxs9(Group3, { children: [
+  return /* @__PURE__ */ jsx10(NodeContainer10, { id, selected, data, type, children: /* @__PURE__ */ jsxs8(Stack2, { children: [
+    /* @__PURE__ */ jsxs8(Group2, { children: [
       "x: ",
-      /* @__PURE__ */ jsx13(NumberInput3, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+      /* @__PURE__ */ jsx10(NumberInput2, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs9(Group3, { children: [
+    /* @__PURE__ */ jsxs8(Group2, { children: [
       "y: ",
-      /* @__PURE__ */ jsx13(NumberInput3, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+      /* @__PURE__ */ jsx10(NumberInput2, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs9(Group3, { children: [
+    /* @__PURE__ */ jsxs8(Group2, { children: [
       "z: ",
-      /* @__PURE__ */ jsx13(NumberInput3, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+      /* @__PURE__ */ jsx10(NumberInput2, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
     ] })
   ] }) });
 }
@@ -485,28 +347,28 @@ var position_const_node_default = PositionConstNode;
 
 // src/nodes/generators/position-grid-node.tsx
 import { NodeContainer as NodeContainer11 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect6, useState as useState4 } from "react";
-import { Group as Group4, NumberInput as NumberInput4, Stack as Stack4 } from "@mantine/core";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData11, useUpdateNodeData as useUpdateNodeData4 } from "@awesome-flow/core/hooks";
-import { jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
+import { useEffect as useEffect5, useState as useState3 } from "react";
+import { Group as Group3, NumberInput as NumberInput3, Stack as Stack3 } from "@mantine/core";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData11, useUpdateNodeData as useUpdateNodeData3 } from "@awesome-flow/core/hooks";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
 function PositionGridNode({ id, selected, data, type }) {
-  const [x, setX] = useState4(data.center?.x);
-  const [y, setY] = useState4(data.center?.y);
-  const [z, setZ] = useState4(data.center?.z);
-  const [radius, setRadius] = useState4(data.radius);
-  const updateNodeData = useUpdateNodeData4();
+  const [x, setX] = useState3(data.center?.x);
+  const [y, setY] = useState3(data.center?.y);
+  const [z, setZ] = useState3(data.center?.z);
+  const [radius, setRadius] = useState3(data.radius);
+  const updateNodeData = useUpdateNodeData3();
   const updateComputedData = useUpdateNodeComputedData11();
-  useEffect6(() => {
+  useEffect5(() => {
     updateNodeData(id, {
       center: { x, y, z }
     });
   }, [x, y, z]);
-  useEffect6(() => {
+  useEffect5(() => {
     updateNodeData(id, {
       radius
     });
   }, [radius]);
-  useEffect6(() => {
+  useEffect5(() => {
     const positions = [];
     for (let i = -radius; i < radius; i++) {
       for (let j = -radius; j < radius; j++) {
@@ -517,143 +379,36 @@ function PositionGridNode({ id, selected, data, type }) {
       positions
     });
   }, [x, y, z, radius]);
-  return /* @__PURE__ */ jsx14(NodeContainer11, { id, selected, data, type, children: /* @__PURE__ */ jsxs10(Stack4, { children: [
-    /* @__PURE__ */ jsxs10(Group4, { children: [
+  return /* @__PURE__ */ jsx11(NodeContainer11, { id, selected, data, type, children: /* @__PURE__ */ jsxs9(Stack3, { children: [
+    /* @__PURE__ */ jsxs9(Group3, { children: [
       "x: ",
-      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+      /* @__PURE__ */ jsx11(NumberInput3, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs10(Group4, { children: [
+    /* @__PURE__ */ jsxs9(Group3, { children: [
       "y: ",
-      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+      /* @__PURE__ */ jsx11(NumberInput3, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs10(Group4, { children: [
+    /* @__PURE__ */ jsxs9(Group3, { children: [
       "z: ",
-      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+      /* @__PURE__ */ jsx11(NumberInput3, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs10(Group4, { children: [
+    /* @__PURE__ */ jsxs9(Group3, { children: [
       "r: ",
-      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: radius, onChange: (e) => setRadius(Number(e)) })
+      /* @__PURE__ */ jsx11(NumberInput3, { size: "xs", w: 100, value: radius, onChange: (e) => setRadius(Number(e)) })
     ] })
   ] }) });
 }
 var position_grid_node_default = PositionGridNode;
 
-// src/nodes/generators/variable-property-node.tsx
-import { NodeCombobox, NodeContainer as NodeContainer12, NodeTrackConnections as NodeTrackConnections7 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback8, useEffect as useEffect7, useState as useState5 } from "react";
-import { Stack as Stack5 } from "@mantine/core";
-import { useIncomingNodeData as useIncomingNodeData2, useOutgoingNodes, useUpdateNodeData as useUpdateNodeData5 } from "@awesome-flow/core/hooks";
-import { getObjectPropertyMap } from "@awesome-flow/core/utils";
-import { nodeDataPropertyExcept as nodeDataPropertyExcept3 } from "@awesome-flow/core/abstract";
-import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
-function VariablePropertyNode({
-  id,
-  selected,
-  data,
-  type
-}) {
-  const [options3, setOptions] = useState5({});
-  const [selectedProperty, setSelectedProperty] = useState5(data.property);
-  const updateNodeData = useUpdateNodeData5();
-  const outgoing = useOutgoingNodes(id);
-  const incoming = useIncomingNodeData2(id);
-  useEffect7(() => {
-    if (outgoing?.length) {
-      const { data: data2 } = outgoing[0];
-      const properties = getObjectPropertyMap(data2, nodeDataPropertyExcept3);
-      setOptions(properties);
-      if (!selectedProperty) {
-        const keys = Object.keys(properties);
-        if (keys.length) {
-          setSelectedProperty({
-            name: keys[0],
-            value: properties[keys[0]]
-          });
-        }
-      }
-    } else {
-      setSelectedProperty(null);
-    }
-  }, [outgoing]);
-  useEffect7(() => {
-    if (!incoming?.length && selectedProperty?.disabled) {
-      setSelectedProperty({ ...selectedProperty, disabled: false });
-    } else if (incoming?.length && selectedProperty) {
-      const incomingValue = incoming[0].value;
-      if (incomingValue !== void 0 && incomingValue !== null) {
-        setSelectedProperty({
-          name: selectedProperty.name,
-          value: incomingValue,
-          disabled: true
-        });
-      }
-    }
-  }, [incoming]);
-  useEffect7(() => {
-    if (selectedProperty) {
-      updateNodeData(id, { property: selectedProperty });
-    }
-  }, [selectedProperty]);
-  const onPropertyChange = useCallback8(
-    (selected2) => {
-      setSelectedProperty({
-        name: selected2,
-        value: options3[selected2]
-      });
-    },
-    [options3]
-  );
-  const onValueChange = useCallback8((name, value) => {
-    setSelectedProperty({
-      name,
-      value
-    });
-  }, []);
-  return /* @__PURE__ */ jsxs11(NodeContainer12, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs11(Stack5, { align: "center", children: [
-      /* @__PURE__ */ jsx15(
-        NodeCombobox,
-        {
-          options: options3,
-          onChange: onPropertyChange,
-          selected: selectedProperty?.name,
-          hideListValues: true
-        }
-      ),
-      /* @__PURE__ */ jsx15(node_property_input_default, { property: selectedProperty, onChange: onValueChange })
-    ] }),
-    /* @__PURE__ */ jsx15(NodeTrackConnections7, { handles: data.handles, nodeId: id })
-  ] });
-}
-var variable_property_node_default = VariablePropertyNode;
-
-// src/nodes/generators/variable-value-node.tsx
-import { NodeContainer as NodeContainer13, NodeTrackConnections as NodeTrackConnections8 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback9, useState as useState6 } from "react";
-import { useUpdateNodeData as useUpdateNodeData6 } from "@awesome-flow/core/hooks";
-import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
-function VariableValueNode({ id, selected, data, type }) {
-  const [value, setValue] = useState6(data.value || 0);
-  const updateNodeData = useUpdateNodeData6();
-  const onValueChange = useCallback9((newValue) => {
-    updateNodeData(id, { value: newValue });
-    setValue(newValue);
-  }, []);
-  return /* @__PURE__ */ jsxs12(NodeContainer13, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx16(node_value_input_default, { value, onChange: onValueChange }),
-    /* @__PURE__ */ jsx16(NodeTrackConnections8, { handles: data.handles, nodeId: id, type: "source" })
-  ] });
-}
-var variable_value_node_default = VariableValueNode;
-
-// src/nodes/groups/node-module-group.tsx
-import { NodeContainer as NodeContainer14, NodeCollapse } from "@awesome-flow/core/layout";
+// src/nodes/groups/module-group-node.tsx
+import { NodeContainer as NodeContainer12, NodeCollapse, NodeTrackConnections as NodeTrackConnections7 } from "@awesome-flow/core/layout";
 import { NodeResizer, useStore, useUpdateNodeInternals } from "@xyflow/react";
 import { FlowContext } from "@awesome-flow/core/abstract";
-import { useCallback as useCallback10, useContext, useEffect as useEffect8, useMemo as useMemo10 } from "react";
+import { useCallback as useCallback7, useContext, useEffect as useEffect6, useMemo as useMemo9 } from "react";
 import { shallow } from "zustand/shallow";
-import { Badge, Group as Group5 } from "@mantine/core";
-import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
+import { Badge, Group as Group4 } from "@mantine/core";
+import { useIncomingComputedData, useUpdateNodeComputedData as useUpdateNodeComputedData12 } from "@awesome-flow/core/hooks";
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
 function ModuleGroupNode({
   id,
   selected,
@@ -666,19 +421,19 @@ function ModuleGroupNode({
   const updateNodeInternals = useUpdateNodeInternals();
   const triggerNodeChanges = useStore((s) => s.triggerNodeChanges);
   const { groupNodes, setGroupCollapsed } = context.useFlowStore(
-    useCallback10(
+    useCallback7(
       (state) => ({ groupNodes: state.groups[id], setGroupCollapsed: state.setGroupCollapsed }),
       []
     )
   );
   const intersectingNode = context.useInteractivityStore(
-    useCallback10((state) => state.nodeIntersectionTargets[id], [id]),
+    useCallback7((state) => state.nodeIntersectionTargets[id], [id]),
     shallow
   );
-  useEffect8(() => {
+  useEffect6(() => {
     updateNodeInternals(id);
   }, [width, height]);
-  useEffect8(() => {
+  useEffect6(() => {
     triggerNodeChanges([
       {
         id,
@@ -687,87 +442,98 @@ function ModuleGroupNode({
       }
     ]);
   }, [intersectingNode]);
-  const onCollapsed = useCallback10((collapsed) => {
+  const onCollapsed = useCallback7((collapsed) => {
     setGroupCollapsed(id, collapsed);
   }, []);
-  const size = useMemo10(() => {
+  const size = useMemo9(() => {
     return {
       width: data.initialSize?.width || 100,
       height: data.initialSize?.height || 50
     };
   }, [data.initialSize]);
-  return /* @__PURE__ */ jsx17(
-    NodeContainer14,
+  const incomingModules = useIncomingComputedData(id);
+  const updateComputedData = useUpdateNodeComputedData12();
+  useEffect6(() => {
+    if (incomingModules?.length) {
+      const { module } = incomingModules[0];
+      updateComputedData(id, { module });
+    }
+  }, [incomingModules]);
+  return /* @__PURE__ */ jsxs10(
+    NodeContainer12,
     {
       id,
       selected,
       data,
-      title: /* @__PURE__ */ jsx17(Group5, { justify: "space-between", children: /* @__PURE__ */ jsxs13(Group5, { gap: "xs", children: [
-        /* @__PURE__ */ jsx17(Badge, { size: "xs", variant: "outline", radius: "xs", color: "gray", children: groupNodes?.length || 0 }),
-        /* @__PURE__ */ jsx17(NodeCollapse, { nodeId: id, isCollapsed: data.isCollapsed, onCollapsed })
+      title: /* @__PURE__ */ jsx12(Group4, { justify: "space-between", children: /* @__PURE__ */ jsxs10(Group4, { gap: "xs", children: [
+        /* @__PURE__ */ jsx12(Badge, { size: "xs", variant: "outline", radius: "xs", color: "gray", children: groupNodes?.length || 0 }),
+        /* @__PURE__ */ jsx12(NodeCollapse, { nodeId: id, isCollapsed: data.isCollapsed, onCollapsed })
       ] }) }),
       type,
-      children: /* @__PURE__ */ jsx17(
-        NodeResizer,
-        {
-          nodeId: id,
-          minWidth: size.width,
-          minHeight: size.height,
-          isVisible: selected && !data.isCollapsed
-        }
-      )
+      children: [
+        /* @__PURE__ */ jsx12(
+          NodeResizer,
+          {
+            nodeId: id,
+            minWidth: size.width,
+            minHeight: size.height,
+            isVisible: selected && !data.isCollapsed
+          }
+        ),
+        /* @__PURE__ */ jsx12(NodeTrackConnections7, { handles: data.handles, nodeId: id, type: "target" })
+      ]
     }
   );
 }
-var node_module_group_default = ModuleGroupNode;
+var module_group_node_default = ModuleGroupNode;
 
 // src/nodes/modifiers/noise-abs-node.tsx
-import { NodeContainer as NodeContainer15, NodeTrackConnections as NodeTrackConnections9 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect9 } from "react";
-import { useIncomingComputedData, useUpdateNodeComputedData as useUpdateNodeComputedData12 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer13, NodeTrackConnections as NodeTrackConnections8 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect7 } from "react";
+import { useIncomingComputedData as useIncomingComputedData2, useUpdateNodeComputedData as useUpdateNodeComputedData13 } from "@awesome-flow/core/hooks";
 import { Abs } from "libnoise-ts/module/modifier";
-import { jsx as jsx18 } from "react/jsx-runtime";
+import { jsx as jsx13 } from "react/jsx-runtime";
 function NoiseAbsNode({ id, selected, data, type }) {
-  const incoming = useIncomingComputedData(id);
-  const updateComputedData = useUpdateNodeComputedData12();
-  useEffect9(() => {
+  const incoming = useIncomingComputedData2(id);
+  const updateComputedData = useUpdateNodeComputedData13();
+  useEffect7(() => {
     if (incoming?.length > 0) {
       const module = new Abs(incoming[0].module);
       updateComputedData(id, { module });
     }
   }, [incoming]);
-  return /* @__PURE__ */ jsx18(NodeContainer15, { id, selected, data, type, children: /* @__PURE__ */ jsx18(NodeTrackConnections9, { handles: data.handles, nodeId: id, type: "target" }) });
+  return /* @__PURE__ */ jsx13(NodeContainer13, { id, selected, data, type, children: /* @__PURE__ */ jsx13(NodeTrackConnections8, { handles: data.handles, nodeId: id, type: "target" }) });
 }
 var noise_abs_node_default = NoiseAbsNode;
 
 // src/nodes/modifiers/noise-clamp-node.tsx
-import { NodeContainer as NodeContainer16, NodeTrackConnections as NodeTrackConnections10 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect10, useState as useState7 } from "react";
-import { Group as Group6, NumberInput as NumberInput5, Stack as Stack6 } from "@mantine/core";
+import { NodeContainer as NodeContainer14, NodeTrackConnections as NodeTrackConnections9 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect8, useState as useState4 } from "react";
+import { Group as Group5, NumberInput as NumberInput4, Stack as Stack4 } from "@mantine/core";
 import {
-  useIncomingComputedData as useIncomingComputedData2,
-  useUpdateNodeComputedData as useUpdateNodeComputedData13,
-  useUpdateNodeData as useUpdateNodeData7
+  useIncomingComputedData as useIncomingComputedData3,
+  useUpdateNodeComputedData as useUpdateNodeComputedData14,
+  useUpdateNodeData as useUpdateNodeData4
 } from "@awesome-flow/core/hooks";
 import { Clamp } from "libnoise-ts/module/modifier";
-import { jsx as jsx19, jsxs as jsxs14 } from "react/jsx-runtime";
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
 function NoiseClampNode({ id, selected, data, type }) {
-  const [lowerBound, setLowerBound] = useState7(data.lowerBound);
-  const [upperBound, setUpperBound] = useState7(data.upperBound);
-  const incoming = useIncomingComputedData2(id);
-  const updateNodeData = useUpdateNodeData7();
-  const updateComputedData = useUpdateNodeComputedData13();
-  useEffect10(() => {
+  const [lowerBound, setLowerBound] = useState4(data.lowerBound);
+  const [upperBound, setUpperBound] = useState4(data.upperBound);
+  const incoming = useIncomingComputedData3(id);
+  const updateNodeData = useUpdateNodeData4();
+  const updateComputedData = useUpdateNodeComputedData14();
+  useEffect8(() => {
     if (incoming?.length) {
       const module = new Clamp(incoming[0].module, lowerBound, upperBound);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { lowerBound, upperBound });
   }, [incoming, lowerBound, upperBound]);
-  return /* @__PURE__ */ jsxs14(NodeContainer16, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx19(Stack6, { children: /* @__PURE__ */ jsxs14(Group6, { children: [
-      /* @__PURE__ */ jsx19(
-        NumberInput5,
+  return /* @__PURE__ */ jsxs11(NodeContainer14, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx14(Stack4, { children: /* @__PURE__ */ jsxs11(Group5, { children: [
+      /* @__PURE__ */ jsx14(
+        NumberInput4,
         {
           size: "xs",
           w: 100,
@@ -776,8 +542,8 @@ function NoiseClampNode({ id, selected, data, type }) {
           step: 0.1
         }
       ),
-      /* @__PURE__ */ jsx19(
-        NumberInput5,
+      /* @__PURE__ */ jsx14(
+        NumberInput4,
         {
           size: "xs",
           w: 100,
@@ -787,18 +553,18 @@ function NoiseClampNode({ id, selected, data, type }) {
         }
       )
     ] }) }),
-    /* @__PURE__ */ jsx19(NodeTrackConnections10, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx14(NodeTrackConnections9, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_clamp_node_default = NoiseClampNode;
 
 // src/nodes/modifiers/noise-combine-node.tsx
-import { NodeCombobox as NodeCombobox2, NodeContainer as NodeContainer17, NodeTrackConnections as NodeTrackConnections11 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback11, useEffect as useEffect11 } from "react";
+import { NodeCombobox, NodeContainer as NodeContainer15, NodeTrackConnections as NodeTrackConnections10 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback8, useEffect as useEffect9 } from "react";
 import {
-  useIncomingComputedData as useIncomingComputedData3,
-  useUpdateNodeComputedData as useUpdateNodeComputedData14,
-  useUpdateNodeData as useUpdateNodeData8
+  useIncomingComputedData as useIncomingComputedData4,
+  useUpdateNodeComputedData as useUpdateNodeComputedData15,
+  useUpdateNodeData as useUpdateNodeData5
 } from "@awesome-flow/core/hooks";
 import {
   IconAsterisk,
@@ -819,49 +585,49 @@ var noiseCombineModuleMap = {
 };
 
 // src/nodes/modifiers/noise-combine-node.tsx
-import { jsx as jsx20, jsxs as jsxs15 } from "react/jsx-runtime";
+import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
 var options = {
-  add: /* @__PURE__ */ jsx20(IconPlus, {}),
-  min: /* @__PURE__ */ jsx20(IconChevronLeft, {}),
-  max: /* @__PURE__ */ jsx20(IconChevronRight, {}),
-  multiply: /* @__PURE__ */ jsx20(IconAsterisk, {}),
-  power: /* @__PURE__ */ jsx20(IconChevronUp, {})
+  add: /* @__PURE__ */ jsx15(IconPlus, {}),
+  min: /* @__PURE__ */ jsx15(IconChevronLeft, {}),
+  max: /* @__PURE__ */ jsx15(IconChevronRight, {}),
+  multiply: /* @__PURE__ */ jsx15(IconAsterisk, {}),
+  power: /* @__PURE__ */ jsx15(IconChevronUp, {})
 };
 function NoiseCombineNode({ id, selected, data, type }) {
-  const updateNodeData = useUpdateNodeData8();
-  const updateComputedData = useUpdateNodeComputedData14();
-  const incoming = useIncomingComputedData3(id);
-  useEffect11(() => {
+  const updateNodeData = useUpdateNodeData5();
+  const updateComputedData = useUpdateNodeComputedData15();
+  const incoming = useIncomingComputedData4(id);
+  useEffect9(() => {
     const ModuleFactory = noiseCombineModuleMap[data.operation];
     if (incoming?.length > 1) {
       const module = new ModuleFactory(incoming[0].module, incoming[1].module);
       updateComputedData(id, { module });
     }
   }, [data.operation, incoming]);
-  const onChange = useCallback11((operation) => {
+  const onChange = useCallback8((operation) => {
     updateNodeData(id, { operation });
   }, []);
-  return /* @__PURE__ */ jsxs15(NodeContainer17, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx20(NodeCombobox2, { options, selected: data.operation, onChange }),
-    /* @__PURE__ */ jsx20(NodeTrackConnections11, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs12(NodeContainer15, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx15(NodeCombobox, { options, selected: data.operation, onChange, width: 150 }),
+    /* @__PURE__ */ jsx15(NodeTrackConnections10, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_combine_node_default = NoiseCombineNode;
 
 // src/nodes/modifiers/noise-curve-node.tsx
-import { NodeContainer as NodeContainer18, NodeTrackConnections as NodeTrackConnections12 } from "@awesome-flow/core/layout";
-import { ActionIcon, Button, Group as Group7, NumberInput as NumberInput6, Space } from "@mantine/core";
+import { NodeContainer as NodeContainer16, NodeTrackConnections as NodeTrackConnections11 } from "@awesome-flow/core/layout";
+import { ActionIcon, Button, Group as Group6, NumberInput as NumberInput5, Space } from "@mantine/core";
 import {
-  useIncomingComputedData as useIncomingComputedData4,
-  useUpdateNodeComputedData as useUpdateNodeComputedData15,
-  useUpdateNodeData as useUpdateNodeData9
+  useIncomingComputedData as useIncomingComputedData5,
+  useUpdateNodeComputedData as useUpdateNodeComputedData16,
+  useUpdateNodeData as useUpdateNodeData6
 } from "@awesome-flow/core/hooks";
 
 // ../../node_modules/@mantine/form/esm/use-form.mjs
-import { useState as useState11, useCallback as useCallback17 } from "react";
+import { useState as useState8, useCallback as useCallback14 } from "react";
 
 // ../../node_modules/@mantine/form/esm/actions/actions.mjs
-import { useLayoutEffect, useEffect as useEffect12 } from "react";
+import { useLayoutEffect, useEffect as useEffect10 } from "react";
 function validateFormName(name) {
   if (!/^[0-9a-zA-Z-]+$/.test(name)) {
     throw new Error(
@@ -869,7 +635,7 @@ function validateFormName(name) {
     );
   }
 }
-var useIsomorphicEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect12;
+var useIsomorphicEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect10;
 function useFormEvent(eventKey, handler) {
   useIsomorphicEffect(() => {
     if (eventKey) {
@@ -966,7 +732,7 @@ function getInputOnChange(setValue) {
 }
 
 // ../../node_modules/@mantine/form/esm/hooks/use-form-errors/use-form-errors.mjs
-import { useState as useState8, useCallback as useCallback12 } from "react";
+import { useState as useState5, useCallback as useCallback9 } from "react";
 
 // ../../node_modules/@mantine/form/esm/hooks/use-form-errors/filter-errors/filter-errors.mjs
 function filterErrors(errors) {
@@ -984,14 +750,14 @@ function filterErrors(errors) {
 
 // ../../node_modules/@mantine/form/esm/hooks/use-form-errors/use-form-errors.mjs
 function useFormErrors(initialErrors) {
-  const [errorsState, setErrorsState] = useState8(filterErrors(initialErrors));
-  const setErrors = useCallback12((errors) => {
+  const [errorsState, setErrorsState] = useState5(filterErrors(initialErrors));
+  const setErrors = useCallback9((errors) => {
     setErrorsState(
       (current) => filterErrors(typeof errors === "function" ? errors(current) : errors)
     );
   }, []);
-  const clearErrors = useCallback12(() => setErrorsState({}), []);
-  const clearFieldError = useCallback12(
+  const clearErrors = useCallback9(() => setErrorsState({}), []);
+  const clearFieldError = useCallback9(
     (path) => {
       if (errorsState[path] === void 0) {
         return;
@@ -1004,7 +770,7 @@ function useFormErrors(initialErrors) {
     },
     [errorsState]
   );
-  const setFieldError = useCallback12(
+  const setFieldError = useCallback9(
     (path, error) => {
       if (error == null || error === false) {
         clearFieldError(path);
@@ -1024,7 +790,7 @@ function useFormErrors(initialErrors) {
 }
 
 // ../../node_modules/@mantine/form/esm/hooks/use-form-list/use-form-list.mjs
-import { useCallback as useCallback13 } from "react";
+import { useCallback as useCallback10 } from "react";
 
 // ../../node_modules/@mantine/form/esm/lists/clear-list-state.mjs
 function clearListState(field, state) {
@@ -1248,7 +1014,7 @@ function useFormList({
   $errors,
   $status
 }) {
-  const reorderListItem = useCallback13((path, payload) => {
+  const reorderListItem = useCallback10((path, payload) => {
     $status.clearFieldDirty(path);
     $errors.setErrors((errs) => reorderErrors(path, payload, errs));
     $values.setValues({
@@ -1256,7 +1022,7 @@ function useFormList({
       updateState: true
     });
   }, []);
-  const removeListItem = useCallback13((path, index) => {
+  const removeListItem = useCallback10((path, index) => {
     $status.clearFieldDirty(path);
     $errors.setErrors((errs) => changeErrorIndices(path, index, errs, -1));
     $values.setValues({
@@ -1264,7 +1030,7 @@ function useFormList({
       updateState: true
     });
   }, []);
-  const insertListItem = useCallback13((path, item, index) => {
+  const insertListItem = useCallback10((path, item, index) => {
     $status.clearFieldDirty(path);
     $errors.setErrors((errs) => changeErrorIndices(path, index, errs, 1));
     $values.setValues({
@@ -1277,7 +1043,7 @@ function useFormList({
 
 // ../../node_modules/@mantine/form/esm/hooks/use-form-status/use-form-status.mjs
 var import_fast_deep_equal = __toESM(require_fast_deep_equal(), 1);
-import { useState as useState9, useRef, useCallback as useCallback14 } from "react";
+import { useState as useState6, useRef, useCallback as useCallback11 } from "react";
 
 // ../../node_modules/@mantine/form/esm/get-status/get-status.mjs
 function getStatus(status, path) {
@@ -1296,31 +1062,31 @@ function useFormStatus({
   mode,
   $values
 }) {
-  const [touchedState, setTouchedState] = useState9(initialTouched);
-  const [dirtyState, setDirtyState] = useState9(initialDirty);
+  const [touchedState, setTouchedState] = useState6(initialTouched);
+  const [dirtyState, setDirtyState] = useState6(initialDirty);
   const touchedRef = useRef(initialTouched);
   const dirtyRef = useRef(initialDirty);
-  const setTouched = useCallback14((values) => {
+  const setTouched = useCallback11((values) => {
     const resolvedValues = typeof values === "function" ? values(touchedRef.current) : values;
     touchedRef.current = resolvedValues;
     if (mode === "controlled") {
       setTouchedState(resolvedValues);
     }
   }, []);
-  const setDirty = useCallback14((values) => {
+  const setDirty = useCallback11((values) => {
     const resolvedValues = typeof values === "function" ? values(dirtyRef.current) : values;
     dirtyRef.current = resolvedValues;
     if (mode === "controlled") {
       setDirtyState(resolvedValues);
     }
   }, []);
-  const resetTouched = useCallback14(() => setTouched({}), []);
+  const resetTouched = useCallback11(() => setTouched({}), []);
   const resetDirty = (values) => {
     const newSnapshot = values ? { ...values, ...$values.refValues.current } : $values.refValues.current;
     $values.setValuesSnapshot(newSnapshot);
     setDirty({});
   };
-  const setFieldTouched = useCallback14((path, touched) => {
+  const setFieldTouched = useCallback11((path, touched) => {
     setTouched((currentTouched) => {
       if (getStatus(currentTouched, path) === touched) {
         return currentTouched;
@@ -1328,7 +1094,7 @@ function useFormStatus({
       return { ...currentTouched, [path]: touched };
     });
   }, []);
-  const setFieldDirty = useCallback14((path, dirty) => {
+  const setFieldDirty = useCallback11((path, dirty) => {
     setDirty((currentDirty) => {
       if (getStatus(currentDirty, path) === dirty) {
         return currentDirty;
@@ -1336,11 +1102,11 @@ function useFormStatus({
       return { ...currentDirty, [path]: dirty };
     });
   }, []);
-  const isTouched = useCallback14(
+  const isTouched = useCallback11(
     (path) => getStatus(touchedRef.current, path),
     []
   );
-  const clearFieldDirty = useCallback14(
+  const clearFieldDirty = useCallback11(
     (path) => setDirty((current) => {
       if (typeof path !== "string") {
         return current;
@@ -1354,7 +1120,7 @@ function useFormStatus({
     }),
     []
   );
-  const isDirty = useCallback14((path) => {
+  const isDirty = useCallback11((path) => {
     if (path) {
       const overriddenValue = getPath(path, dirtyRef.current);
       if (typeof overriddenValue === "boolean") {
@@ -1370,8 +1136,8 @@ function useFormStatus({
     }
     return !(0, import_fast_deep_equal.default)($values.refValues.current, $values.valuesSnapshot.current);
   }, []);
-  const getDirty = useCallback14(() => dirtyRef.current, []);
-  const getTouched = useCallback14(() => touchedRef.current, []);
+  const getDirty = useCallback11(() => dirtyRef.current, []);
+  const getTouched = useCallback11(() => touchedRef.current, []);
   return {
     touchedState,
     dirtyState,
@@ -1394,17 +1160,17 @@ function useFormStatus({
 }
 
 // ../../node_modules/@mantine/form/esm/hooks/use-form-values/use-form-values.mjs
-import { useRef as useRef2, useState as useState10, useCallback as useCallback15 } from "react";
+import { useRef as useRef2, useState as useState7, useCallback as useCallback12 } from "react";
 function useFormValues({
   initialValues,
   onValuesChange,
   mode
 }) {
   const initialized = useRef2(false);
-  const [stateValues, setStateValues] = useState10(initialValues || {});
+  const [stateValues, setStateValues] = useState7(initialValues || {});
   const refValues = useRef2(stateValues);
   const valuesSnapshot = useRef2(stateValues);
-  const setValues = useCallback15(
+  const setValues = useCallback12(
     ({
       values,
       subscribers,
@@ -1421,7 +1187,7 @@ function useFormValues({
     },
     [onValuesChange]
   );
-  const setFieldValue = useCallback15((payload) => {
+  const setFieldValue = useCallback12((payload) => {
     const currentValue = getPath(payload.path, refValues.current);
     const updatedValue = payload.value instanceof Function ? payload.value(currentValue) : payload.value;
     if (currentValue !== updatedValue) {
@@ -1433,10 +1199,10 @@ function useFormValues({
       );
     }
   }, []);
-  const setValuesSnapshot = useCallback15((payload) => {
+  const setValuesSnapshot = useCallback12((payload) => {
     valuesSnapshot.current = payload;
   }, []);
-  const initialize = useCallback15((values, onInitialize) => {
+  const initialize = useCallback12((values, onInitialize) => {
     if (!initialized.current) {
       initialized.current = true;
       setValues({ values, updateState: mode === "controlled" });
@@ -1444,14 +1210,14 @@ function useFormValues({
       onInitialize();
     }
   }, []);
-  const resetValues = useCallback15(() => {
+  const resetValues = useCallback12(() => {
     setValues({
       values: valuesSnapshot.current,
       updateState: true,
       mergeWithPreviousValues: false
     });
   }, []);
-  const getValues = useCallback15(() => refValues.current, []);
+  const getValues = useCallback12(() => refValues.current, []);
   return {
     initialized,
     stateValues,
@@ -1467,15 +1233,15 @@ function useFormValues({
 }
 
 // ../../node_modules/@mantine/form/esm/hooks/use-form-watch/use-form-watch.mjs
-import { useRef as useRef3, useCallback as useCallback16, useEffect as useEffect13 } from "react";
+import { useRef as useRef3, useCallback as useCallback13, useEffect as useEffect11 } from "react";
 function useFormWatch({
   $status
 }) {
   const subscribers = useRef3(
     {}
   );
-  const watch = useCallback16((path, callback) => {
-    useEffect13(() => {
+  const watch = useCallback13((path, callback) => {
+    useEffect11(() => {
       subscribers.current[path] = subscribers.current[path] || [];
       subscribers.current[path].push(callback);
       return () => {
@@ -1483,7 +1249,7 @@ function useFormWatch({
       };
     }, [callback]);
   }, []);
-  const getFieldSubscribers = useCallback16((path) => {
+  const getFieldSubscribers = useCallback13((path) => {
     if (!subscribers.current[path]) {
       return [];
     }
@@ -1503,6 +1269,11 @@ function useFormWatch({
   };
 }
 
+// ../../node_modules/@mantine/form/esm/paths/get-data-path.mjs
+function getDataPath(formName, fieldPath) {
+  return formName ? `${formName}-${fieldPath.toString()}` : fieldPath.toString();
+}
+
 // ../../node_modules/@mantine/form/esm/validate/validate-values.mjs
 function getValidationResults(errors) {
   const filteredErrors = filterErrors(errors);
@@ -1591,20 +1362,20 @@ function useForm({
   const $status = useFormStatus({ initialDirty, initialTouched, $values, mode });
   const $list = useFormList({ $values, $errors, $status });
   const $watch = useFormWatch({ $status });
-  const [formKey, setFormKey] = useState11(0);
-  const [fieldKeys, setFieldKeys] = useState11({});
-  const reset = useCallback17(() => {
+  const [formKey, setFormKey] = useState8(0);
+  const [fieldKeys, setFieldKeys] = useState8({});
+  const reset = useCallback14(() => {
     $values.resetValues();
     $errors.clearErrors();
     $status.resetDirty();
     $status.resetTouched();
     mode === "uncontrolled" && setFormKey((key2) => key2 + 1);
   }, []);
-  const initialize = useCallback17((values) => {
+  const initialize = useCallback14((values) => {
     $values.initialize(values, () => mode === "uncontrolled" && setFormKey((key2) => key2 + 1));
   }, []);
-  const setFieldValue = useCallback17(
-    (path, value, options3) => {
+  const setFieldValue = useCallback14(
+    (path, value, options2) => {
       const shouldValidate = shouldValidateOnChange(path, validateInputOnChange);
       $status.clearFieldDirty(path);
       $status.setFieldTouched(path, true);
@@ -1619,7 +1390,7 @@ function useForm({
             const validationResults = validateFieldValue(path, rules, payload.updatedValues);
             validationResults.hasError ? $errors.setFieldError(path, validationResults.error) : $errors.clearFieldError(path);
           } : null,
-          options3?.forceUpdate !== false && mode !== "controlled" ? () => setFieldKeys((keys) => ({
+          options2?.forceUpdate !== false && mode !== "controlled" ? () => setFieldKeys((keys) => ({
             ...keys,
             [path]: (keys[path] || 0) + 1
           })) : null
@@ -1628,7 +1399,7 @@ function useForm({
     },
     [onValuesChange, rules]
   );
-  const setValues = useCallback17(
+  const setValues = useCallback14(
     (values) => {
       const previousValues = $values.refValues.current;
       $values.setValues({ values, updateState: mode === "controlled" });
@@ -1644,12 +1415,12 @@ function useForm({
     },
     [onValuesChange, clearInputErrorOnChange]
   );
-  const validate = useCallback17(() => {
+  const validate = useCallback14(() => {
     const results = validateValues(rules, $values.refValues.current);
     $errors.setErrors(results.errors);
     return results;
   }, [rules]);
-  const validateField = useCallback17(
+  const validateField = useCallback14(
     (path) => {
       const results = validateFieldValue(path, rules, $values.refValues.current);
       results.hasError ? $errors.setFieldError(path, results.error) : $errors.clearFieldError(path);
@@ -1661,7 +1432,7 @@ function useForm({
     const onChange = getInputOnChange(
       (value) => setFieldValue(path, value, { forceUpdate: false })
     );
-    const payload = { onChange };
+    const payload = { onChange, "data-path": getDataPath(name, path) };
     if (withError) {
       payload.error = $errors.errorsState[path];
     }
@@ -1705,15 +1476,19 @@ function useForm({
     }
   };
   const getTransformedValues = (input) => transformValues(input || $values.refValues.current);
-  const onReset = useCallback17((event) => {
+  const onReset = useCallback14((event) => {
     event.preventDefault();
     reset();
   }, []);
-  const isValid = useCallback17(
+  const isValid = useCallback14(
     (path) => path ? !validateFieldValue(path, rules, $values.refValues.current).hasError : !validateValues(rules, $values.refValues.current).hasErrors,
     [rules]
   );
   const key = (path) => `${formKey}-${path}-${fieldKeys[path] || 0}`;
+  const getInputNode = useCallback14(
+    (path) => document.querySelector(`[data-path="${getDataPath(name, path)}"]`),
+    []
+  );
   const form = {
     watch: $watch.watch,
     initialized: $values.initialized.current,
@@ -1747,25 +1522,26 @@ function useForm({
     onReset,
     isValid,
     getTransformedValues,
-    key
+    key,
+    getInputNode
   };
   useFormActions(name, form);
   return form;
 }
 
 // src/nodes/modifiers/noise-curve-node.tsx
-import { useCallback as useCallback18, useEffect as useEffect14, useState as useState12 } from "react";
+import { useCallback as useCallback15, useEffect as useEffect12, useState as useState9 } from "react";
 import { Curve } from "libnoise-ts/module/modifier";
 import { Tuple } from "libnoise-ts/util";
 import { IconX } from "@tabler/icons-react";
 import { randomId } from "@mantine/hooks";
 import { NodeState } from "@awesome-flow/core/abstract";
-import { Fragment as Fragment3, jsx as jsx21, jsxs as jsxs16 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
 function NoiseCurveNode({ id, selected, data, type }) {
-  const incoming = useIncomingComputedData4(id);
-  const updateNodeData = useUpdateNodeData9();
-  const updateComputedData = useUpdateNodeComputedData15();
-  const [values, setValues] = useState12([]);
+  const incoming = useIncomingComputedData5(id);
+  const updateNodeData = useUpdateNodeData6();
+  const updateComputedData = useUpdateNodeComputedData16();
+  const [values, setValues] = useState9([]);
   const form = useForm({
     mode: "uncontrolled",
     initialValues: {
@@ -1784,7 +1560,7 @@ function NoiseCurveNode({ id, selected, data, type }) {
         }
       }
     },
-    onValuesChange: useCallback18((values2) => {
+    onValuesChange: useCallback15((values2) => {
       if (form.isValid()) {
         const points = values2.points.map((v) => ({ input: v.input, output: v.output }));
         setValues(points);
@@ -1793,11 +1569,11 @@ function NoiseCurveNode({ id, selected, data, type }) {
       form.validate();
     }, [])
   });
-  useEffect14(() => {
+  useEffect12(() => {
     const points = data.points?.length ? data.points.map((v) => ({ input: v.input, output: v.output, key: randomId() })) : [1, 2, 3, 4].map(() => ({ input: 0, output: 0, key: randomId() }));
     form.initialize({ points });
   }, []);
-  useEffect14(() => {
+  useEffect12(() => {
     if (incoming?.length && values?.length >= 4) {
       const module = new Curve(
         incoming[0].module,
@@ -1806,9 +1582,9 @@ function NoiseCurveNode({ id, selected, data, type }) {
       updateComputedData(id, { module });
     }
   }, [values, incoming]);
-  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ jsxs16(Group7, { mt: "xs", children: [
-    /* @__PURE__ */ jsx21(
-      NumberInput6,
+  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ jsxs13(Group6, { mt: "xs", children: [
+    /* @__PURE__ */ jsx16(
+      NumberInput5,
       {
         size: "xs",
         w: 100,
@@ -1818,8 +1594,8 @@ function NoiseCurveNode({ id, selected, data, type }) {
       },
       form.key(`points.${index}.input`)
     ),
-    /* @__PURE__ */ jsx21(
-      NumberInput6,
+    /* @__PURE__ */ jsx16(
+      NumberInput5,
       {
         size: "xs",
         w: 100,
@@ -1829,22 +1605,22 @@ function NoiseCurveNode({ id, selected, data, type }) {
       },
       form.key(`points.${index}.output`)
     ),
-    data.state === NodeState.edit && values.length > 4 && /* @__PURE__ */ jsx21(
+    data.state === NodeState.edit && values.length > 4 && /* @__PURE__ */ jsx16(
       ActionIcon,
       {
         color: "red",
         variant: "outline",
         size: "sm",
         onClick: () => form.removeListItem("points", index),
-        children: /* @__PURE__ */ jsx21(IconX, { size: "1rem" })
+        children: /* @__PURE__ */ jsx16(IconX, { size: "1rem" })
       }
     )
   ] }, item.key));
-  return /* @__PURE__ */ jsxs16(NodeContainer18, { id, selected, type, data, children: [
+  return /* @__PURE__ */ jsxs13(NodeContainer16, { id, selected, type, data, children: [
     fields,
-    data.state === NodeState.edit && /* @__PURE__ */ jsxs16(Fragment3, { children: [
-      /* @__PURE__ */ jsx21(Space, { h: 10 }),
-      /* @__PURE__ */ jsx21(
+    data.state === NodeState.edit && /* @__PURE__ */ jsxs13(Fragment, { children: [
+      /* @__PURE__ */ jsx16(Space, { h: 10 }),
+      /* @__PURE__ */ jsx16(
         Button,
         {
           variant: "outline",
@@ -1855,39 +1631,39 @@ function NoiseCurveNode({ id, selected, data, type }) {
         }
       )
     ] }),
-    /* @__PURE__ */ jsx21(NodeTrackConnections12, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx16(NodeTrackConnections11, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_curve_node_default = NoiseCurveNode;
 
 // src/nodes/modifiers/noise-exponent-node.tsx
-import { NodeContainer as NodeContainer19, NodeTrackConnections as NodeTrackConnections13 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect15, useState as useState13 } from "react";
-import { Group as Group8, NumberInput as NumberInput7, Stack as Stack7 } from "@mantine/core";
+import { NodeContainer as NodeContainer17, NodeTrackConnections as NodeTrackConnections12 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect13, useState as useState10 } from "react";
+import { Group as Group7, NumberInput as NumberInput6, Stack as Stack5 } from "@mantine/core";
 import {
-  useIncomingComputedData as useIncomingComputedData5,
-  useUpdateNodeComputedData as useUpdateNodeComputedData16,
-  useUpdateNodeData as useUpdateNodeData10
+  useIncomingComputedData as useIncomingComputedData6,
+  useUpdateNodeComputedData as useUpdateNodeComputedData17,
+  useUpdateNodeData as useUpdateNodeData7
 } from "@awesome-flow/core/hooks";
 import { Exponent } from "libnoise-ts/module/modifier";
-import { jsx as jsx22, jsxs as jsxs17 } from "react/jsx-runtime";
+import { jsx as jsx17, jsxs as jsxs14 } from "react/jsx-runtime";
 function NoiseExponentNode({ id, selected, data, type }) {
-  const [exponent, setExponent] = useState13(data.exponent);
-  const incoming = useIncomingComputedData5(id);
-  const updateNodeData = useUpdateNodeData10();
-  const updateComputedData = useUpdateNodeComputedData16();
-  useEffect15(() => {
+  const [exponent, setExponent] = useState10(data.exponent);
+  const incoming = useIncomingComputedData6(id);
+  const updateNodeData = useUpdateNodeData7();
+  const updateComputedData = useUpdateNodeComputedData17();
+  useEffect13(() => {
     if (incoming?.length > 0) {
       const module = new Exponent(incoming[0].module, exponent);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { exponent });
   }, [incoming, exponent]);
-  return /* @__PURE__ */ jsxs17(NodeContainer19, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx22(Stack7, { children: /* @__PURE__ */ jsxs17(Group8, { children: [
+  return /* @__PURE__ */ jsxs14(NodeContainer17, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx17(Stack5, { children: /* @__PURE__ */ jsxs14(Group7, { children: [
       "Exponent:",
-      /* @__PURE__ */ jsx22(
-        NumberInput7,
+      /* @__PURE__ */ jsx17(
+        NumberInput6,
         {
           size: "xs",
           value: exponent,
@@ -1896,38 +1672,38 @@ function NoiseExponentNode({ id, selected, data, type }) {
         }
       )
     ] }) }),
-    /* @__PURE__ */ jsx22(NodeTrackConnections13, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx17(NodeTrackConnections12, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_exponent_node_default = NoiseExponentNode;
 
 // src/nodes/modifiers/noise-invert-node.tsx
-import { NodeContainer as NodeContainer20, NodeTrackConnections as NodeTrackConnections14 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect16 } from "react";
-import { useIncomingComputedData as useIncomingComputedData6, useUpdateNodeComputedData as useUpdateNodeComputedData17 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer18, NodeTrackConnections as NodeTrackConnections13 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect14 } from "react";
+import { useIncomingComputedData as useIncomingComputedData7, useUpdateNodeComputedData as useUpdateNodeComputedData18 } from "@awesome-flow/core/hooks";
 import { Invert } from "libnoise-ts/module/modifier";
-import { jsx as jsx23 } from "react/jsx-runtime";
+import { jsx as jsx18 } from "react/jsx-runtime";
 function NoiseInvertNode({ id, selected, data, type }) {
-  const incoming = useIncomingComputedData6(id);
-  const updateComputedData = useUpdateNodeComputedData17();
-  useEffect16(() => {
+  const incoming = useIncomingComputedData7(id);
+  const updateComputedData = useUpdateNodeComputedData18();
+  useEffect14(() => {
     if (incoming?.length > 0) {
       const module = new Invert(incoming[0].module);
       updateComputedData(id, { module });
     }
   }, [incoming]);
-  return /* @__PURE__ */ jsx23(NodeContainer20, { id, selected, data, type, children: /* @__PURE__ */ jsx23(NodeTrackConnections14, { handles: data.handles, nodeId: id, type: "target" }) });
+  return /* @__PURE__ */ jsx18(NodeContainer18, { id, selected, data, type, children: /* @__PURE__ */ jsx18(NodeTrackConnections13, { handles: data.handles, nodeId: id, type: "target" }) });
 }
 var noise_invert_node_default = NoiseInvertNode;
 
 // src/nodes/modifiers/noise-normalize-node.tsx
-import { NodeContainer as NodeContainer21, NodeTrackConnections as NodeTrackConnections15 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect17, useState as useState14 } from "react";
-import { Group as Group9, NumberInput as NumberInput8, Stack as Stack8 } from "@mantine/core";
+import { NodeContainer as NodeContainer19, NodeTrackConnections as NodeTrackConnections14 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect15, useState as useState11 } from "react";
+import { Group as Group8, NumberInput as NumberInput7, Stack as Stack6 } from "@mantine/core";
 import {
-  useIncomingComputedData as useIncomingComputedData7,
-  useUpdateNodeComputedData as useUpdateNodeComputedData18,
-  useUpdateNodeData as useUpdateNodeData11
+  useIncomingComputedData as useIncomingComputedData8,
+  useUpdateNodeComputedData as useUpdateNodeComputedData19,
+  useUpdateNodeData as useUpdateNodeData8
 } from "@awesome-flow/core/hooks";
 
 // src/modules/normalize-noise-module.ts
@@ -1947,14 +1723,14 @@ function normalize(value, min, max) {
 }
 
 // src/nodes/modifiers/noise-normalize-node.tsx
-import { jsx as jsx24, jsxs as jsxs18 } from "react/jsx-runtime";
+import { jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
 function NoiseNormalizeNode({ id, selected, data, type }) {
-  const [intervalStart, setIntervalStart] = useState14(data.intervalStart);
-  const [intervalEnd, setIntervalEnd] = useState14(data.intervalEnd);
-  const incoming = useIncomingComputedData7(id);
-  const updateNodeData = useUpdateNodeData11();
-  const updateComputedData = useUpdateNodeComputedData18();
-  useEffect17(() => {
+  const [intervalStart, setIntervalStart] = useState11(data.intervalStart);
+  const [intervalEnd, setIntervalEnd] = useState11(data.intervalEnd);
+  const incoming = useIncomingComputedData8(id);
+  const updateNodeData = useUpdateNodeData8();
+  const updateComputedData = useUpdateNodeComputedData19();
+  useEffect15(() => {
     if (incoming?.length) {
       const source = incoming[0].module;
       const module = new NormalizeNoiseModule(source, intervalStart, intervalEnd);
@@ -1962,10 +1738,10 @@ function NoiseNormalizeNode({ id, selected, data, type }) {
     }
     updateNodeData(id, { intervalStart, intervalEnd });
   }, [incoming, intervalStart, intervalEnd]);
-  return /* @__PURE__ */ jsxs18(NodeContainer21, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx24(Stack8, { children: /* @__PURE__ */ jsxs18(Group9, { children: [
-      /* @__PURE__ */ jsx24(
-        NumberInput8,
+  return /* @__PURE__ */ jsxs15(NodeContainer19, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx19(Stack6, { children: /* @__PURE__ */ jsxs15(Group8, { children: [
+      /* @__PURE__ */ jsx19(
+        NumberInput7,
         {
           size: "xs",
           w: 100,
@@ -1973,8 +1749,8 @@ function NoiseNormalizeNode({ id, selected, data, type }) {
           onChange: (e) => setIntervalStart(Number(e))
         }
       ),
-      /* @__PURE__ */ jsx24(
-        NumberInput8,
+      /* @__PURE__ */ jsx19(
+        NumberInput7,
         {
           size: "xs",
           w: 100,
@@ -1983,41 +1759,41 @@ function NoiseNormalizeNode({ id, selected, data, type }) {
         }
       )
     ] }) }),
-    /* @__PURE__ */ jsx24(NodeTrackConnections15, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx19(NodeTrackConnections14, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_normalize_node_default = NoiseNormalizeNode;
 
 // src/nodes/modifiers/noise-scale-bias-node.tsx
-import { NodeContainer as NodeContainer22, NodeTrackConnections as NodeTrackConnections16 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect18, useState as useState15 } from "react";
-import { Group as Group10, NumberInput as NumberInput9, Stack as Stack9 } from "@mantine/core";
+import { NodeContainer as NodeContainer20, NodeTrackConnections as NodeTrackConnections15 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect16, useState as useState12 } from "react";
+import { Group as Group9, NumberInput as NumberInput8, Stack as Stack7 } from "@mantine/core";
 import {
-  useIncomingComputedData as useIncomingComputedData8,
-  useUpdateNodeComputedData as useUpdateNodeComputedData19,
-  useUpdateNodeData as useUpdateNodeData12
+  useIncomingComputedData as useIncomingComputedData9,
+  useUpdateNodeComputedData as useUpdateNodeComputedData20,
+  useUpdateNodeData as useUpdateNodeData9
 } from "@awesome-flow/core/hooks";
 import { ScaleBias } from "libnoise-ts/module/modifier";
-import { jsx as jsx25, jsxs as jsxs19 } from "react/jsx-runtime";
+import { jsx as jsx20, jsxs as jsxs16 } from "react/jsx-runtime";
 function NoiseScaleBiasNode({ id, selected, data, type }) {
-  const [scale, setScale] = useState15(data.scale);
-  const [bias, setBias] = useState15(data.bias);
-  const incoming = useIncomingComputedData8(id);
-  const updateNodeData = useUpdateNodeData12();
-  const updateComputedData = useUpdateNodeComputedData19();
-  useEffect18(() => {
+  const [scale, setScale] = useState12(data.scale);
+  const [bias, setBias] = useState12(data.bias);
+  const incoming = useIncomingComputedData9(id);
+  const updateNodeData = useUpdateNodeData9();
+  const updateComputedData = useUpdateNodeComputedData20();
+  useEffect16(() => {
     if (incoming?.length > 0) {
       const module = new ScaleBias(incoming[0].module, scale, bias);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { scale, bias });
   }, [incoming, scale, bias]);
-  return /* @__PURE__ */ jsxs19(NodeContainer22, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs19(Stack9, { children: [
-      /* @__PURE__ */ jsxs19(Group10, { children: [
+  return /* @__PURE__ */ jsxs16(NodeContainer20, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs16(Stack7, { children: [
+      /* @__PURE__ */ jsxs16(Group9, { children: [
         "Scale:",
-        /* @__PURE__ */ jsx25(
-          NumberInput9,
+        /* @__PURE__ */ jsx20(
+          NumberInput8,
           {
             size: "xs",
             w: 100,
@@ -2027,10 +1803,10 @@ function NoiseScaleBiasNode({ id, selected, data, type }) {
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs19(Group10, { children: [
+      /* @__PURE__ */ jsxs16(Group9, { children: [
         "Bias:",
-        /* @__PURE__ */ jsx25(
-          NumberInput9,
+        /* @__PURE__ */ jsx20(
+          NumberInput8,
           {
             size: "xs",
             w: 100,
@@ -2041,30 +1817,30 @@ function NoiseScaleBiasNode({ id, selected, data, type }) {
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsx25(NodeTrackConnections16, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx20(NodeTrackConnections15, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_scale_bias_node_default = NoiseScaleBiasNode;
 
 // src/nodes/modifiers/noise-terrace-node.tsx
-import { NodeContainer as NodeContainer23, NodeTrackConnections as NodeTrackConnections17 } from "@awesome-flow/core/layout";
-import { ActionIcon as ActionIcon2, Button as Button2, Group as Group11, NumberInput as NumberInput10, Space as Space2 } from "@mantine/core";
+import { NodeContainer as NodeContainer21, NodeTrackConnections as NodeTrackConnections16 } from "@awesome-flow/core/layout";
+import { ActionIcon as ActionIcon2, Button as Button2, Group as Group10, NumberInput as NumberInput9, Space as Space2 } from "@mantine/core";
 import {
-  useIncomingComputedData as useIncomingComputedData9,
-  useUpdateNodeComputedData as useUpdateNodeComputedData20,
-  useUpdateNodeData as useUpdateNodeData13
+  useIncomingComputedData as useIncomingComputedData10,
+  useUpdateNodeComputedData as useUpdateNodeComputedData21,
+  useUpdateNodeData as useUpdateNodeData10
 } from "@awesome-flow/core/hooks";
-import { useCallback as useCallback19, useEffect as useEffect19, useState as useState16 } from "react";
+import { useCallback as useCallback16, useEffect as useEffect17, useState as useState13 } from "react";
 import { Terrace } from "libnoise-ts/module/modifier";
 import { IconX as IconX2 } from "@tabler/icons-react";
 import { randomId as randomId2 } from "@mantine/hooks";
 import { NodeState as NodeState2 } from "@awesome-flow/core/abstract";
-import { Fragment as Fragment4, jsx as jsx26, jsxs as jsxs20 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx21, jsxs as jsxs17 } from "react/jsx-runtime";
 function NoiseTerraceNode({ id, selected, data, type }) {
-  const incoming = useIncomingComputedData9(id);
-  const updateNodeData = useUpdateNodeData13();
-  const updateComputedData = useUpdateNodeComputedData20();
-  const [values, setValues] = useState16([]);
+  const incoming = useIncomingComputedData10(id);
+  const updateNodeData = useUpdateNodeData10();
+  const updateComputedData = useUpdateNodeComputedData21();
+  const [values, setValues] = useState13([]);
   const form = useForm({
     mode: "uncontrolled",
     initialValues: {
@@ -2072,7 +1848,7 @@ function NoiseTerraceNode({ id, selected, data, type }) {
     },
     validateInputOnChange: [`points.${FORM_INDEX}.input`],
     clearInputErrorOnChange: true,
-    onValuesChange: useCallback19((values2) => {
+    onValuesChange: useCallback16((values2) => {
       if (form.isValid()) {
         const points = values2.points.map((v) => v.value);
         setValues(points);
@@ -2081,19 +1857,19 @@ function NoiseTerraceNode({ id, selected, data, type }) {
       form.validate();
     }, [])
   });
-  useEffect19(() => {
+  useEffect17(() => {
     const points = data.points?.length ? data.points.map((v) => ({ value: v, key: randomId2() })) : [1, 2].map(() => ({ value: 0, key: randomId2() }));
     form.initialize({ points });
   }, []);
-  useEffect19(() => {
+  useEffect17(() => {
     if (incoming?.length && values?.length >= 2) {
       const module = new Terrace(incoming[0].module, values);
       updateComputedData(id, { module });
     }
   }, [values, incoming]);
-  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ jsxs20(Group11, { mt: "xs", children: [
-    /* @__PURE__ */ jsx26(
-      NumberInput10,
+  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ jsxs17(Group10, { mt: "xs", children: [
+    /* @__PURE__ */ jsx21(
+      NumberInput9,
       {
         size: "xs",
         placeholder: "Input Value",
@@ -2102,22 +1878,22 @@ function NoiseTerraceNode({ id, selected, data, type }) {
       },
       form.key(`points.${index}.value`)
     ),
-    data.state === NodeState2.edit && values.length > 2 && /* @__PURE__ */ jsx26(
+    data.state === NodeState2.edit && values.length > 2 && /* @__PURE__ */ jsx21(
       ActionIcon2,
       {
         color: "red",
         variant: "outline",
         size: "sm",
         onClick: () => form.removeListItem("points", index),
-        children: /* @__PURE__ */ jsx26(IconX2, { size: "1rem" })
+        children: /* @__PURE__ */ jsx21(IconX2, { size: "1rem" })
       }
     )
   ] }, item.key));
-  return /* @__PURE__ */ jsxs20(NodeContainer23, { id, selected, type, data, children: [
+  return /* @__PURE__ */ jsxs17(NodeContainer21, { id, selected, type, data, children: [
     fields,
-    data.state === NodeState2.edit && /* @__PURE__ */ jsxs20(Fragment4, { children: [
-      /* @__PURE__ */ jsx26(Space2, { h: 10 }),
-      /* @__PURE__ */ jsx26(
+    data.state === NodeState2.edit && /* @__PURE__ */ jsxs17(Fragment2, { children: [
+      /* @__PURE__ */ jsx21(Space2, { h: 10 }),
+      /* @__PURE__ */ jsx21(
         Button2,
         {
           variant: "outline",
@@ -2128,94 +1904,27 @@ function NoiseTerraceNode({ id, selected, data, type }) {
         }
       )
     ] }),
-    /* @__PURE__ */ jsx26(NodeTrackConnections17, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx21(NodeTrackConnections16, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_terrace_node_default = NoiseTerraceNode;
 
-// src/nodes/modifiers/variable-combine-node.tsx
-import { NodeCombobox as NodeCombobox3, NodeContainer as NodeContainer24, NodeTrackConnections as NodeTrackConnections18 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback20, useEffect as useEffect20, useState as useState17 } from "react";
-import { useIncomingNodeData as useIncomingNodeData3, useUpdateNodeData as useUpdateNodeData14 } from "@awesome-flow/core/hooks";
-import {
-  IconAsterisk as IconAsterisk2,
-  IconChevronLeft as IconChevronLeft2,
-  IconChevronRight as IconChevronRight2,
-  IconChevronUp as IconChevronUp2,
-  IconDivide,
-  IconPlus as IconPlus2
-} from "@tabler/icons-react";
-import { jsx as jsx27, jsxs as jsxs21 } from "react/jsx-runtime";
-var options2 = {
-  add: /* @__PURE__ */ jsx27(IconPlus2, {}),
-  divide: /* @__PURE__ */ jsx27(IconDivide, {}),
-  min: /* @__PURE__ */ jsx27(IconChevronLeft2, {}),
-  max: /* @__PURE__ */ jsx27(IconChevronRight2, {}),
-  multiply: /* @__PURE__ */ jsx27(IconAsterisk2, {}),
-  power: /* @__PURE__ */ jsx27(IconChevronUp2, {})
-};
-function VariableCombineNode({
-  id,
-  selected,
-  data,
-  type
-}) {
-  const [operation, setOperation] = useState17(data.operation);
-  const [value, setValue] = useState17(data.value);
-  const updateNodeData = useUpdateNodeData14();
-  const incoming = useIncomingNodeData3(id);
-  useEffect20(() => {
-    if (incoming?.length > 1) {
-      const result = getOperationResult(operation, incoming[0].value, incoming[1].value);
-      setValue(result);
-      updateNodeData(id, { value: result });
-    }
-  }, [operation, incoming]);
-  const onChange = useCallback20((op) => {
-    updateNodeData(id, { operation: op });
-    setOperation(op);
-  }, []);
-  return /* @__PURE__ */ jsxs21(NodeContainer24, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx27(NodeCombobox3, { options: options2, selected: operation, onChange }),
-    /* @__PURE__ */ jsx27(node_value_input_default, { value, onChange: () => {
-    }, disabled: true }),
-    /* @__PURE__ */ jsx27(NodeTrackConnections18, { handles: data.handles, nodeId: id, type: "target" })
-  ] });
-}
-function getOperationResult(operation, value1, value2) {
-  switch (operation) {
-    case "add" /* add */:
-      return Number(value1) + Number(value2);
-    case "divide" /* divide */:
-      return Number(value1) / (Number(value2) || 1);
-    case "max" /* max */:
-      return Number(value1) > Number(value2) ? value1 : value2;
-    case "min" /* min */:
-      return Number(value1) < Number(value2) ? value1 : value2;
-    case "multiply" /* multiply */:
-      return Number(value1) * Number(value2);
-    case "power" /* power */:
-      return Number(value1) ** Number(value2);
-  }
-}
-var variable_combine_node_default = VariableCombineNode;
-
 // src/nodes/output/noise-logger-node.tsx
-import { NodeContainer as NodeContainer25, NodeTrackConnections as NodeTrackConnections19 } from "@awesome-flow/core/layout";
-import { useMemo as useMemo11 } from "react";
-import { Divider, Stack as Stack10, Text } from "@mantine/core";
-import { useIncomingComputedData as useIncomingComputedData10 } from "@awesome-flow/core/hooks";
-import { jsx as jsx28, jsxs as jsxs22 } from "react/jsx-runtime";
+import { NodeContainer as NodeContainer22, NodeTrackConnections as NodeTrackConnections17 } from "@awesome-flow/core/layout";
+import { useMemo as useMemo10 } from "react";
+import { Divider, Stack as Stack8, Text } from "@mantine/core";
+import { useIncomingComputedData as useIncomingComputedData11 } from "@awesome-flow/core/hooks";
+import { jsx as jsx22, jsxs as jsxs18 } from "react/jsx-runtime";
 function NoiseLoggerNode({ id, selected, data, type }) {
-  const incoming = useIncomingComputedData10(id);
-  const noise = useMemo11(() => incoming?.map((p) => p.noise).flat(), [incoming]);
-  return /* @__PURE__ */ jsxs22(NodeContainer25, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs22(Text, { children: [
+  const incoming = useIncomingComputedData11(id);
+  const noise = useMemo10(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+  return /* @__PURE__ */ jsxs18(NodeContainer22, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs18(Text, { children: [
       "Size: ",
       noise?.length || 0
     ] }),
-    /* @__PURE__ */ jsx28(Divider, { h: 5 }),
-    /* @__PURE__ */ jsx28(Stack10, { children: noise?.map((v, i) => /* @__PURE__ */ jsxs22(Text, { children: [
+    /* @__PURE__ */ jsx22(Divider, { h: 5 }),
+    /* @__PURE__ */ jsx22(Stack8, { children: noise?.map((v, i) => /* @__PURE__ */ jsxs18(Text, { children: [
       v.position?.x,
       ":",
       v.position?.y,
@@ -2224,92 +1933,31 @@ function NoiseLoggerNode({ id, selected, data, type }) {
       ": ",
       v.value
     ] }, i)) }),
-    /* @__PURE__ */ jsx28(NodeTrackConnections19, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx22(NodeTrackConnections17, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_logger_node_default = NoiseLoggerNode;
 
 // src/nodes/output/noise-output-node.tsx
-import { NodeContainer as NodeContainer26, NodeTrackConnections as NodeTrackConnections20 } from "@awesome-flow/core/layout";
-import { useIncomingComputedData as useIncomingComputedData11, useUpdateNodeComputedData as useUpdateNodeComputedData21 } from "@awesome-flow/core/hooks";
-import { Box, Group as Group12, LoadingOverlay, Stack as Stack11 } from "@mantine/core";
-import { useEffect as useEffect21, useState as useState18 } from "react";
-import { jsx as jsx29, jsxs as jsxs23 } from "react/jsx-runtime";
-function NoiseOutputNode({ id, selected, data, type }) {
-  const [generating, setGenerating] = useState18(false);
-  const updateComputedData = useUpdateNodeComputedData21();
-  const incomingModules = useIncomingComputedData11(id, 8 /* module */);
-  const incomingPositions = useIncomingComputedData11(
-    id,
-    4 /* position */
-  );
-  useEffect21(() => {
-    if (incomingPositions?.length && incomingModules?.length) {
-      const { module } = incomingModules[0];
-      if (module) {
-        setGenerating(true);
-      }
-    }
-  }, [incomingModules, incomingPositions]);
-  useEffect21(() => {
-    if (incomingPositions?.length && incomingModules?.length) {
-      const { module } = incomingModules[0];
-      if (module && generating) {
-        const noise = [];
-        for (const input of incomingPositions) {
-          for (const position of input.positions) {
-            const value = module.getValue(position.x, position.y, position.z);
-            noise.push({
-              position,
-              value
-            });
-          }
-        }
-        console.log("SET COMPUTED DATA");
-        updateComputedData(id, { noise, module });
-        setGenerating(false);
-      }
-    }
-  }, [generating]);
-  return /* @__PURE__ */ jsxs23(NodeContainer26, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs23(Box, { pos: "relative", children: [
-      /* @__PURE__ */ jsx29(
-        LoadingOverlay,
-        {
-          visible: generating,
-          zIndex: 1e3,
-          overlayProps: { radius: "sm", blur: 2 }
-        }
-      ),
-      /* @__PURE__ */ jsxs23(Stack11, { children: [
-        /* @__PURE__ */ jsxs23(Group12, { children: [
-          "Position Inputs: ",
-          incomingPositions?.length
-        ] }),
-        /* @__PURE__ */ jsxs23(Group12, { children: [
-          "Module Inputs: ",
-          incomingModules?.length
-        ] })
-      ] })
-    ] }),
-    /* @__PURE__ */ jsx29(NodeTrackConnections20, { handles: data.handles, nodeId: id, type: "target" })
-  ] });
-}
-var noise_output_node_default = NoiseOutputNode;
+import { NodeContainer as NodeContainer32, NodeTrackConnections as NodeTrackConnections27 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback21, useState as useState20 } from "react";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData30 } from "@awesome-flow/core/hooks";
+import { HandlesIncomingDataStatus as HandlesIncomingDataStatus4 } from "@awesome-flow/core/components";
+import { Text as Text3 } from "@mantine/core";
 
 // src/nodes/output/noise-raw-texture-node.tsx
-import { NodeContainer as NodeContainer27, NodeTrackConnections as NodeTrackConnections21 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect22, useMemo as useMemo12, useState as useState19 } from "react";
+import { NodeContainer as NodeContainer23, NodeTrackConnections as NodeTrackConnections18 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect18, useMemo as useMemo11, useState as useState14 } from "react";
 import { useIncomingComputedData as useIncomingComputedData12, useUpdateNodeComputedData as useUpdateNodeComputedData22 } from "@awesome-flow/core/hooks";
-import { Group as Group13, Stack as Stack12 } from "@mantine/core";
-import { jsx as jsx30, jsxs as jsxs24 } from "react/jsx-runtime";
+import { Group as Group11, Stack as Stack9 } from "@mantine/core";
+import { jsx as jsx23, jsxs as jsxs19 } from "react/jsx-runtime";
 function NoiseRawTextureNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData22();
-  const [dataLength, setDataLength] = useState19(0);
-  const [resolution, setResolution] = useState19(0);
+  const [dataLength, setDataLength] = useState14(0);
+  const [resolution, setResolution] = useState14(0);
   const incoming = useIncomingComputedData12(id);
-  const noise = useMemo12(() => incoming?.map((p) => p.noise).flat(), [incoming]);
-  useEffect22(() => {
+  const noise = useMemo11(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+  useEffect18(() => {
     if (noise?.length) {
       const size = Math.ceil(Math.sqrt(noise.length));
       const colors = noise.map((n) => [n.value * 255, n.value * 255, n.value * 255, 255]).flat();
@@ -2320,19 +1968,19 @@ function NoiseRawTextureNode({ id, selected, data, type }) {
       updateComputedData(id, { textureData: dataArray, textureResolution: size });
     }
   }, [noise]);
-  return /* @__PURE__ */ jsxs24(NodeContainer27, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs24(Stack12, { children: [
-      /* @__PURE__ */ jsxs24(Group13, { children: [
+  return /* @__PURE__ */ jsxs19(NodeContainer23, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs19(Stack9, { children: [
+      /* @__PURE__ */ jsxs19(Group11, { children: [
         "Resolution: ",
         resolution,
         "x",
         resolution
       ] }),
-      /* @__PURE__ */ jsxs24(Group13, { children: [
+      /* @__PURE__ */ jsxs19(Group11, { children: [
         "Input Length: ",
         noise?.length || 0
       ] }),
-      /* @__PURE__ */ jsxs24(Group13, { children: [
+      /* @__PURE__ */ jsxs19(Group11, { children: [
         "Output Length (",
         resolution,
         "*",
@@ -2341,104 +1989,122 @@ function NoiseRawTextureNode({ id, selected, data, type }) {
         dataLength
       ] })
     ] }),
-    /* @__PURE__ */ jsx30(NodeTrackConnections21, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx23(NodeTrackConnections18, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_raw_texture_node_default = NoiseRawTextureNode;
 
 // src/nodes/output/positions-logger-node.tsx
-import { NodeContainer as NodeContainer28, NodeTrackConnections as NodeTrackConnections22 } from "@awesome-flow/core/layout";
-import { useMemo as useMemo13 } from "react";
-import { Divider as Divider2, Stack as Stack13, Text as Text2 } from "@mantine/core";
+import { NodeContainer as NodeContainer24, NodeTrackConnections as NodeTrackConnections19 } from "@awesome-flow/core/layout";
+import { useMemo as useMemo12 } from "react";
+import { Divider as Divider2, Stack as Stack10, Text as Text2 } from "@mantine/core";
 import { useIncomingComputedData as useIncomingComputedData13 } from "@awesome-flow/core/hooks";
-import { jsx as jsx31, jsxs as jsxs25 } from "react/jsx-runtime";
+import { jsx as jsx24, jsxs as jsxs20 } from "react/jsx-runtime";
 function PositionsLoggerNode({ id, selected, data, type }) {
   const incoming = useIncomingComputedData13(id);
-  const positions = useMemo13(() => {
+  const positions = useMemo12(() => {
     return incoming?.map((p) => p.positions).flat();
   }, [incoming]);
-  return /* @__PURE__ */ jsxs25(NodeContainer28, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs25(Text2, { children: [
+  return /* @__PURE__ */ jsxs20(NodeContainer24, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs20(Text2, { children: [
       "Size: ",
       positions?.length || 0
     ] }),
-    /* @__PURE__ */ jsx31(Divider2, { h: 5 }),
-    /* @__PURE__ */ jsx31(Stack13, { children: positions?.map((v, i) => /* @__PURE__ */ jsxs25(Text2, { children: [
+    /* @__PURE__ */ jsx24(Divider2, { h: 5 }),
+    /* @__PURE__ */ jsx24(Stack10, { children: positions?.map((v, i) => /* @__PURE__ */ jsxs20(Text2, { children: [
       v.x,
       ":",
       v.y,
       ":",
       v.z
     ] }, i)) }),
-    /* @__PURE__ */ jsx31(NodeTrackConnections22, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx24(NodeTrackConnections19, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var positions_logger_node_default = PositionsLoggerNode;
 
 // src/nodes/selectors/noise-blend-node.tsx
-import { NodeContainer as NodeContainer29, NodeTrackConnections as NodeTrackConnections23 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect23 } from "react";
-import { useIncomingComputedData as useIncomingComputedData14, useUpdateNodeComputedData as useUpdateNodeComputedData23 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer25, NodeTrackConnections as NodeTrackConnections20 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback17 } from "react";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData23 } from "@awesome-flow/core/hooks";
 import { Blend } from "libnoise-ts/module/selector";
-import { Group as Group14 } from "@mantine/core";
-import { jsx as jsx32, jsxs as jsxs26 } from "react/jsx-runtime";
+import { HandlesIncomingDataStatus } from "@awesome-flow/core/components";
+import { jsx as jsx25, jsxs as jsxs21 } from "react/jsx-runtime";
 function NoiseBlendNode({ id, selected, data, type }) {
-  const incoming = useIncomingComputedData14(id);
   const updateComputedData = useUpdateNodeComputedData23();
-  useEffect23(() => {
-    if (incoming?.length > 2) {
-      const module = new Blend(incoming[0].module, incoming[1].module, incoming[2].module);
-      updateComputedData(id, { module });
-    }
-  }, [id, incoming, updateComputedData]);
-  return /* @__PURE__ */ jsxs26(NodeContainer29, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs26(Group14, { children: [
-      "Modules: ",
-      incoming?.length
-    ] }),
-    /* @__PURE__ */ jsx32(NodeTrackConnections23, { handles: data.handles, nodeId: id, type: "target" })
+  const onDataUpdated = useCallback17(
+    (incomingData) => {
+      const incomingSources = incomingData["source" /* source */];
+      const incomingControl = incomingData["control" /* control */];
+      if (incomingSources?.length >= 2 && incomingControl?.length) {
+        const module = new Blend(
+          incomingSources[0].module,
+          incomingSources[1].module,
+          incomingControl[0].module
+        );
+        updateComputedData(id, { module });
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs21(NodeContainer25, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx25(
+      HandlesIncomingDataStatus,
+      {
+        nodeId: id,
+        handles: data.handles,
+        handleKey: "dataId",
+        onDataUpdated,
+        type: "target",
+        resetComputedData: true
+      }
+    ),
+    /* @__PURE__ */ jsx25(NodeTrackConnections20, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_blend_node_default = NoiseBlendNode;
 
 // src/nodes/selectors/noise-select-node.tsx
-import { NodeContainer as NodeContainer30, NodeTrackConnections as NodeTrackConnections24 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect24, useState as useState20 } from "react";
-import {
-  useIncomingComputedData as useIncomingComputedData15,
-  useUpdateNodeComputedData as useUpdateNodeComputedData24,
-  useUpdateNodeData as useUpdateNodeData15
-} from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer26, NodeTrackConnections as NodeTrackConnections21 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback18, useEffect as useEffect19, useState as useState15 } from "react";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData24, useUpdateNodeData as useUpdateNodeData11 } from "@awesome-flow/core/hooks";
 import { Select } from "libnoise-ts/module/selector";
-import { Group as Group15, NumberInput as NumberInput11, Stack as Stack14 } from "@mantine/core";
-import { jsx as jsx33, jsxs as jsxs27 } from "react/jsx-runtime";
+import { Group as Group12, NumberInput as NumberInput10, Stack as Stack11 } from "@mantine/core";
+import { HandlesIncomingDataStatus as HandlesIncomingDataStatus2 } from "@awesome-flow/core/components";
+import { jsx as jsx26, jsxs as jsxs22 } from "react/jsx-runtime";
 function NoiseSelectNode({ id, selected, data, type }) {
-  const [edgeFalloff, setEdgeFalloff] = useState20(data.edgeFalloff);
-  const [lowerBound, setLowerBound] = useState20(data.lowerBound);
-  const [upperBound, setUpperBound] = useState20(data.upperBound);
-  const incoming = useIncomingComputedData15(id);
-  const updateNodeData = useUpdateNodeData15();
+  const [edgeFalloff, setEdgeFalloff] = useState15(data.edgeFalloff);
+  const [lowerBound, setLowerBound] = useState15(data.lowerBound);
+  const [upperBound, setUpperBound] = useState15(data.upperBound);
+  const updateNodeData = useUpdateNodeData11();
   const updateComputedData = useUpdateNodeComputedData24();
-  useEffect24(() => {
-    if (incoming?.length > 2) {
-      const module = new Select(
-        incoming[0].module,
-        incoming[1].module,
-        incoming[2].module,
-        edgeFalloff,
-        lowerBound,
-        upperBound
-      );
-      updateComputedData(id, { module });
-    }
+  useEffect19(() => {
     updateNodeData(id, { edgeFalloff, lowerBound, upperBound });
-  }, [incoming, edgeFalloff, lowerBound, upperBound, updateNodeData, id, updateComputedData]);
-  return /* @__PURE__ */ jsxs27(NodeContainer30, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs27(Stack14, { children: [
-      /* @__PURE__ */ jsxs27(Group15, { children: [
+  }, [edgeFalloff, lowerBound, upperBound]);
+  const onDataUpdated = useCallback18(
+    (incomingData) => {
+      const incomingSources = incomingData["source" /* source */];
+      const incomingControl = incomingData["control" /* control */];
+      if (incomingSources?.length >= 2 && incomingControl?.length) {
+        const module = new Select(
+          incomingSources[0].module,
+          incomingSources[1].module,
+          incomingControl[0].module,
+          edgeFalloff,
+          lowerBound,
+          upperBound
+        );
+        updateComputedData(id, { module });
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs22(NodeContainer26, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs22(Stack11, { children: [
+      /* @__PURE__ */ jsxs22(Group12, { children: [
         "Edge Falloff:",
-        /* @__PURE__ */ jsx33(
-          NumberInput11,
+        /* @__PURE__ */ jsx26(
+          NumberInput10,
           {
             size: "xs",
             w: 100,
@@ -2448,10 +2114,10 @@ function NoiseSelectNode({ id, selected, data, type }) {
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs27(Group15, { children: [
+      /* @__PURE__ */ jsxs22(Group12, { children: [
         "Lower Bound:",
-        /* @__PURE__ */ jsx33(
-          NumberInput11,
+        /* @__PURE__ */ jsx26(
+          NumberInput10,
           {
             size: "xs",
             w: 100,
@@ -2461,10 +2127,10 @@ function NoiseSelectNode({ id, selected, data, type }) {
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs27(Group15, { children: [
+      /* @__PURE__ */ jsxs22(Group12, { children: [
         "Upper Bound:",
-        /* @__PURE__ */ jsx33(
-          NumberInput11,
+        /* @__PURE__ */ jsx26(
+          NumberInput10,
           {
             size: "xs",
             w: 100,
@@ -2474,101 +2140,103 @@ function NoiseSelectNode({ id, selected, data, type }) {
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs27(Group15, { children: [
-        "Modules: ",
-        incoming?.length
-      ] })
+      /* @__PURE__ */ jsx26(
+        HandlesIncomingDataStatus2,
+        {
+          nodeId: id,
+          handles: data.handles,
+          handleKey: "dataId",
+          onDataUpdated,
+          type: "target",
+          resetComputedData: true
+        }
+      )
     ] }),
-    /* @__PURE__ */ jsx33(NodeTrackConnections24, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx26(NodeTrackConnections21, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_select_node_default = NoiseSelectNode;
 
 // src/nodes/transformers/noise-displace-node.tsx
-import { NodeContainer as NodeContainer31, NodeTrackConnections as NodeTrackConnections25 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect25, useMemo as useMemo14 } from "react";
-import { useIncomingHandleData, useUpdateNodeComputedData as useUpdateNodeComputedData25 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer27, NodeTrackConnections as NodeTrackConnections22 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback19 } from "react";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData25 } from "@awesome-flow/core/hooks";
 import { Displace } from "libnoise-ts/module/transformer";
-import { Badge as Badge2, Stack as Stack15 } from "@mantine/core";
-import { jsx as jsx34, jsxs as jsxs28 } from "react/jsx-runtime";
+import { HandlesIncomingDataStatus as HandlesIncomingDataStatus3 } from "@awesome-flow/core/components";
+import { jsx as jsx27, jsxs as jsxs23 } from "react/jsx-runtime";
 function NoiseDisplaceNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData25();
-  const incomingHandleData = useIncomingHandleData(id, data.handles);
-  const { sourceModule, xModule, yModule, zModule } = useMemo14(() => {
-    return {
-      sourceModule: incomingHandleData["source" /* sourceModule */],
-      xModule: incomingHandleData["x-module" /* xModule */],
-      yModule: incomingHandleData["y-module" /* yModule */],
-      zModule: incomingHandleData["z-module" /* zModule */]
-    };
-  }, [incomingHandleData]);
-  useEffect25(() => {
-    if (sourceModule && xModule && yModule && zModule) {
-      const module = new Displace(
-        sourceModule[0].module,
-        xModule[0].module,
-        yModule[0].module,
-        zModule[0].module
-      );
-      updateComputedData(id, { module });
-    }
-  }, [id, updateComputedData, sourceModule, xModule, yModule, zModule]);
-  const { sourceColor, xColor, yColor, zColor } = useMemo14(() => {
-    return {
-      sourceColor: sourceModule ? "green" : "orange",
-      xColor: xModule ? "green" : "orange",
-      yColor: yModule ? "green" : "orange",
-      zColor: zModule ? "green" : "orange"
-    };
-  }, [sourceModule, xModule, yModule, zModule]);
-  return /* @__PURE__ */ jsxs28(NodeContainer31, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs28(Stack15, { align: "center", children: [
-      /* @__PURE__ */ jsx34(Badge2, { color: sourceColor, children: "Source Module" }),
-      /* @__PURE__ */ jsx34(Badge2, { color: xColor, children: "X Module" }),
-      /* @__PURE__ */ jsx34(Badge2, { color: yColor, children: "Y Module" }),
-      /* @__PURE__ */ jsx34(Badge2, { color: zColor, children: "Z Module" })
-    ] }),
-    /* @__PURE__ */ jsx34(NodeTrackConnections25, { handles: data.handles, nodeId: id, type: "target" })
+  const onDataUpdated = useCallback19(
+    (handleData) => {
+      const sourceModule = handleData["source" /* sourceModule */];
+      const xModule = handleData["x-module" /* xModule */];
+      const yModule = handleData["y-module" /* yModule */];
+      const zModule = handleData["z-module" /* zModule */];
+      if (sourceModule && xModule && yModule && zModule) {
+        const module = new Displace(
+          sourceModule[0].module,
+          xModule[0].module,
+          yModule[0].module,
+          zModule[0].module
+        );
+        updateComputedData(id, { module });
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs23(NodeContainer27, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx27(
+      HandlesIncomingDataStatus3,
+      {
+        nodeId: id,
+        handles: data.handles,
+        handleKey: "dataId",
+        onDataUpdated,
+        type: "target",
+        resetComputedData: true
+      }
+    ),
+    /* @__PURE__ */ jsx27(NodeTrackConnections22, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_displace_node_default = NoiseDisplaceNode;
 
 // src/nodes/transformers/noise-rotate-point-node.tsx
-import { NodeContainer as NodeContainer32, NodeTrackConnections as NodeTrackConnections26 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect26, useState as useState21 } from "react";
+import { NodeContainer as NodeContainer28, NodeTrackConnections as NodeTrackConnections23 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect20, useState as useState16 } from "react";
 import {
-  useIncomingComputedData as useIncomingComputedData16,
+  useIncomingComputedData as useIncomingComputedData14,
   useUpdateNodeComputedData as useUpdateNodeComputedData26,
-  useUpdateNodeData as useUpdateNodeData16
+  useUpdateNodeData as useUpdateNodeData12
 } from "@awesome-flow/core/hooks";
-import { Group as Group16, NumberInput as NumberInput12, Stack as Stack16 } from "@mantine/core";
+import { Group as Group13, NumberInput as NumberInput11, Stack as Stack12 } from "@mantine/core";
 import { RotatePoint } from "libnoise-ts/module/transformer";
-import { jsx as jsx35, jsxs as jsxs29 } from "react/jsx-runtime";
+import { jsx as jsx28, jsxs as jsxs24 } from "react/jsx-runtime";
 function NoiseRotatePointNode({
   id,
   selected,
   data,
   type
 }) {
-  const [xAngle, setXAngle] = useState21(data.xAngle);
-  const [yAngle, setYAngle] = useState21(data.yAngle);
-  const [zAngle, setZAngle] = useState21(data.zAngle);
-  const incoming = useIncomingComputedData16(id);
-  const updateNodeData = useUpdateNodeData16();
+  const [xAngle, setXAngle] = useState16(data.xAngle);
+  const [yAngle, setYAngle] = useState16(data.yAngle);
+  const [zAngle, setZAngle] = useState16(data.zAngle);
+  const incoming = useIncomingComputedData14(id);
+  const updateNodeData = useUpdateNodeData12();
   const updateComputedData = useUpdateNodeComputedData26();
-  useEffect26(() => {
+  useEffect20(() => {
     if (incoming?.length) {
       const module = new RotatePoint(incoming[0].module, xAngle, yAngle, zAngle);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { xAngle, yAngle, zAngle });
   }, [id, updateComputedData, updateNodeData, incoming, xAngle, yAngle, zAngle]);
-  return /* @__PURE__ */ jsxs29(NodeContainer32, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs29(Stack16, { children: [
-      /* @__PURE__ */ jsxs29(Group16, { children: [
+  return /* @__PURE__ */ jsxs24(NodeContainer28, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs24(Stack12, { children: [
+      /* @__PURE__ */ jsxs24(Group13, { children: [
         "X Angle:",
-        /* @__PURE__ */ jsx35(
-          NumberInput12,
+        /* @__PURE__ */ jsx28(
+          NumberInput11,
           {
             size: "xs",
             w: 100,
@@ -2578,10 +2246,10 @@ function NoiseRotatePointNode({
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs29(Group16, { children: [
+      /* @__PURE__ */ jsxs24(Group13, { children: [
         "Y Angle:",
-        /* @__PURE__ */ jsx35(
-          NumberInput12,
+        /* @__PURE__ */ jsx28(
+          NumberInput11,
           {
             size: "xs",
             w: 100,
@@ -2591,10 +2259,10 @@ function NoiseRotatePointNode({
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs29(Group16, { children: [
+      /* @__PURE__ */ jsxs24(Group13, { children: [
         "Z Angle:",
-        /* @__PURE__ */ jsx35(
-          NumberInput12,
+        /* @__PURE__ */ jsx28(
+          NumberInput11,
           {
             size: "xs",
             w: 100,
@@ -2605,47 +2273,47 @@ function NoiseRotatePointNode({
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsx35(NodeTrackConnections26, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx28(NodeTrackConnections23, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_rotate_point_node_default = NoiseRotatePointNode;
 
 // src/nodes/transformers/noise-scale-point-node.tsx
-import { NodeContainer as NodeContainer33, NodeTrackConnections as NodeTrackConnections27 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect27, useState as useState22 } from "react";
+import { NodeContainer as NodeContainer29, NodeTrackConnections as NodeTrackConnections24 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect21, useState as useState17 } from "react";
 import {
-  useIncomingComputedData as useIncomingComputedData17,
+  useIncomingComputedData as useIncomingComputedData15,
   useUpdateNodeComputedData as useUpdateNodeComputedData27,
-  useUpdateNodeData as useUpdateNodeData17
+  useUpdateNodeData as useUpdateNodeData13
 } from "@awesome-flow/core/hooks";
-import { Group as Group17, NumberInput as NumberInput13, Stack as Stack17 } from "@mantine/core";
+import { Group as Group14, NumberInput as NumberInput12, Stack as Stack13 } from "@mantine/core";
 import { ScalePoint } from "libnoise-ts/module/transformer";
-import { jsx as jsx36, jsxs as jsxs30 } from "react/jsx-runtime";
+import { jsx as jsx29, jsxs as jsxs25 } from "react/jsx-runtime";
 function NoiseScalePointNode({
   id,
   selected,
   data,
   type
 }) {
-  const [xScale, setXScale] = useState22(data.xScale);
-  const [yScale, setYScale] = useState22(data.yScale);
-  const [zScale, setZScale] = useState22(data.zScale);
-  const incoming = useIncomingComputedData17(id);
-  const updateNodeData = useUpdateNodeData17();
+  const [xScale, setXScale] = useState17(data.xScale);
+  const [yScale, setYScale] = useState17(data.yScale);
+  const [zScale, setZScale] = useState17(data.zScale);
+  const incoming = useIncomingComputedData15(id);
+  const updateNodeData = useUpdateNodeData13();
   const updateComputedData = useUpdateNodeComputedData27();
-  useEffect27(() => {
+  useEffect21(() => {
     if (incoming?.length) {
       const module = new ScalePoint(incoming[0].module, xScale, yScale, zScale);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { xScale, yScale, zScale });
   }, [id, incoming, updateComputedData, updateNodeData, xScale, yScale, zScale]);
-  return /* @__PURE__ */ jsxs30(NodeContainer33, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs30(Stack17, { children: [
-      /* @__PURE__ */ jsxs30(Group17, { children: [
+  return /* @__PURE__ */ jsxs25(NodeContainer29, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs25(Stack13, { children: [
+      /* @__PURE__ */ jsxs25(Group14, { children: [
         "X Scale:",
-        /* @__PURE__ */ jsx36(
-          NumberInput13,
+        /* @__PURE__ */ jsx29(
+          NumberInput12,
           {
             size: "xs",
             w: 100,
@@ -2655,10 +2323,10 @@ function NoiseScalePointNode({
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs30(Group17, { children: [
+      /* @__PURE__ */ jsxs25(Group14, { children: [
         "Y Scale:",
-        /* @__PURE__ */ jsx36(
-          NumberInput13,
+        /* @__PURE__ */ jsx29(
+          NumberInput12,
           {
             size: "xs",
             w: 100,
@@ -2668,10 +2336,10 @@ function NoiseScalePointNode({
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs30(Group17, { children: [
+      /* @__PURE__ */ jsxs25(Group14, { children: [
         "Z Scale:",
-        /* @__PURE__ */ jsx36(
-          NumberInput13,
+        /* @__PURE__ */ jsx29(
+          NumberInput12,
           {
             size: "xs",
             w: 100,
@@ -2682,47 +2350,47 @@ function NoiseScalePointNode({
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsx36(NodeTrackConnections27, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx29(NodeTrackConnections24, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_scale_point_node_default = NoiseScalePointNode;
 
 // src/nodes/transformers/noise-translate-point-node.tsx
-import { NodeContainer as NodeContainer34, NodeTrackConnections as NodeTrackConnections28 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect28, useState as useState23 } from "react";
+import { NodeContainer as NodeContainer30, NodeTrackConnections as NodeTrackConnections25 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect22, useState as useState18 } from "react";
 import {
-  useIncomingComputedData as useIncomingComputedData18,
+  useIncomingComputedData as useIncomingComputedData16,
   useUpdateNodeComputedData as useUpdateNodeComputedData28,
-  useUpdateNodeData as useUpdateNodeData18
+  useUpdateNodeData as useUpdateNodeData14
 } from "@awesome-flow/core/hooks";
-import { Group as Group18, NumberInput as NumberInput14, Stack as Stack18 } from "@mantine/core";
+import { Group as Group15, NumberInput as NumberInput13, Stack as Stack14 } from "@mantine/core";
 import { TranslatePoint } from "libnoise-ts/module/transformer";
-import { jsx as jsx37, jsxs as jsxs31 } from "react/jsx-runtime";
+import { jsx as jsx30, jsxs as jsxs26 } from "react/jsx-runtime";
 function NoiseTranslatePointNode({
   id,
   selected,
   data,
   type
 }) {
-  const [translateX, setTranslateX] = useState23(data.translateX);
-  const [translateY, setTranslateY] = useState23(data.translateY);
-  const [translateZ, setTranslateZ] = useState23(data.translateZ);
-  const incoming = useIncomingComputedData18(id);
-  const updateNodeData = useUpdateNodeData18();
+  const [translateX, setTranslateX] = useState18(data.translateX);
+  const [translateY, setTranslateY] = useState18(data.translateY);
+  const [translateZ, setTranslateZ] = useState18(data.translateZ);
+  const incoming = useIncomingComputedData16(id);
+  const updateNodeData = useUpdateNodeData14();
   const updateComputedData = useUpdateNodeComputedData28();
-  useEffect28(() => {
+  useEffect22(() => {
     if (incoming?.length) {
       const module = new TranslatePoint(incoming[0].module, translateX, translateY, translateZ);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { translateX, translateY, translateZ });
   }, [id, incoming, translateX, translateY, translateZ, updateComputedData, updateNodeData]);
-  return /* @__PURE__ */ jsxs31(NodeContainer34, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs31(Stack18, { children: [
-      /* @__PURE__ */ jsxs31(Group18, { children: [
+  return /* @__PURE__ */ jsxs26(NodeContainer30, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs26(Stack14, { children: [
+      /* @__PURE__ */ jsxs26(Group15, { children: [
         "Translate X:",
-        /* @__PURE__ */ jsx37(
-          NumberInput14,
+        /* @__PURE__ */ jsx30(
+          NumberInput13,
           {
             size: "xs",
             w: 100,
@@ -2732,10 +2400,10 @@ function NoiseTranslatePointNode({
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs31(Group18, { children: [
+      /* @__PURE__ */ jsxs26(Group15, { children: [
         "Translate Y:",
-        /* @__PURE__ */ jsx37(
-          NumberInput14,
+        /* @__PURE__ */ jsx30(
+          NumberInput13,
           {
             size: "xs",
             w: 100,
@@ -2745,10 +2413,10 @@ function NoiseTranslatePointNode({
           }
         )
       ] }),
-      /* @__PURE__ */ jsxs31(Group18, { children: [
+      /* @__PURE__ */ jsxs26(Group15, { children: [
         "Translate Z:",
-        /* @__PURE__ */ jsx37(
-          NumberInput14,
+        /* @__PURE__ */ jsx30(
+          NumberInput13,
           {
             size: "xs",
             w: 100,
@@ -2759,31 +2427,32 @@ function NoiseTranslatePointNode({
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsx37(NodeTrackConnections28, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx30(NodeTrackConnections25, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_translate_point_node_default = NoiseTranslatePointNode;
 
 // src/nodes/transformers/noise-turbulence-node .tsx
-import { NodeContainer as NodeContainer35, NodeTrackConnections as NodeTrackConnections29 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback21, useEffect as useEffect29, useState as useState24 } from "react";
-import { useIncomingComputedData as useIncomingComputedData19, useUpdateNodeComputedData as useUpdateNodeComputedData29 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer31, NodeTrackConnections as NodeTrackConnections26 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback20, useEffect as useEffect23, useState as useState19 } from "react";
+import { useIncomingComputedData as useIncomingComputedData17, useUpdateNodeComputedData as useUpdateNodeComputedData29 } from "@awesome-flow/core/hooks";
 import { Turbulence } from "libnoise-ts/module/transformer";
-import { jsx as jsx38, jsxs as jsxs32 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables7 } from "@awesome-flow/core/components";
+import { jsx as jsx31, jsxs as jsxs27 } from "react/jsx-runtime";
 function NoiseTurbulenceNode({
   id,
   selected,
   data,
   type
 }) {
-  const [properties, setProperties] = useState24(null);
-  const incoming = useIncomingComputedData19(id);
+  const [properties, setProperties] = useState19(null);
+  const incoming = useIncomingComputedData17(id);
   const updateComputedData = useUpdateNodeComputedData29();
-  const onPropertiesChange = useCallback21((props) => {
+  const onPropertiesChange = useCallback20((props) => {
     setProperties(props);
   }, []);
-  useEffect29(() => {
-    if (incoming?.length) {
+  useEffect23(() => {
+    if (incoming?.length && properties) {
       const module = new Turbulence(
         incoming[0].module,
         properties.frequency.value,
@@ -2793,15 +2462,1011 @@ function NoiseTurbulenceNode({
       );
       updateComputedData(id, { module });
     }
-  }, [id, incoming, properties, updateComputedData]);
-  return /* @__PURE__ */ jsxs32(NodeContainer35, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx38(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx38(NodeTrackConnections29, { handles: data.handles, nodeId: id, type: "target" })
+  }, [id, incoming, properties]);
+  return /* @__PURE__ */ jsxs27(NodeContainer31, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx31(NodePropertyVariables7, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx31(NodeTrackConnections26, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_turbulence_node_default = NoiseTurbulenceNode;
+
+// src/templates/generators/noise-checkerboard-template.ts
+import { Position } from "@xyflow/system";
+var NoiseCheckerboardNodeTemplateFactory = class {
+  template = {
+    type: "noise-checkerboard" /* noiseCheckerboard */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Checkerboard Noise"
+    },
+    handles: [
+      {
+        position: Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-const-template.ts
+import { Position as Position2 } from "@xyflow/system";
+var NoiseConstNodeTemplateFactory = class {
+  template = {
+    type: "noise-constant" /* noiseConst */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Const Value Noise",
+      noise: 0,
+      min: -1,
+      max: 1
+    },
+    handles: [
+      {
+        position: Position2.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-cylinders-template.ts
+import { CoreHandleType } from "@awesome-flow/core/abstract";
+import { Position as Position3 } from "@xyflow/system";
+var NoiseCylindersNodeTemplateFactory = class {
+  template = {
+    type: "noise-cylinders" /* noiseCylinders */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Cylinders Noise",
+      frequency: 0.1
+    },
+    handles: [
+      {
+        position: Position3.Left,
+        dataType: CoreHandleType.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position3.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-perlin-template.ts
+import { CoreHandleType as CoreHandleType2 } from "@awesome-flow/core/abstract";
+import { Position as Position4 } from "@xyflow/system";
+var NoisePerlinNodeTemplateFactory = class {
+  template = {
+    type: "noise-perlin" /* noisePerlin */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Perlin Noise",
+      frequency: 0.1,
+      lacunarity: 2,
+      octaves: 5,
+      persistence: 0.5,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position4.Left,
+        dataType: CoreHandleType2.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position4.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-ridgedmulti-template.ts
+import { CoreHandleType as CoreHandleType3 } from "@awesome-flow/core/abstract";
+import { Position as Position5 } from "@xyflow/system";
+var NoiseRidgedMultiNodeTemplateFactory = class {
+  template = {
+    type: "noise-ridged-multi" /* noiseRidgedMulti */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Ridged Multi Noise",
+      frequency: 0.1,
+      lacunarity: 2,
+      octaves: 6,
+      offset: 1,
+      gain: 2,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position5.Left,
+        dataType: CoreHandleType3.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position5.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-simplex-template.ts
+import {
+  CoreHandleType as CoreHandleType4
+} from "@awesome-flow/core/abstract";
+import { Position as Position6 } from "@xyflow/system";
+var NoiseSimplexNodeTemplateFactory = class {
+  template = {
+    type: "noise-simplex" /* noiseSimplex */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Simplex Noise"
+    },
+    handles: [
+      {
+        position: Position6.Left,
+        dataType: CoreHandleType4.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position6.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-spheres-template.ts
+import { CoreHandleType as CoreHandleType5 } from "@awesome-flow/core/abstract";
+import { Position as Position7 } from "@xyflow/system";
+var NoiseSpheresNodeTemplateFactory = class {
+  template = {
+    type: "noise-spheres" /* noiseSpheres */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Spheres Noise",
+      frequency: 0.1
+    },
+    handles: [
+      {
+        position: Position7.Left,
+        dataType: CoreHandleType5.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position7.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-voronoi-template.ts
+import { CoreHandleType as CoreHandleType6 } from "@awesome-flow/core/abstract";
+import { Position as Position8 } from "@xyflow/system";
+var NoiseVoronoiNodeTemplateFactory = class {
+  template = {
+    type: "noise-voronoi" /* noiseVoronoi */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Voronoi Noise",
+      frequency: 0.1,
+      displacement: 1,
+      distance: true,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position8.Left,
+        dataType: CoreHandleType6.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position8.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/position-const-template.ts
+import { Position as Position9 } from "@xyflow/system";
+var PositionConstNodeTemplateFactory = class {
+  template = {
+    type: "position" /* position */,
+    group: "Positions" /* positions */,
+    data: {
+      title: "Position Output",
+      position: { x: 0, y: 0, z: 0 }
+    },
+    handles: [
+      {
+        position: Position9.Right,
+        dataType: "position" /* position */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/position-grid-template.ts
+import { Position as Position10 } from "@xyflow/system";
+var PositionGridNodeTemplateFactory = class {
+  template = {
+    type: "grid" /* grid */,
+    group: "Positions" /* positions */,
+    data: {
+      title: "Grid Output",
+      center: { x: 0, y: 0, z: 0 },
+      radius: 1
+    },
+    handles: [
+      {
+        position: Position10.Right,
+        dataType: "position" /* position */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-normalize-template.ts
+import { IDGenerator } from "@awesome-flow/core/utils";
+import { Position as Position11 } from "@xyflow/system";
+var NoiseNormalizeNodeTemplateFactory = class {
+  template = {
+    id: IDGenerator.template(),
+    type: "noise-normalize" /* noiseNormalize */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Normalize Noise",
+      intervalStart: -1,
+      intervalEnd: 1
+    },
+    handles: [
+      {
+        position: Position11.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position11.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/output/noise-logger-template.ts
+import { Position as Position12 } from "@xyflow/system";
+var NoiseLoggerNodeTemplateFactory = class {
+  template = {
+    type: "noise-logger" /* noiseLogger */,
+    group: "Output" /* output */,
+    data: {
+      title: "Noise Logger"
+    },
+    handles: [
+      {
+        position: Position12.Left,
+        dataType: "noise" /* noise */,
+        connection: "target"
+      }
+    ]
+  };
+};
+
+// src/templates/output/noise-raw-texture-template.ts
+import { Position as Position13 } from "@xyflow/system";
+var NoiseRawTextureTemplateFactory = class {
+  template = {
+    type: "texture-data" /* textureData */,
+    group: "Output" /* output */,
+    data: {
+      title: "Texture Data"
+    },
+    handles: [
+      {
+        position: Position13.Left,
+        dataType: "noise" /* noise */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position13.Right,
+        dataType: "texture" /* texture */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/output/position-logger-template.ts
+import { Position as Position14 } from "@xyflow/system";
+var PositionLoggerNodeTemplateFactory = class {
+  template = {
+    type: "position-logger" /* positionLogger */,
+    group: "Positions" /* positions */,
+    data: {
+      title: "Position Logger"
+    },
+    handles: [
+      {
+        position: Position14.Left,
+        dataType: "position" /* position */,
+        connection: "target"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-combine-template.ts
+import { Position as Position15 } from "@xyflow/system";
+var NoiseCombineNodeTemplateFactory = class {
+  template = {
+    type: "noise-combiner" /* noiseCombine */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Combine Noise",
+      operation: "add" /* add */
+    },
+    handles: [
+      {
+        position: Position15.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 2
+      },
+      {
+        position: Position15.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-clamp-template.ts
+import { Position as Position16 } from "@xyflow/system";
+var NoiseClampNodeTemplateFactory = class {
+  template = {
+    type: "noise-clamp" /* noiseClamp */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Clamp Noise",
+      lowerBound: -1,
+      upperBound: 1
+    },
+    handles: [
+      {
+        position: Position16.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position16.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-abs-template.ts
+import { Position as Position17 } from "@xyflow/system";
+var NoiseAbsNodeTemplateFactory = class {
+  template = {
+    type: "noise-abs" /* noiseAbs */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Abs Noise"
+    },
+    handles: [
+      {
+        position: Position17.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position17.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/output/noise-output-template.ts
+import { Position as Position18 } from "@xyflow/system";
+var NoiseOutputNodeTemplateFactory = class {
+  template = {
+    type: "noise-output" /* noiseOutput */,
+    group: "Output" /* output */,
+    data: {
+      title: "Noise Output"
+    },
+    handles: [
+      {
+        position: Position18.Left,
+        dataType: "position" /* position */,
+        connection: "target"
+      },
+      {
+        position: Position18.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position18.Right,
+        dataType: "noise" /* noise */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-curve-template.ts
+import { CoreHandleType as CoreHandleType7 } from "@awesome-flow/core/abstract";
+import { Position as Position19 } from "@xyflow/system";
+var NoiseCurveNodeTemplateFactory = class {
+  template = {
+    type: "noise-curve" /* noiseCurve */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Noise Curve",
+      points: []
+    },
+    handles: [
+      {
+        position: Position19.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position19.Left,
+        dataType: CoreHandleType7.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position19.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-exponent-template.ts
+import { Position as Position20 } from "@xyflow/system";
+var NoiseExponentNodeTemplateFactory = class {
+  template = {
+    type: "noise-exponent" /* noiseExponent */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Noise Exponent",
+      exponent: 1
+    },
+    handles: [
+      {
+        position: Position20.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position20.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-invert-template.ts
+import { Position as Position21 } from "@xyflow/system";
+var NoiseInvertNodeTemplateFactory = class {
+  template = {
+    type: "noise-invert" /* noiseInvert */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Invert Noise"
+    },
+    handles: [
+      {
+        position: Position21.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position21.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-scalebias-template.ts
+import { Position as Position22 } from "@xyflow/system";
+var NoiseScaleBiasNodeTemplateFactory = class {
+  template = {
+    type: "noise-scale-bias" /* noiseScaleBias */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Scale/Bias Noise",
+      scale: 1,
+      bias: 0
+    },
+    handles: [
+      {
+        position: Position22.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position22.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-terrace-template.ts
+import { Position as Position23 } from "@xyflow/system";
+var NoiseTerraceNodeTemplateFactory = class {
+  template = {
+    type: "noise-terrace" /* noiseTerrace */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Noise Terrace",
+      points: []
+    },
+    handles: [
+      {
+        position: Position23.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position23.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/selectors/noise-blend-template.ts
+import { Position as Position24 } from "@xyflow/system";
+var NoiseBlendNodeTemplateFactory = class {
+  template = {
+    type: "noise-blend" /* noiseBlend */,
+    group: "Noise Selectors" /* noiseSelectors */,
+    data: {
+      title: "Noise Blend"
+    },
+    handles: [
+      {
+        position: Position24.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Modules",
+        dataId: "source" /* source */,
+        maxConnections: 2,
+        minConnections: 2
+      },
+      {
+        position: Position24.Left,
+        dataType: "module" /* module */,
+        dataId: "control" /* control */,
+        connection: "target",
+        label: "Control Module",
+        maxConnections: 1
+      },
+      {
+        position: Position24.Right,
+        dataType: "module" /* module */,
+        dataId: "output" /* output */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/selectors/noise-select-template.ts
+import { Position as Position25 } from "@xyflow/system";
+var NoiseSelectNodeTemplateFactory = class {
+  template = {
+    type: "noise-select" /* noiseSelect */,
+    group: "Noise Selectors" /* noiseSelectors */,
+    data: {
+      title: "Noise Select",
+      edgeFalloff: 0,
+      lowerBound: -1,
+      upperBound: 1
+    },
+    handles: [
+      {
+        position: Position25.Left,
+        dataType: "module" /* module */,
+        dataId: "source" /* source */,
+        connection: "target",
+        label: "Source Modules",
+        maxConnections: 2,
+        minConnections: 2
+      },
+      {
+        position: Position25.Left,
+        dataType: "module" /* module */,
+        dataId: "control" /* control */,
+        connection: "target",
+        label: "Control Module",
+        maxConnections: 1
+      },
+      {
+        position: Position25.Right,
+        dataType: "module" /* module */,
+        dataId: "output" /* output */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-displace-template.ts
+import { Position as Position26 } from "@xyflow/system";
+var NoiseDisplaceNodeTemplateFactory = class {
+  template = {
+    type: "noise-displace" /* noiseDisplace */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Displace"
+    },
+    handles: [
+      {
+        position: Position26.Left,
+        connection: "target",
+        label: "Source Module",
+        dataType: "module" /* module */,
+        dataId: "source" /* sourceModule */,
+        maxConnections: 1
+      },
+      {
+        position: Position26.Left,
+        connection: "target",
+        label: "X Module",
+        dataType: "module" /* module */,
+        dataId: "x-module" /* xModule */,
+        maxConnections: 1
+      },
+      {
+        position: Position26.Left,
+        connection: "target",
+        label: "Y Module",
+        dataType: "module" /* module */,
+        dataId: "y-module" /* yModule */,
+        maxConnections: 1
+      },
+      {
+        position: Position26.Left,
+        connection: "target",
+        label: "Z Module",
+        dataType: "module" /* module */,
+        dataId: "z-module" /* zModule */,
+        maxConnections: 1
+      },
+      {
+        position: Position26.Right,
+        dataType: "module" /* module */,
+        dataId: "output" /* output */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-rotate-point-template.ts
+import { Position as Position27 } from "@xyflow/system";
+var NoiseRotatePointNodeTemplateFactory = class {
+  template = {
+    type: "noise-rotate-point" /* noiseRotatePoint */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Rotate Point",
+      xAngle: 0,
+      yAngle: 0,
+      zAngle: 0
+    },
+    handles: [
+      {
+        position: Position27.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: Position27.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-scale-point-template.ts
+import { Position as Position28 } from "@xyflow/system";
+var NoiseScalePointNodeTemplateFactory = class {
+  template = {
+    type: "noise-scale-point" /* noiseScalePoint */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Scale Point",
+      xScale: 1,
+      yScale: 1,
+      zScale: 1
+    },
+    handles: [
+      {
+        position: Position28.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: Position28.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-translate-point-template.ts
+import { Position as Position29 } from "@xyflow/system";
+var NoiseTranslatePointNodeTemplateFactory = class {
+  template = {
+    type: "noise-translate-point" /* noiseTranslatePoint */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Translate Point",
+      translateX: 0,
+      translateY: 0,
+      translateZ: 0
+    },
+    handles: [
+      {
+        position: Position29.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: Position29.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-turbulence-template.ts
+import { CoreHandleType as CoreHandleType8 } from "@awesome-flow/core/abstract";
+import { Position as Position30 } from "@xyflow/system";
+var NoiseTurbulenceNodeTemplateFactory = class {
+  template = {
+    type: "noise-turbulence" /* noiseTurbulence */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Turbulence",
+      frequency: 1,
+      power: 1,
+      roughness: 1,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position30.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: Position30.Left,
+        dataType: CoreHandleType8.variableProperty,
+        label: "Variable Properties",
+        connection: "target"
+      },
+      {
+        position: Position30.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-billow-template.ts
+import { CoreHandleType as CoreHandleType9 } from "@awesome-flow/core/abstract";
+import { IDGenerator as IDGenerator2 } from "@awesome-flow/core/utils";
+import { Position as Position31 } from "@xyflow/system";
+var NoiseBillowNodeTemplateFactory = class {
+  template = {
+    id: IDGenerator2.template(),
+    type: "noise-billow" /* noiseBillow */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Billow Noise",
+      frequency: 0.1,
+      lacunarity: 2,
+      octaves: 5,
+      persistence: 0.5,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position31.Left,
+        dataType: CoreHandleType9.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position31.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/groups/module-group-template.ts
+import {
+  CoreTemplateGroup
+} from "@awesome-flow/core/abstract";
+import { IDGenerator as IDGenerator3 } from "@awesome-flow/core/utils";
+import { Position as Position32 } from "@xyflow/system";
+var ModuleGroupNodeTemplateFactory = class {
+  template = {
+    id: IDGenerator3.template(),
+    type: "group-module" /* groupModule */,
+    group: CoreTemplateGroup.groups,
+    data: {
+      title: "Modules Group",
+      isGroup: true,
+      initialSize: {
+        width: 300,
+        height: 200
+      },
+      collapsedSize: {
+        width: 300,
+        height: 80
+      }
+    },
+    handles: [
+      {
+        position: Position32.Bottom,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1,
+        hideOnCollapse: true
+      },
+      {
+        position: Position32.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/abstract/node-types.ts
+var noiseNodeTemplates = {
+  ["noise-output" /* noiseOutput */]: new NoiseOutputNodeTemplateFactory(),
+  ["noise-simplex" /* noiseSimplex */]: new NoiseSimplexNodeTemplateFactory(),
+  ["noise-billow" /* noiseBillow */]: new NoiseBillowNodeTemplateFactory(),
+  ["noise-checkerboard" /* noiseCheckerboard */]: new NoiseCheckerboardNodeTemplateFactory(),
+  ["noise-normalize" /* noiseNormalize */]: new NoiseNormalizeNodeTemplateFactory(),
+  ["noise-logger" /* noiseLogger */]: new NoiseLoggerNodeTemplateFactory(),
+  ["noise-constant" /* noiseConst */]: new NoiseConstNodeTemplateFactory(),
+  ["position" /* position */]: new PositionConstNodeTemplateFactory(),
+  ["position-logger" /* positionLogger */]: new PositionLoggerNodeTemplateFactory(),
+  ["grid" /* grid */]: new PositionGridNodeTemplateFactory(),
+  ["texture-data" /* textureData */]: new NoiseRawTextureTemplateFactory(),
+  ["noise-cylinders" /* noiseCylinders */]: new NoiseCylindersNodeTemplateFactory(),
+  ["noise-perlin" /* noisePerlin */]: new NoisePerlinNodeTemplateFactory(),
+  ["noise-ridged-multi" /* noiseRidgedMulti */]: new NoiseRidgedMultiNodeTemplateFactory(),
+  ["noise-spheres" /* noiseSpheres */]: new NoiseSpheresNodeTemplateFactory(),
+  ["noise-voronoi" /* noiseVoronoi */]: new NoiseVoronoiNodeTemplateFactory(),
+  ["noise-combiner" /* noiseCombine */]: new NoiseCombineNodeTemplateFactory(),
+  ["noise-clamp" /* noiseClamp */]: new NoiseClampNodeTemplateFactory(),
+  ["noise-abs" /* noiseAbs */]: new NoiseAbsNodeTemplateFactory(),
+  ["noise-curve" /* noiseCurve */]: new NoiseCurveNodeTemplateFactory(),
+  ["noise-exponent" /* noiseExponent */]: new NoiseExponentNodeTemplateFactory(),
+  ["noise-invert" /* noiseInvert */]: new NoiseInvertNodeTemplateFactory(),
+  ["noise-scale-bias" /* noiseScaleBias */]: new NoiseScaleBiasNodeTemplateFactory(),
+  ["noise-terrace" /* noiseTerrace */]: new NoiseTerraceNodeTemplateFactory(),
+  ["noise-blend" /* noiseBlend */]: new NoiseBlendNodeTemplateFactory(),
+  ["noise-select" /* noiseSelect */]: new NoiseSelectNodeTemplateFactory(),
+  ["noise-displace" /* noiseDisplace */]: new NoiseDisplaceNodeTemplateFactory(),
+  ["noise-rotate-point" /* noiseRotatePoint */]: new NoiseRotatePointNodeTemplateFactory(),
+  ["noise-scale-point" /* noiseScalePoint */]: new NoiseScalePointNodeTemplateFactory(),
+  ["noise-translate-point" /* noiseTranslatePoint */]: new NoiseTranslatePointNodeTemplateFactory(),
+  ["noise-turbulence" /* noiseTurbulence */]: new NoiseTurbulenceNodeTemplateFactory(),
+  ["group-module" /* groupModule */]: new ModuleGroupNodeTemplateFactory()
+};
+
+// src/nodes/output/noise-output-node.tsx
+import { jsx as jsx32, jsxs as jsxs28 } from "react/jsx-runtime";
+function NoiseOutputNode({ id, selected, data, type }) {
+  const [size, setSize] = useState20(0);
+  const updateComputedData = useUpdateNodeComputedData30();
+  const onDataUpdated = useCallback21(
+    (handleData) => {
+      const incomingPositions = handleData["position" /* position */];
+      const incomingModule = handleData["module" /* module */];
+      if (incomingPositions?.length && incomingModule?.length && incomingModule[0]?.module) {
+        const { module } = incomingModule[0];
+        const noise = [];
+        for (const input of incomingPositions) {
+          for (const position of input.positions) {
+            const value = module.getValue(position.x, position.y, position.z);
+            noise.push({
+              position,
+              value
+            });
+          }
+        }
+        updateComputedData(id, { noise, module });
+        setSize(noise.length);
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs28(NodeContainer32, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx32(
+      HandlesIncomingDataStatus4,
+      {
+        nodeId: id,
+        handles: data.handles,
+        handleKey: "dataType",
+        onDataUpdated,
+        type: "target",
+        resetComputedData: true
+      }
+    ),
+    /* @__PURE__ */ jsxs28(Text3, { mt: 5, children: [
+      "Noise points: ",
+      size
+    ] }),
+    /* @__PURE__ */ jsx32(NodeTrackConnections27, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_output_node_default = NoiseOutputNode;
 export {
-  node_module_group_default as ModuleGroupNode,
+  module_group_node_default as ModuleGroupNode,
   noise_abs_node_default as NoiseAbsNode,
   noise_billow_node_default as NoiseBillowNode,
   noise_blend_node_default as NoiseBlendNode,
@@ -2832,9 +3497,6 @@ export {
   noise_voronoi_node_default as NoiseVoronoiNode,
   position_const_node_default as PositionConstNode,
   position_grid_node_default as PositionGridNode,
-  positions_logger_node_default as PositionsLoggerNode,
-  variable_combine_node_default as VariableCombineNode,
-  variable_property_node_default as VariablePropertyNode,
-  variable_value_node_default as VariableValueNode
+  positions_logger_node_default as PositionsLoggerNode
 };
 //# sourceMappingURL=index.js.map