need to rebuild entire runtime fuck

.idea/.gitignore

···
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/VRCMacros-UI.iml

···
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="EMPTY_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src-tauri/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/src-tauri/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/modules.xml

···
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/VRCMacros-UI.iml" filepath="$PROJECT_DIR$/.idea/VRCMacros-UI.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

···
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package.json

···
     "@tauri-apps/plugin-clipboard-manager": "~2",
     "@tauri-apps/plugin-dialog": "~2.4.2",
     "@tauri-apps/plugin-opener": "^2.5.2",
+    "@tauri-apps/plugin-os": "~2",
     "animejs": "^4.2.2",
     "solid-js": "^1.9.10"
   },

pnpm-lock.yaml

···
       '@tauri-apps/plugin-opener':
         specifier: ^2.5.2
         version: 2.5.2
+      '@tauri-apps/plugin-os':
+        specifier: ~2
+        version: 2.3.2
       animejs:
         specifier: ^4.2.2
         version: 4.2.2
···
 
   '@tauri-apps/plugin-opener@2.5.2':
     resolution: {integrity: sha512-ei/yRRoCklWHImwpCcDK3VhNXx+QXM9793aQ64YxpqVF0BDuuIlXhZgiAkc15wnPVav+IbkYhmDJIv5R326Mew==}
+
+  '@tauri-apps/plugin-os@2.3.2':
+    resolution: {integrity: sha512-n+nXWeuSeF9wcEsSPmRnBEGrRgOy6jjkSU+UVCOV8YUGKb2erhDOxis7IqRXiRVHhY8XMKks00BJ0OAdkpf6+A==}
 
   '@types/animejs@3.1.13':
     resolution: {integrity: sha512-yWg9l1z7CAv/TKpty4/vupEh24jDGUZXv4r26StRkpUPQm04ztJaftgpto8vwdFs8SiTq6XfaPKCSI+wjzNMvQ==}
···
       '@tauri-apps/api': 2.9.0
 
   '@tauri-apps/plugin-opener@2.5.2':
+    dependencies:
+      '@tauri-apps/api': 2.9.0
+
+  '@tauri-apps/plugin-os@2.3.2':
     dependencies:
       '@tauri-apps/api': 2.9.0
 

src-tauri/Cargo.lock

···
  "anyhow",
  "crossbeam-channel",
  "dirs",
+ "enigo",
  "flate2",
  "serde",
  "serde_json",
···
  "tauri-plugin-clipboard-manager",
  "tauri-plugin-dialog",
  "tauri-plugin-opener",
+ "tauri-plugin-os",
  "tokio",
 ]
 
···
 ]
 
 [[package]]
+name = "core-graphics"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
+dependencies = [
+ "bitflags 2.10.0",
+ "core-foundation",
+ "core-graphics-types",
+ "foreign-types",
+ "libc",
+]
+
+[[package]]
 name = "core-graphics-types"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a3d8a32ae18130a3c84dd492d4215c3d913c3b07c6b63c2eb3eb7ff1101ab7bf"
+
+[[package]]
+name = "enigo"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71c6c56e50f7acae2906a0dcbb34529ca647e40421119ad5d12e7f8ba6e50010"
+dependencies = [
+ "core-foundation",
+ "core-graphics 0.25.0",
+ "foreign-types-shared",
+ "libc",
+ "log",
+ "nom 8.0.0",
+ "objc2 0.6.3",
+ "objc2-app-kit",
+ "objc2-foundation 0.3.2",
+ "windows",
+ "x11rb",
+ "xkbcommon",
+ "xkeysym",
+]
 
 [[package]]
 name = "enumflags2"
···
 checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
+name = "memmap2"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490"
+dependencies = [
+ "libc",
+]
+
+[[package]]
 name = "memoffset"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
 name = "num-conv"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "objc2-core-location"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009"
+dependencies = [
+ "objc2 0.6.3",
+ "objc2-foundation 0.3.2",
+]
+
+[[package]]
 name = "objc2-core-text"
 version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "bitflags 2.10.0",
  "objc2 0.6.3",
+ "objc2-core-foundation",
  "objc2-foundation 0.3.2",
 ]
 
···
 checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22"
 dependencies = [
  "bitflags 2.10.0",
+ "block2 0.6.2",
  "objc2 0.6.3",
+ "objc2-cloud-kit",
+ "objc2-core-data",
  "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-core-image",
+ "objc2-core-location",
+ "objc2-core-text",
+ "objc2-foundation 0.3.2",
+ "objc2-quartz-core 0.3.2",
+ "objc2-user-notifications",
+]
+
+[[package]]
+name = "objc2-user-notifications"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e"
+dependencies = [
+ "objc2 0.6.3",
  "objc2-foundation 0.3.2",
 ]
 
···
 dependencies = [
  "futures-core",
  "pin-project-lite",
+]
+
+[[package]]
+name = "os_info"
+version = "3.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c39b5918402d564846d5aba164c09a66cc88d232179dfd3e3c619a25a268392"
+dependencies = [
+ "android_system_properties",
+ "log",
+ "nix",
+ "objc2 0.6.3",
+ "objc2-foundation 0.3.2",
+ "objc2-ui-kit",
+ "serde",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
 dependencies = [
  "bytemuck",
  "cfg_aliases",
- "core-graphics",
+ "core-graphics 0.24.0",
  "foreign-types",
  "js-sys",
  "log",
···
 ]
 
 [[package]]
+name = "sys-locale"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eab9a99a024a169fe8a903cf9d4a3b3601109bcc13bd9e3c6fff259138626c4"
+dependencies = [
+ "libc",
+]
+
+[[package]]
 name = "system-deps"
 version = "6.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "bitflags 2.10.0",
  "block2 0.6.2",
  "core-foundation",
- "core-graphics",
+ "core-graphics 0.24.0",
  "crossbeam-channel",
  "dispatch",
  "dlopen2",
···
 ]
 
 [[package]]
+name = "tauri-plugin-os"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8f08346c8deb39e96f86973da0e2d76cbb933d7ac9b750f6dc4daf955a6f997"
+dependencies = [
+ "gethostname",
+ "log",
+ "os_info",
+ "serde",
+ "serde_json",
+ "serialize-to-javascript",
+ "sys-locale",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.17",
+]
+
+[[package]]
 name = "tauri-runtime"
 version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "52fac5f7d176f7f7f7e827299ead28ef98de642c5d93a97e0cd0816d17557f19"
 dependencies = [
  "memchr",
- "nom",
+ "nom 7.1.3",
  "petgraph",
 ]
 
···
 version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
+
+[[package]]
+name = "xkbcommon"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a974f48060a14e95705c01f24ad9c3345022f4d97441b8a36beb7ed5c4a02d"
+dependencies = [
+ "libc",
+ "memmap2",
+ "xkeysym",
+]
+
+[[package]]
+name = "xkeysym"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56"
 
 [[package]]
 name = "yoke"

src-tauri/Cargo.toml

···
 tauri-plugin-dialog = "2"
 crossbeam-channel = "0.5"
 tauri-plugin-clipboard-manager = "2"
+tauri-plugin-os = "2"
+
+[target.'cfg(windows)'.dependencies]
+enigo = { version = "0.6.1" }
 

src-tauri/capabilities/default.json

···
     "opener:default",
     "dialog:default",
     "clipboard-manager:allow-read-text",
-    "clipboard-manager:allow-write-text"
+    "clipboard-manager:allow-write-text",
+    "os:default"
   ]
 }

src-tauri/src/lib.rs

···
   let (runtime_sender, runtime_receiver) = bounded(1024);
 
   tauri::Builder::default()
+    .plugin(tauri_plugin_os::init())
     .plugin(tauri_plugin_clipboard_manager::init())
     .plugin(tauri_plugin_dialog::init())
     .plugin(tauri_plugin_opener::init())

src-tauri/src/runtime/nodes.rs

···
-use std::collections::HashMap;
+use std::{
+  collections::HashMap,
+  sync::{Arc, Mutex},
+};
+
+#[cfg(target_os = "windows")]
+use enigo::Enigo;
 
 use crate::{
   runtime::nodes::{
     conditional::{
       ifequal::ConditionalIfEqual, iffalse::ConditionalIfFalse, iftrue::ConditionalIfTrue,
-    },
-    debug::Debug,
-    oscactions::sendchatbox::OSCActionsSendChatbox,
-    osctrigger::OSCTrigger,
-    statics::{float::StaticFloat, int::StaticInt, string::StaticString},
+    }, debug::Debug, oscactions::sendchatbox::OSCActionsSendChatbox, osctrigger::OSCTrigger, shell::ShellCommand, statics::{float::StaticFloat, int::StaticInt, string::StaticString}
   },
   structs::{nodes::Node, parameter_types::ParameterType},
 };
+
+#[cfg(target_os = "windows")]
+use crate::runtime::nodes::press_key::PressKey;
 
 mod conditional;
 mod debug;
 mod oscactions;
 mod osctrigger;
 mod statics;
+mod shell;
+
+#[cfg(target_os = "windows")]
+mod press_key;
 
 pub struct RuntimeNodeTree {
   pub nodes: HashMap<String, Box<dyn RuntimeNode>>,
···
 unsafe impl Send for RuntimeNodeTree {}
 
 impl RuntimeNodeTree {
-  pub fn from(tree: Vec<Node>) -> Self {
+  pub fn from(tree: Vec<Node>, #[cfg(target_os = "windows")] enigo: Arc<Mutex<Enigo>>) -> Self {
     let mut runtime_nodes: HashMap<String, Box<dyn RuntimeNode>> = HashMap::new();
     for node in tree {
       match node.type_id.as_str() {
···
         "debug" => {
           runtime_nodes.insert(node.id.clone(), Debug::new(node));
         }
+
+        #[cfg(target_os = "windows")]
+        "presskey" => {
+          runtime_nodes.insert(node.id.clone(), PressKey::new(node, enigo.clone()));
+        }
+
+        "shellcommand" => {
+          runtime_nodes.insert(node.id.clone(), ShellCommand::new(node));
+        }
+
         _ => {}
       }
     }

src-tauri/src/runtime/nodes/press_key.rs

···
+use std::sync::{Arc, Mutex};
+
+use enigo::{Direction, Enigo, Key, Keyboard};
+
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
+
+pub struct PressKey {
+  key: Option<char>,
+  enigo: Arc<Mutex<Enigo>>,
+}
+
+impl PressKey {
+  pub fn new(node: Node, enigo: Arc<Mutex<Enigo>>) -> Box<Self> {
+    let value = &node.statics[0].value;
+
+    Box::new(Self {
+      enigo,
+      key: if value.is_null() {
+        None
+      } else {
+        let string = value.as_str().unwrap().to_owned();
+
+        if string.len() == 1 {
+          Some(string.chars().nth(0).unwrap())
+        } else {
+          None
+        }
+      },
+    })
+  }
+}
+
+impl RuntimeNode for PressKey {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
+    vec![]
+  }
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    Some(vec![])
+  }
+
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
+    if self.key.is_some() {
+      let mut enigo = self.enigo.lock().unwrap();
+      enigo.key(Key::MediaPlayPause, Direction::Click).unwrap();
+    }
+
+    None
+  }
+
+  fn update_arg(&mut self, _: usize, _: ParameterType) -> bool {
+    false
+  }
+
+  fn is_entrypoint(&self) -> bool {
+    false
+  }
+}

src-tauri/src/runtime/nodes/shell.rs

···
+use std::process::Command;
+
+use crate::{
+  runtime::nodes::RuntimeNode,
+  structs::{nodes::Node, parameter_types::ParameterType},
+};
+
+pub struct ShellCommand {
+  cmd: String
+}
+
+impl ShellCommand {
+  pub fn new(node: Node) -> Box<Self> {
+    Box::new(Self {
+      cmd: "".to_owned()
+    })
+  }
+}
+
+impl RuntimeNode for ShellCommand {
+  fn outputs(&self) -> Vec<Vec<(String, isize, isize)>> {
+    vec![]
+  }
+  fn execute_dry(&mut self, _: &Vec<ParameterType>) -> Option<Vec<ParameterType>> {
+    Some(vec![])
+  }
+
+  fn execute(&mut self) -> Option<Vec<ParameterType>> {
+    dbg!(&self.cmd);
+
+    if self.cmd != ""{
+      let mut split_cmd = self.cmd.split(" ");
+
+      let mut cmd = Command::new(split_cmd.nth(0).unwrap());
+      if split_cmd.clone().count() > 0{ cmd.args(split_cmd); }
+
+      let child = cmd.spawn().unwrap();
+      let output = child.wait_with_output().unwrap();
+
+      self.cmd = "".to_owned();
+
+      Some(vec![
+        ParameterType::Flow(true),
+        ParameterType::String(str::from_utf8(&output.stdout).unwrap().to_owned())
+      ])
+    } else{
+      None
+    }
+  }
+
+  fn update_arg(&mut self, index: usize, arg: ParameterType) -> bool {
+    if index == 1{
+      if let ParameterType::String(cmd) = arg {
+        self.cmd = cmd;
+      }
+    }
+
+    false
+  }
+
+  fn is_entrypoint(&self) -> bool {
+    false
+  }
+}

src-tauri/src/setup.rs

···
 use crossbeam_channel::{bounded, Receiver};
-use std::{collections::HashMap, fs::File, io::Read, sync::Mutex};
+use std::{
+  collections::HashMap,
+  fs::File,
+  io::Read,
+  sync::{Arc, Mutex},
+};
 
 use flate2::read::GzDecoder;
 use serde_json::{Map, Value};
···
     }
   });
 
-  // TODO: Run tabs in seperate threads
+  // TODO: Run tabs in seperate threads (really not looking forward to this... thanks rust)
   // TODO: Support multiple flow inputs on a node
 
   tokio::spawn(async move {
     let mut tabs: HashMap<String, RuntimeNodeTree> = HashMap::new();
+
+    #[cfg(target_os = "windows")]
+    let enigo = Arc::new(Mutex::new(Enigo::new(&Settings::default()).unwrap()));
 
     loop {
       let cmd = runtime_receiver.recv().unwrap();
···
         }
 
         RuntimeCommand::AddTab(graph, id) => {
+          #[cfg(target_os = "windows")]
+          tabs.insert(id, RuntimeNodeTree::from(graph, enigo.clone()));
+
+          #[cfg(target_os = "linux")]
           tabs.insert(id, RuntimeNodeTree::from(graph));
         }
         RuntimeCommand::RemoveTab(id) => {

src/Mangers/NodeManager.tsx

···
 import { NodesByID } from "../Nodes/Nodes";
 import { save } from "@tauri-apps/plugin-dialog";
 import { ConfirmationManager } from "./ConfirmationManager";
+import { platform } from "@tauri-apps/plugin-os";
 
 export interface TabHashMap {
   [details: string] : Tab;
···
           graph: tab[1][0]
         }));
       };
+
+      this.UpdateConfig();
     });
 
     listen('prompt_to_close', async _ => {
···
     invoke('save_graph', { graph: JSON.stringify({
       tab_name: tab.name,
       version: await getVersion(),
+      platform: platform(),
       graph: nodesToSave
     }), path });
   }

src/Nodes/Conditional.tsx

···
 import { NodeConditionalIfFalse } from "./Conditional/IfFalse";
 
 export let NodeConditional: NodeDefinition = {
+  os: 'any',
+
   isSingle: false,
   name: 'Conditional',
   items: [

src/Nodes/Conditional/IfEqual.tsx

···
 import { NodeDefinition } from "../Nodes";
 
 export let NodeConditionalIfEqual: NodeDefinition = {
+  os: 'any',
+
   isSingle: true,
   name: 'If Equal',
   typeId: 'ifequal',

src/Nodes/Conditional/IfFalse.tsx

···
 import { NodeDefinition } from "../Nodes";
 
 export let NodeConditionalIfFalse: NodeDefinition = {
+  os: 'any',
+
   isSingle: true,
   name: 'If False',
   typeId: 'iffalse',
 
   w: 220,
-  h: 150,
+  h: 120,
 
   statics: [{
     type: NodeType.Label,

src/Nodes/Conditional/IfTrue.tsx

···
 import { NodeDefinition } from "../Nodes";
 
 export let NodeConditionalIfTrue: NodeDefinition = {
+  os: 'any',
+
   isSingle: true,
   name: 'If True',
   typeId: 'iftrue',
 
   w: 220,
-  h: 150,
+  h: 120,
 
   statics: [{
     type: NodeType.Label,

src/Nodes/Debug.tsx

···
 import { NodeDefinition } from "./Nodes";
 
 export let NodeDebug: NodeDefinition = {
+  os: 'any',
+
   isSingle: true,
   name: 'Debug',
   typeId: 'debug',

src/Nodes/Nodes.tsx

···
 import { Node, NodeStatic, NodeType } from "../structs/node";
+import { platform } from '@tauri-apps/plugin-os';
 
 import { NodeConditional } from "./Conditional";
 import { NodeDebug } from "./Debug";
 import { NodeOSCActions } from "./OSCActions";
 import { NodeOSCTrigger } from "./OSCTrigger";
+import { NodePressKey } from "./PressKey";
 import { NodeStatics } from "./Statics";
+import { NodeShellCommand } from "./Shell";
 
 export interface NodeDefinition{
+  os: string,
   isSingle: boolean,
   name: string,
   typeId?: string,
···
 // TODO: (Node Additions) Voicemod integrations (win only)
 // TODO: (Node Additions) Executing shell commands? (probably need some kinda popup warning when these are imported about dangerous usage)
 
-export let Nodes: NodeDefinition[] = [
+export let Nodes: NodeDefinition[] = [];
+let nodes = [
   NodeOSCTrigger,
   NodeConditional,
   NodeStatics,
   NodeOSCActions,
-  NodeDebug
+  NodeDebug,
+  NodePressKey,
+  NodeShellCommand
 ]
+
+let os = platform();
+
+for (let i = 0; i < nodes.length; i++) {
+  let node = nodes[i];
+  if(node.os === 'any' || node.os === os)Nodes.push(node);
+}
 
 export let NodesByID: NodeDefinitionHashMap = {}
 

src/Nodes/OSCActions.tsx

···
 import { NodeOSCActionsSendChatbox } from "./OSCActions/Send Chatbox";
 
 export let NodeOSCActions: NodeDefinition = {
+  os: 'any',
+
   isSingle: false,
   name: 'OSC Actions',
   items: [

src/Nodes/OSCActions/Send Chatbox.tsx

···
 import { NodeDefinition } from "../Nodes";
 
 export let NodeOSCActionsSendChatbox: NodeDefinition = {
+  os: 'any',
+
   isSingle: true,
   name: 'Send Chatbox',
   typeId: 'oscsendchatbox',

src/Nodes/OSCTrigger.tsx

···
 import { NodeDefinition } from "./Nodes";
 
 export let NodeOSCTrigger: NodeDefinition = {
+  os: 'any',
+
   isSingle: true,
   name: 'OSC Trigger',
   typeId: 'osctrigger',

src/Nodes/PressKey.tsx

···
+import { Node, NodeType } from "../structs/node";
+import { NodeDefinition } from "./Nodes";
+
+export let NodePressKey: NodeDefinition = {
+  os: 'windows',
+
+  isSingle: true,
+  name: 'Press Key',
+  typeId: 'presskey',
+
+  w: 200,
+  h: 80,
+
+  statics: [
+    {
+      name: "Key",
+      type: NodeType.String,
+      value: ""
+    }
+  ],
+
+  inputs: [
+    {
+      name: "Flow",
+      type: NodeType.Flow,
+    }
+  ],
+
+  onStaticsUpdate: async ( _node: Node ) => {}
+};

src/Nodes/Shell.tsx

···
+import { Node, NodeType } from "../structs/node";
+import { NodeDefinition } from "./Nodes";
+
+export let NodeShellCommand: NodeDefinition = {
+  os: 'any',
+
+  isSingle: true,
+  name: 'Shell Command',
+  typeId: 'shellcommand',
+
+  w: 200,
+  h: 120,
+
+  statics: [],
+
+  inputs: [
+    {
+      name: "Flow",
+      type: NodeType.Flow,
+    },
+    {
+      name: "Command",
+      type: NodeType.String,
+    },
+  ],
+
+  outputs: [
+    {
+      name: "Flow",
+      type: NodeType.Flow,
+    },
+    {
+      name: "Output",
+      type: NodeType.String,
+    },
+  ],
+
+  onStaticsUpdate: async ( _node: Node ) => {}
+};

src/Nodes/Statics.tsx

···
 import { NodeStaticsString } from "./Statics/String";
 
 export let NodeStatics: NodeDefinition = {
+  os: 'any',
+
   isSingle: false,
   name: 'Statics',
   items: [

src/Nodes/Statics/Float.tsx

···
 import { NodeDefinition } from "../Nodes";
 
 export let NodeStaticsFloat: NodeDefinition = {
+  os: 'any',
+
   isSingle: true,
   name: 'Float',
   typeId: 'staticfloat',

src/Nodes/Statics/Int.tsx

···
 import { NodeDefinition } from "../Nodes";
 
 export let NodeStaticsInt: NodeDefinition = {
+  os: 'any',
+
   isSingle: true,
   name: 'Int',
   typeId: 'staticint',

src/Nodes/Statics/String.tsx

···
 import { NodeDefinition } from "../Nodes";
 
 export let NodeStaticsString: NodeDefinition = {
+  os: 'any',
+
   isSingle: true,
   name: 'String',
   typeId: 'staticstring',

src/components/SettingsMenu.css

···
 .settings-menu{
-  position: fixed;
-  z-index: 110;
-  top: 0;
-  left: 0;
-  width: 100vw;
-  height: 100vh;
-  background: rgba(0, 0, 0, 0.75);
-}
+   position: fixed;
+   z-index: 110;
+   top: 0;
+   left: 0;
+   width: 100vw;
+   height: 100vh;
+   background: rgba(0, 0, 0, 0.75);
+ }
 
 .settings-menu-inner{
   position: fixed;

vite.config.ts

···
 
 // https://vitejs.dev/config/
 export default defineConfig(async () => ({
-  plugins: [solid()],
+  plugins: [ solid() ],
 
   // Vite options tailored for Tauri development and only applied in `tauri dev` or `tauri build`
   //