wip

feat: some shit
feat: add debug node
2026-02-17 13:49:10 +01:00 · 2026-02-17 13:49:10 +01:00 · 2026-02-17 13:49:10 +01:00 · 2026-02-17 13:49:10 +01:00 · 2026-02-17 13:49:10 +01:00 · 2026-02-17 13:49:10 +01:00
62 changed files with 2996 additions and 745 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -0,0 +1,9 @@
+[target.wasm32-unknown-unknown]
+rustflags = [
+  "-C",
+  "link-arg=--import-memory",
+  "-C",
+  "link-arg=--initial-memory=67108864", # 64 MiB
+  "-C",
+  "link-arg=--max-memory=536870912", # 512 MiB
+]
--- a/.gitea/workflows/benchmark.yaml
+++ b/.gitea/workflows/benchmark.yaml
@@ -0,0 +1,59 @@
+name: 📊 Benchmark the Runtime
+
+on:
+  push:
+    branches: ["*"]
+  pull_request:
+    branches: ["*"]
+
+env:
+  PNPM_CACHE_FOLDER: .pnpm-store
+  CARGO_HOME: .cargo
+  CARGO_TARGET_DIR: target
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    container: git.max-richter.dev/max/nodarium-ci:bce06da456e3c008851ac006033cfff256015a47
+
+    steps:
+      - name: 📑 Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN }}
+
+      - name: 💾 Setup pnpm Cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.PNPM_CACHE_FOLDER }}
+          key: ${{ runner.os }}-pnpm-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+
+      - name: 🦀 Cache Cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: 📦 Install Dependencies
+        run: pnpm install --frozen-lockfile --store-dir ${{ env.PNPM_CACHE_FOLDER }}
+
+      - name: 🛠️Build Nodes
+        run: pnpm build:nodes
+
+      - name: 🏃 Execute Runtime
+        run: pnpm run --filter @nodarium/app bench
+
+      - name: 📤 Upload Benchmark Results
+        uses: actions/upload-artifact@v3
+        with:
+          name: benchmark-data
+          path: app/benchmark/out/
+          compression: 9
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,68 @@
+# v0.0.5 (2026-02-13)
+
+## Features
+
+- Implement debug node with full runtime integration, wildcard (`*`) inputs, variable-height nodes and parameters, and a quick-connect shortcut.
+- Add color-coded node sockets and edges to visually indicate data types.
+- Recursively merge `localState` with the initial state to safely handle outdated settings stored in `localStorage` when the settings schema changes.
+- Clamp the Add Menu to the viewport.
+- Add application favicon.
+- Consolidate all developer settings into a single **Advanced Mode** setting.
+
+## Fixes
+
+- Fix InputNumber arrow visibility in the light theme.
+- Correct changelog formatting issues.
+
+## Chores
+
+- Add `pnpm qa` pre-commit command.
+- Run linting and type checks before build in CI.
+- Sign release commits with a PGP key.
+- General formatting, lint/type cleanup, test snapshot updates, and `.gitignore` maintenance.
+
+---
+
+- [f16ba26](https://git.max-richter.dev/max/nodarium/commit/f16ba2601ff0e8f0f4454e24689499112a2a257a) fix(ci): still trying to get gpg to work
+- [cc6b832](https://git.max-richter.dev/max/nodarium/commit/cc6b832f1576356e5453ee4289b02f854152ff9a) fix(ci): trying to get gpg to work
+- [dd5fd5b](https://git.max-richter.dev/max/nodarium/commit/dd5fd5bf1715d371566bd40419b72ca05e63401e) fix(ci): better add updates to package.json
+- [38d0fff](https://git.max-richter.dev/max/nodarium/commit/38d0fffcf4ca0a346857c3658ccefdfcdf16e217) chore: update ci image
+- [bce06da](https://git.max-richter.dev/max/nodarium/commit/bce06da456e3c008851ac006033cfff256015a47) ci: add gpg-agent to ci image
+- [af585d5](https://git.max-richter.dev/max/nodarium/commit/af585d56ec825662961c8796226ed9d8cb900795) feat: use new ci image with gpg
+- [0aa73a2](https://git.max-richter.dev/max/nodarium/commit/0aa73a27c1f23bea177ecc66034f8e0384c29a8e) feat: install gpg in ci image
+- [c1ae702](https://git.max-richter.dev/max/nodarium/commit/c1ae70282cb5d58527180614a80823d80ca478c5) feat: add color to sockets
+- [4c7b03d](https://git.max-richter.dev/max/nodarium/commit/4c7b03dfb82174317d8ba01f4725af804201154d) feat: add gradient mesh line
+- [144e8cc](https://git.max-richter.dev/max/nodarium/commit/144e8cc797cfcc5a7a1fd9a0a2098dc99afb6170) fix: correctly highlight possible outputs
+- [12ff9c1](https://git.max-richter.dev/max/nodarium/commit/12ff9c151873d253ed2e54dcf56aa9c9c4716c7c) Merge pull request 'feat/debug-node' (#41) from feat/debug-node into main
+- [8d3ffe8](https://git.max-richter.dev/max/nodarium/commit/8d3ffe84ab9ca9e6d6d28333752e34da878fd3ea) Merge branch 'main' into feat/debug-node
+- [95ec93e](https://git.max-richter.dev/max/nodarium/commit/95ec93eeada9bf062e01e1e77b67b8f0343a51bf) feat: better handle ctrl+shift clicks and selections
+- [d39185e](https://git.max-richter.dev/max/nodarium/commit/d39185efafc360f49ab9437c0bad1f64665df167) feat: add "pnpm qa" command to check before commit
+- [81580cc](https://git.max-richter.dev/max/nodarium/commit/81580ccd8c1db30ce83433c4c4df84bd660d3460) fix: cleanup some type errors
+- [bf6f632](https://git.max-richter.dev/max/nodarium/commit/bf6f632d2772c3da812d5864c401f17e1aa8666a) feat: add shortcut to quick connect to debug
+- [e098be6](https://git.max-richter.dev/max/nodarium/commit/e098be60135f57cf863904a58489e032ed27e8b4) fix: also execute all nodes before debug node
+- [ec13850](https://git.max-richter.dev/max/nodarium/commit/ec13850e1c0ca5846da614d25887ff492cf8be04) fix: make debug node work with runtime
+- [15e08a8](https://git.max-richter.dev/max/nodarium/commit/15e08a816339bdf9de9ecb6a57a7defff42dbe8c) feat: implement debug node
+- [48cee58](https://git.max-richter.dev/max/nodarium/commit/48cee58ad337c1c6c59a0eb55bf9b5ecd16b99d0) chore: update test snapshots
+- [3235cae](https://git.max-richter.dev/max/nodarium/commit/3235cae9049e193c242b6091cee9f01e67ee850e) chore: fix lint and typecheck errors
+- [3f44072](https://git.max-richter.dev/max/nodarium/commit/3f440728fc8a94d59022bb545f418be049a1f1ba) feat: implement variable height for node shader
+- [da09f8b](https://git.max-richter.dev/max/nodarium/commit/da09f8ba1eda5ed347433d37064a3b4ab49e627e) refactor: move debug node into runtime
+- [ddc3b4c](https://git.max-richter.dev/max/nodarium/commit/ddc3b4ce357ef1c1e8066c0a52151713d0b6ed95) feat: allow variable height node parameters
+- [2690fc8](https://git.max-richter.dev/max/nodarium/commit/2690fc871291e73d3d028df9668e8fffb1e77476) chore: gitignore pnpm-store
+- [072ab90](https://git.max-richter.dev/max/nodarium/commit/072ab9063ba56df0673020eb639548f3a8601e04) feat: add initial debug node
+- [e23cad2](https://git.max-richter.dev/max/nodarium/commit/e23cad254d610e00f196b7fdb4532f36fd735a4b) feat: add "*" datatype for inputs for debug node
+- [5b5c63c](https://git.max-richter.dev/max/nodarium/commit/5b5c63c1a9c4ef757382bd4452149dc9777693ff) fix(ui): make arrows on inputnumber visible on lighttheme
+- [c9021f2](https://git.max-richter.dev/max/nodarium/commit/c9021f2383828f2e2b5594d125165bbc8f70b8e7) refactor: merge all dev settings into one setting
+- [9eecdd4](https://git.max-richter.dev/max/nodarium/commit/9eecdd4fb85dc60b8196101050334e26732c9a34) Merge pull request 'feat: merge localState recursively with initial' (#38) from feat/debug-node into main
+- [7e71a41](https://git.max-richter.dev/max/nodarium/commit/7e71a41e5229126d404f56598c624709961dbf3b) feat: merge localState recursively with initial
+- [07cd9e8](https://git.max-richter.dev/max/nodarium/commit/07cd9e84eb51bc02b7fed39c36cf83caba175ad7) feat: clamp AddMenu to viewport
+- [a31a49a](https://git.max-richter.dev/max/nodarium/commit/a31a49ad503d69f92f2491dd685729060ea49896) ci: lint and typecheck before build
+- [850d641](https://git.max-richter.dev/max/nodarium/commit/850d641a25cd0c781478c58c117feaf085bdbc62) chore: pnpm format
+- [ee5ca81](https://git.max-richter.dev/max/nodarium/commit/ee5ca817573b83cacfa3709e0ae88c6263bc39c1) ci: sign release commits with pgp key
+- [22a1183](https://git.max-richter.dev/max/nodarium/commit/22a11832b861ae8b44e2d374b55d12937ecab247) fix(ci): correctly format changelog
+- [b5ce572](https://git.max-richter.dev/max/nodarium/commit/b5ce5723fa4a35443df39a9096d0997f808f0b4f) chore: format favicon svg
+- [102130c](https://git.max-richter.dev/max/nodarium/commit/102130cc7777ceebcdb3de8466c90cef5b380111) feat: add favicon
+- [1668a2e](https://git.max-richter.dev/max/nodarium/commit/1668a2e6d59db071ab3da45204c2b7bfcd2150a2) chore: format changelog.md
+
 # v0.0.4 (2026-02-10)

 ## Features
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -24,6 +24,14 @@ dependencies = [
 "nodarium_utils",
 ]

+[[package]]
+name = "debug"
+version = "0.1.0"
+dependencies = [
+ "nodarium_macros",
+ "nodarium_utils",
+]
+
 [[package]]
 name = "float"
 version = "0.1.0"
--- a/README.md
+++ b/README.md
@@ -27,7 +27,6 @@ Currently this visual programming language is used to develop <https://nodes.max
 - [Node.js](https://nodejs.org/en/download)
 - [pnpm](https://pnpm.io/installation)
 - [rust](https://www.rust-lang.org/tools/install)
- wasm-pack

 ### Install dependencies

--- a/SHARED_MEMORY_REFACTOR_PLAN.md
+++ b/SHARED_MEMORY_REFACTOR_PLAN.md
@@ -0,0 +1,783 @@
+# Shared Memory Refactor Plan
+
+## Executive Summary
+
+Migrate to a single shared `WebAssembly.Memory` instance imported by all nodes using `--import-memory`. The `#[nodarium_execute]` macro writes the function's return value directly to shared memory at the specified offset.
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                        Shared WebAssembly.Memory                    │
+│  ┌───────────────────────────────────────────────────────────────┐  │
+│  │  [Node A output]  [Node B output]  [Node C output]  ...       │  │
+│  │  ┌────────────┐   ┌────────────┐   ┌────────────┐             │  │
+│  │  │ Vec<i32>   │   │ Vec<i32>   │   │ Vec<i32>   │             │  │
+│  │  │ 4 bytes    │   │ 12 bytes   │   │ 2KB        │             │  │
+│  │  └────────────┘   └────────────┘   └────────────┘             │  │
+│  │                                                               │  │
+│  │  offset: 0 ────────────────────────────────────────────────►  │  │
+│  └───────────────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────────────┘
+                                   ▲
+                                   │
+                                   │ import { memory } from "env"
+         ┌─────────────────────────┼─────────────────────────┐
+         │                         │                         │
+    ┌────┴────┐               ┌────┴────┐               ┌────┴────┐
+    │  Node A │               │  Node B │               │  Node C │
+    │  WASM   │               │  WASM   │               │  WASM   │
+    └─────────┘               └─────────┘               └─────────┘
+```
+
+## Phase 1: Compilation Configuration
+
+### 1.1 Cargo Config
+
+```toml
+# nodes/max/plantarium/box/.cargo/config.toml
+[build]
+rustflags = ["-C", "link-arg=--import-memory"]
+```
+
+Or globally in `Cargo.toml`:
+
+```toml
+[profile.release]
+rustflags = ["-C", "link-arg=--import-memory"]
+```
+
+### 1.2 Import Memory Semantics
+
+With `--import-memory`:
+
+- Nodes **import** memory from the host (not export their own)
+- All nodes receive the same `WebAssembly.Memory` instance
+- Memory is read/write accessible from all modules
+- No `memory.grow` needed (host manages allocation)
+
+## Phase 2: Macro Design
+
+### 2.1 Clean Node API
+
+```rust
+// input.json has 3 inputs: op_type, a, b
+nodarium_definition_file!("src/input.json");
+
+#[nodarium_execute]
+pub fn execute(op_type: *i32, a: *i32, b: *i32) -> Vec<i32> {
+    // Read inputs directly from shared memory
+    let op = unsafe { *op_type };
+    let a_val = f32::from_bits(unsafe { *a } as u32);
+    let b_val = f32::from_bits(unsafe { *b } as u32);
+
+    let result = match op {
+        0 => a_val + b_val,
+        1 => a_val - b_val,
+        2 => a_val * b_val,
+        3 => a_val / b_val,
+        _ => 0.0,
+    };
+
+    // Return Vec<i32>, macro handles writing to shared memory
+    vec![result.to_bits()]
+}
+```
+
+### 2.2 Macro Implementation
+
+```rust
+// packages/macros/src/lib.rs
+
+#[proc_macro_attribute]
+pub fn nodarium_execute(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input_fn = parse_macro_input!(item as syn::ItemFn);
+    let fn_name = &input_fn.sig.ident;
+
+    // Parse definition to get input count
+    let project_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let def: NodeDefinition = serde_json::from_str(&fs::read_to_string(
+        Path::new(&project_dir).join("src/input.json")
+    ).unwrap()).unwrap();
+
+    let input_count = def.inputs.as_ref().map(|i| i.len()).unwrap_or(0);
+
+    // Validate signature
+    validate_signature(&input_fn, input_count);
+
+    // Generate wrapper
+    generate_execute_wrapper(input_fn, fn_name, input_count)
+}
+
+fn validate_signature(fn_sig: &syn::Signature, expected_inputs: usize) {
+    let param_count = fn_sig.inputs.len();
+    if param_count != expected_inputs {
+        panic!(
+            "Execute function has {} parameters but definition has {} inputs\n\
+             Definition inputs: {:?}\n\
+             Expected signature:\n\
+             pub fn execute({}) -> Vec<i32>",
+            param_count,
+            expected_inputs,
+            def.inputs.as_ref().map(|i| i.keys().collect::<Vec<_>>()),
+            (0..expected_inputs)
+                .map(|i| format!("arg{}: *const i32", i))
+                .collect::<Vec<_>>()
+                .join(", ")
+        );
+    }
+
+    // Verify return type is Vec<i32>
+    match &fn_sig.output {
+        syn::ReturnType::Type(_, ty) => {
+            if !matches!(&**ty, syn::Type::Path(tp) if tp.path.is_ident("Vec")) {
+                panic!("Execute function must return Vec<i32>");
+            }
+        }
+        syn::ReturnType::Default => {
+            panic!("Execute function must return Vec<i32>");
+        }
+    }
+}
+
+fn generate_execute_wrapper(
+    input_fn: syn::ItemFn,
+    fn_name: &syn::Ident,
+    input_count: usize,
+) -> TokenStream {
+    let arg_names: Vec<_> = (0..input_count)
+        .map(|i| syn::Ident::new(&format!("arg{}", i), proc_macro2::Span::call_site()))
+        .collect();
+
+    let expanded = quote! {
+        #input_fn
+
+        #[no_mangle]
+        pub extern "C" fn execute(
+            output_pos: i32,
+            #( #arg_names: i32 ),*
+        ) -> i32 {
+            extern "C" {
+                fn __nodarium_log(ptr: *const u8, len: usize);
+                fn __nodarium_log_panic(ptr: *const u8, len: usize);
+            }
+
+            // Setup panic hook
+            static SET_HOOK: std::sync::Once = std::sync::Once::new();
+            SET_HOOK.call_once(|| {
+                std::panic::set_hook(Box::new(|info| {
+                    let msg = info.to_string();
+                    unsafe { __nodarium_log_panic(msg.as_ptr(), msg.len()); }
+                }));
+            });
+
+            // Call user function
+            let result = #fn_name(
+                #( #arg_names as *const i32 ),*
+            );
+
+            // Write result directly to shared memory at output_pos
+            let len_bytes = result.len() * 4;
+            unsafe {
+                let src = result.as_ptr() as *const u8;
+                let dst = output_pos as *mut u8;
+                dst.copy_from_nonoverlapping(src, len_bytes);
+            }
+
+            // Forget the Vec to prevent deallocation (data is in shared memory now)
+            core::mem::forget(result);
+
+            len_bytes as i32
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+```
+
+### 2.3 Generated Assembly
+
+The macro generates:
+
+```asm
+; Input: output_pos in register r0, arg0 in r1, arg1 in r2, arg2 in r3
+execute:
+    ; Call user function
+    bl    user_execute           ; returns pointer to Vec<i32> in r0
+
+    ; Calculate byte length
+    ldr   r4, [r0, #8]           ; Vec::len field
+    lsl   r4, r4, #2             ; len * 4 (i32 = 4 bytes)
+
+    ; Copy Vec data to shared memory at output_pos
+    ldr   r5, [r0, #0]           ; Vec::ptr field
+    ldr   r6, [r0, #4]           ; capacity (unused)
+
+    ; memcpy(dst=output_pos, src=r5, len=r4)
+    ; (implemented via copy_from_nonoverlapping)
+
+    ; Return length
+    mov   r0, r4
+    bx    lr
+```
+
+## Phase 3: Input Reading Helpers
+
+```rust
+// packages/utils/src/accessor.rs
+
+/// Read i32 from shared memory
+#[inline]
+pub unsafe fn read_i32(ptr: *const i32) -> i32 {
+    *ptr
+}
+
+/// Read f32 from shared memory (stored as i32 bits)
+#[inline]
+pub unsafe fn read_f32(ptr: *const i32) -> f32 {
+    f32::from_bits(*ptr as u32)
+}
+
+/// Read boolean from shared memory
+#[inline]
+pub unsafe fn read_bool(ptr: *const i32) -> bool {
+    *ptr != 0
+}
+
+/// Read vec3 (3 f32s) from shared memory
+#[inline]
+pub unsafe fn read_vec3(ptr: *const i32) -> [f32; 3] {
+    let p = ptr as *const f32;
+    [p.read(), p.add(1).read(), p.add(2).read()]
+}
+
+/// Read slice from shared memory
+#[inline]
+pub unsafe fn read_i32_slice(ptr: *const i32, len: usize) -> &[i32] {
+    std::slice::from_raw_parts(ptr, len)
+}
+
+/// Read f32 slice from shared memory
+#[inline]
+pub unsafe fn read_f32_slice(ptr: *const i32, len: usize) -> &[f32] {
+    std::slice::from_raw_parts(ptr as *const f32, len)
+}
+
+/// Read with default value
+#[inline]
+pub unsafe fn read_f32_default(ptr: *const i32, default: f32) -> f32 {
+    if ptr.is_null() { default } else { read_f32(ptr) }
+}
+
+#[inline]
+pub unsafe fn read_i32_default(ptr: *const i32, default: i32) -> i32 {
+    if ptr.is_null() { default } else { read_i32(ptr) }
+}
+```
+
+## Phase 4: Node Implementation Examples
+
+### 4.1 Math Node
+
+```rust
+// nodes/max/plantarium/math/src/lib.rs
+
+nodarium_definition_file!("src/input.json");
+
+#[nodarium_execute]
+pub fn execute(op_type: *const i32, a: *const i32, b: *const i32) -> Vec<i32> {
+    use nodarium_utils::{read_i32, read_f32};
+
+    let op = unsafe { read_i32(op_type) };
+    let a_val = unsafe { read_f32(a) };
+    let b_val = unsafe { read_f32(b) };
+
+    let result = match op {
+        0 => a_val + b_val,  // add
+        1 => a_val - b_val,  // subtract
+        2 => a_val * b_val,  // multiply
+        3 => a_val / b_val,  // divide
+        _ => 0.0,
+    };
+
+    vec![result.to_bits()]
+}
+```
+
+### 4.2 Vec3 Node
+
+```rust
+// nodes/max/plantarium/vec3/src/lib.rs
+
+nodarium_definition_file!("src/input.json");
+
+#[nodarium_execute]
+pub fn execute(x: *const i32, y: *const i32, z: *const i32) -> Vec<i32> {
+    use nodarium_utils::read_f32;
+
+    let x_val = unsafe { read_f32(x) };
+    let y_val = unsafe { read_f32(y) };
+    let z_val = unsafe { read_f32(z) };
+
+    vec![x_val.to_bits(), y_val.to_bits(), z_val.to_bits()]
+}
+```
+
+### 4.3 Box Node
+
+```rust
+// nodes/max/plantarium/box/src/lib.rs
+
+nodarium_definition_file!("src/input.json");
+
+#[nodarium_execute]
+pub fn execute(size: *const i32) -> Vec<i32> {
+    use nodarium_utils::{read_f32, encode_float, calculate_normals};
+
+    let size = unsafe { read_f32(size) };
+    let p = encode_float(size);
+    let n = encode_float(-size);
+
+    let mut cube_geometry = vec![
+        1,          // 1: geometry
+        8,          // 8 vertices
+        12,         // 12 faces
+
+        // Face indices
+        0, 1, 2, 0, 2, 3,
+        0, 3, 4, 4, 5, 0,
+        6, 1, 0, 5, 6, 0,
+        7, 2, 1, 6, 7, 1,
+        2, 7, 3, 3, 7, 4,
+        7, 6, 4, 4, 6, 5,
+
+        // Bottom plate
+        p, n, n, p, n, p, n, n, p, n, n, n,
+
+        // Top plate
+        n, p, n, p, p, n, p, p, p, n, p, p,
+
+        // Normals
+        0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+
+    calculate_normals(&mut cube_geometry);
+    cube_geometry
+}
+```
+
+### 4.4 Stem Node
+
+```rust
+// nodes/max/plantarium/stem/src/lib.rs
+
+nodarium_definition_file!("src/input.json");
+
+#[nodarium_execute]
+pub fn execute(
+    origin: *const i32,
+    amount: *const i32,
+    length: *const i32,
+    thickness: *const i32,
+    resolution: *const i32,
+) -> Vec<i32> {
+    use nodarium_utils::{
+        read_vec3, read_i32, read_f32,
+        geometry::{create_multiple_paths, wrap_multiple_paths},
+    };
+
+    let origin = unsafe { read_vec3(origin) };
+    let amount = unsafe { read_i32(amount) } as usize;
+    let length = unsafe { read_f32(length) };
+    let thickness = unsafe { read_f32(thickness) };
+    let resolution = unsafe { read_i32(resolution) } as usize;
+
+    let mut stem_data = create_multiple_paths(amount, resolution, 1);
+    let mut stems = wrap_multiple_paths(&mut stem_data);
+
+    for stem in stems.iter_mut() {
+        let points = stem.get_points_mut();
+        for (i, point) in points.iter_mut().enumerate() {
+            let t = i as f32 / (resolution as f32 - 1.0);
+            point.x = origin[0];
+            point.y = origin[1] + t * length;
+            point.z = origin[2];
+            point.w = thickness * (1.0 - t);
+        }
+    }
+
+    stem_data
+}
+```
+
+## Phase 5: Runtime Implementation
+
+```typescript
+// app/src/lib/runtime/memory-manager.ts
+
+export const SHARED_MEMORY = new WebAssembly.Memory({
+  initial: 1024, // 64MB initial
+  maximum: 4096, // 256MB maximum
+});
+
+export class MemoryManager {
+  private offset: number = 0;
+  private readonly start: number = 0;
+
+  reset() {
+    this.offset = this.start;
+  }
+
+  alloc(bytes: number): number {
+    const pos = this.offset;
+    this.offset += bytes;
+    return pos;
+  }
+
+  readInt32(pos: number): number {
+    return new Int32Array(SHARED_MEMORY.buffer)[pos / 4];
+  }
+
+  readFloat32(pos: number): number {
+    return new Float32Array(SHARED_MEMORY.buffer)[pos / 4];
+  }
+
+  readBytes(pos: number, length: number): Uint8Array {
+    return new Uint8Array(SHARED_MEMORY.buffer, pos, length);
+  }
+
+  getInt32View(): Int32Array {
+    return new Int32Array(SHARED_MEMORY.buffer);
+  }
+
+  getFloat32View(): Float32Array {
+    return new Float32Array(SHARED_MEMORY.buffer);
+  }
+
+  getRemaining(): number {
+    return SHARED_MEMORY.buffer.byteLength - this.offset;
+  }
+}
+```
+
+```typescript
+// app/src/lib/runtime/imports.ts
+
+import { SHARED_MEMORY } from "./memory-manager";
+
+export function createImportObject(nodeId: string): WebAssembly.Imports {
+  return {
+    env: {
+      // Import shared memory
+      memory: SHARED_MEMORY,
+
+      // Logging
+      __nodarium_log: (ptr: number, len: number) => {
+        const msg = new TextDecoder().decode(
+          new Uint8Array(SHARED_MEMORY.buffer, ptr, len),
+        );
+        console.log(`[${nodeId}] ${msg}`);
+      },
+
+      __nodarium_log_panic: (ptr: number, len: number) => {
+        const msg = new TextDecoder().decode(
+          new Uint8Array(SHARED_MEMORY.buffer, ptr, len),
+        );
+        console.error(`[${nodeId}] PANIC: ${msg}`);
+      },
+    },
+  };
+}
+```
+
+```typescript
+// app/src/lib/runtime/executor.ts
+
+import { SHARED_MEMORY } from "./memory-manager";
+import { createImportObject } from "./imports";
+
+export class SharedMemoryRuntimeExecutor implements RuntimeExecutor {
+  private memory: MemoryManager;
+  private results: Map<string, { pos: number; len: number }> = new Map();
+  private instances: Map<string, WebAssembly.Instance> = new Map();
+
+  constructor(private registry: NodeRegistry) {
+    this.memory = new MemoryManager();
+  }
+
+  async execute(graph: Graph, settings: Record<string, unknown>) {
+    this.memory.reset();
+    this.results.clear();
+
+    const [outputNode, nodes] = await this.addMetaData(graph);
+    const sortedNodes = nodes.sort((a, b) => b.depth - a.depth);
+
+    for (const node of sortedNodes) {
+      await this.executeNode(node, settings);
+    }
+
+    const result = this.results.get(outputNode.id);
+    const view = this.memory.getInt32View();
+    return view.subarray(result.pos / 4, result.pos / 4 + result.len / 4);
+  }
+
+  private async executeNode(
+    node: RuntimeNode,
+    settings: Record<string, unknown>,
+  ) {
+    const def = this.definitionMap.get(node.type)!;
+    const inputs = def.inputs || {};
+    const inputNames = Object.keys(inputs);
+
+    const outputSize = this.estimateOutputSize(def);
+    const outputPos = this.memory.alloc(outputSize);
+    const args: number[] = [outputPos];
+
+    for (const inputName of inputNames) {
+      const inputDef = inputs[inputName];
+      const inputNode = node.state.inputNodes[inputName];
+      if (inputNode) {
+        const parentResult = this.results.get(inputNode.id)!;
+        args.push(parentResult.pos);
+        continue;
+      }
+
+      const valuePos = this.memory.alloc(16);
+      this.writeValue(
+        valuePos,
+        inputDef,
+        node.props?.[inputName] ??
+          settings[inputDef.setting ?? ""] ??
+          inputDef.value,
+      );
+      args.push(valuePos);
+    }
+
+    let instance = this.instances.get(node.type);
+    if (!instance) {
+      instance = await this.instantiateNode(node.type);
+      this.instances.set(node.type, instance);
+    }
+
+    const writtenLen = instance.exports.execute(...args);
+    this.results.set(node.id, { pos: outputPos, len: writtenLen });
+  }
+
+  private writeValue(pos: number, inputDef: NodeInput, value: unknown) {
+    const view = this.memory.getFloat32View();
+    const intView = this.memory.getInt32View();
+
+    switch (inputDef.type) {
+      case "float":
+        view[pos / 4] = value as number;
+        break;
+      case "integer":
+      case "select":
+      case "seed":
+        intView[pos / 4] = value as number;
+        break;
+      case "boolean":
+        intView[pos / 4] = value ? 1 : 0;
+        break;
+      case "vec3":
+        const arr = value as number[];
+        view[pos / 4] = arr[0];
+        view[pos / 4 + 1] = arr[1];
+        view[pos / 4 + 2] = arr[2];
+        break;
+    }
+  }
+
+  private estimateOutputSize(def: NodeDefinition): number {
+    const sizes: Record<string, number> = {
+      float: 16,
+      integer: 16,
+      boolean: 16,
+      vec3: 16,
+      geometry: 8192,
+      path: 4096,
+    };
+    return sizes[def.outputs?.[0] || "float"] || 64;
+  }
+
+  private async instantiateNode(
+    nodeType: string,
+  ): Promise<WebAssembly.Instance> {
+    const wasmBytes = await this.fetchWasm(nodeType);
+    const module = await WebAssembly.compile(wasmBytes);
+    const importObject = createImportObject(nodeType);
+    return WebAssembly.instantiate(module, importObject);
+  }
+}
+```
+
+## Phase 7: Execution Flow Visualization
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                           Execution Timeline                                │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+Step 1: Setup
+  SHARED_MEMORY = new WebAssembly.Memory({ initial: 1024 })
+  memory.offset = 0
+
+Step 2: Execute Node A (math with 3 inputs)
+  outputPos = memory.alloc(16) = 0
+  args = [0, ptr_to_op_type, ptr_to_a, ptr_to_b]
+
+  Node A reads:
+    *ptr_to_op_type → op
+    *ptr_to_a → a
+    *ptr_to_b → b
+
+  Node A returns: vec![result.to_bits()]
+
+  Macro writes result directly to SHARED_MEMORY[0..4]
+  Returns: 4
+
+  results['A'] = { pos: 0, len: 4 }
+  memory.offset = 4
+
+Step 3: Execute Node B (stem with 5 inputs, input[0] from A)
+  outputPos = memory.alloc(4096) = 4
+  args = [4, results['A'].pos, ptr_to_amount, ptr_to_length, ...]
+
+  Node B reads:
+    *results['A'].pos → value from Node A
+    *ptr_to_amount → amount
+    ...
+
+  Node B returns: stem_data Vec<i32> (1000 elements = 4000 bytes)
+
+  Macro writes stem_data directly to SHARED_MEMORY[4..4004]
+  Returns: 4000
+
+  results['B'] = { pos: 4, len: 4000 }
+  memory.offset = 4004
+
+Step 4: Execute Node C (output, 1 input from B)
+  outputPos = memory.alloc(16) = 4004
+  args = [4004, results['B'].pos, results['B'].len]
+
+  Node C reads:
+    *results['B'].pos → stem geometry
+
+  Node C returns: vec![1] (identity)
+  Macro writes to SHARED_MEMORY[4004..4008]
+
+  results['C'] = { pos: 4004, len: 4 }
+
+Final: Return SHARED_MEMORY[4004..4008] as geometry result
+```
+
+## Phase 6: Memory Growth Strategy
+
+```typescript
+class MemoryManager {
+  alloc(bytes: number): number {
+    const required = this.offset + bytes;
+    const currentBytes = SHARED_MEMORY.buffer.byteLength;
+
+    if (required > currentBytes) {
+      const pagesNeeded = Math.ceil((required - currentBytes) / 65536);
+      const success = SHARED_MEMORY.grow(pagesNeeded);
+
+      if (!success) {
+        throw new Error(`Out of memory: need ${bytes} bytes`);
+      }
+
+      this.int32View = new Int32Array(SHARED_MEMORY.buffer);
+      this.float32View = new Float32Array(SHARED_MEMORY.buffer);
+    }
+
+    const pos = this.offset;
+    this.offset += bytes;
+    return pos;
+  }
+}
+```
+
+## Phase 8: Migration Checklist
+
+### Build Configuration
+
+- [ ] Add `--import-memory` to Rust flags in `Cargo.toml`
+- [ ] Ensure no nodes export memory
+
+### Runtime
+
+- [ ] Create `SHARED_MEMORY` instance
+- [ ] Implement `MemoryManager` with alloc/read/write
+- [ ] Create import object factory
+- [ ] Implement `SharedMemoryRuntimeExecutor`
+
+### Macro
+
+- [ ] Parse definition JSON
+- [ ] Validate function signature (N params, Vec<i32> return)
+- [ ] Generate wrapper that writes return value to `output_pos`
+- [ ] Add panic hook
+
+### Utilities
+
+- [ ] `read_i32(ptr: *const i32) -> i32`
+- [ ] `read_f32(ptr: *const i32) -> f32`
+- [ ] `read_bool(ptr: *const i32) -> bool`
+- [ ] `read_vec3(ptr: *const i32) -> [f32; 3]`
+- [ ] `read_i32_slice(ptr: *const i32, len: usize) -> &[i32]`
+
+### Nodes
+
+- [ ] `float`, `integer`, `boolean` nodes
+- [ ] `vec3` node
+- [ ] `math` node
+- [ ] `random` node
+- [ ] `box` node
+- [ ] `stem` node
+- [ ] `branch` node
+- [ ] `instance` node
+- [ ] `output` node
+
+## Phase 9: Before vs After
+
+### Before (per-node memory)
+
+```rust
+#[nodarium_execute]
+pub fn execute(input: &[i32]) -> Vec<i32> {
+    let args = split_args(input);
+    let a = evaluate_float(args[0]);
+    let b = evaluate_float(args[1]);
+    vec![(a + b).to_bits()]
+}
+```
+
+### After (shared memory)
+
+```rust
+#[nodarium_execute]
+pub fn execute(a: *const i32, b: *const i32) -> Vec<i32> {
+    use nodarium_utils::read_f32;
+    let a_val = unsafe { read_f32(a) };
+    let b_val = unsafe { read_f32(b) };
+    vec![(a_val + b_val).to_bits()]
+}
+```
+
+**Key differences:**
+
+- Parameters are input pointers, not a slice
+- Use `read_f32` helper instead of `evaluate_float`
+- Macro writes result directly to shared memory
+- All nodes share the same memory import
+
+## Phase 10: Benefits
+
+| Aspect            | Before         | After                |
+| ----------------- | -------------- | -------------------- |
+| Memory            | N × ~1MB heaps | 1 × 64-256MB shared  |
+| Cross-node access | Copy via JS    | Direct read          |
+| API               | `&[i32]` slice | `*const i32` pointer |
+| Validation        | Runtime        | Compile-time         |
--- a/SUMMARY.md
+++ b/SUMMARY.md
@@ -0,0 +1,227 @@
+# Nodarium - AI Coding Agent Summary
+
+## Project Overview
+
+Nodarium is a WebAssembly-based visual programming language used to build <https://nodes.max-richter.dev>, a procedural 3D plant modeling tool. The system allows users to create visual node graphs where each node is a compiled WebAssembly module.
+
+## Technology Stack
+
+**Frontend (SvelteKit):**
+
+- Framework: SvelteKit with Svelte 5
+- 3D Rendering: Three.js via Threlte
+- Styling: Tailwind CSS 4
+- Build Tool: Vite
+- State Management: Custom store-client package
+- WASM Integration: vite-plugin-wasm, comlink
+
+**Backend/Core (Rust/WASM):**
+
+- Language: Rust
+- Output: WebAssembly (wasm32-unknown-unknown target)
+- Build Tool: cargo
+- Procedural Macros: custom macros package
+
+**Package Management:**
+
+- Node packages: pnpm workspace (v10.28.1)
+- Rust packages: Cargo workspace
+
+## Directory Structure
+
+```
+nodarium/
+├── app/                          # SvelteKit web application
+│   ├── src/
+│   │   ├── lib/                  # App-specific components and utilities
+│   │   ├── routes/               # SvelteKit routes (pages)
+│   │   ├── app.css               # Global styles
+│   │   └── app.html              # HTML template
+│   ├── static/
+│   │   └── nodes/                # Compiled WASM node files served statically
+│   ├── package.json              # App dependencies
+│   ├── svelte.config.js          # SvelteKit configuration
+│   ├── vite.config.ts            # Vite configuration
+│   └── tsconfig.json             # TypeScript configuration
+│
+├── packages/                     # Shared workspace packages
+│   ├── ui/                       # Svelte UI component library (published as @nodarium/ui)
+│   │   ├── src/                  # UI components
+│   │   ├── static/               # Static assets for UI
+│   │   ├── dist/                 # Built output
+│   │   └── package.json
+│   ├── registry/                 # Node registry with IndexedDB persistence (@nodarium/registry)
+│   │   └── src/
+│   ├── types/                    # Shared TypeScript types (@nodarium/types)
+│   │   └── src/
+│   ├── utils/                    # Shared utilities (@nodarium/utils)
+│   │   └── src/
+│   └── macros/                   # Rust procedural macros for node development
+│
+├── nodes/                        # WebAssembly node packages (Rust)
+│   └── max/plantarium/           # Plantarium nodes namespace
+│       ├── box/                  # Box geometry node
+│       ├── branch/               # Branch generation node
+│       ├── float/                # Float value node
+│       ├── gravity/              # Gravity simulation node
+│       ├── instance/             # Geometry instancing node
+│       ├── math/                 # Math operations node
+│       ├── noise/                # Noise generation node
+│       ├── output/               # Output node for results
+│       ├── random/               # Random value node
+│       ├── rotate/               # Rotation transformation node
+│       ├── stem/                 # Stem geometry node
+│       ├── triangle/             # Triangle geometry node
+│       ├── vec3/                 # Vector3 manipulation node
+│       └── .template/            # Node template for creating new nodes
+│
+├── docs/                         # Documentation
+│   ├── ARCHITECTURE.md           # System architecture overview
+│   ├── DEVELOPING_NODES.md       # Guide for creating new nodes
+│   ├── NODE_DEFINITION.md        # Node definition schema
+│   └── PLANTARIUM.md             # Plantarium-specific documentation
+│
+├── Cargo.toml                    # Rust workspace configuration
+├── package.json                  # Root npm scripts
+├── pnpm-workspace.yaml           # pnpm workspace configuration
+├── pnpm-lock.yaml                # Locked dependency versions
+└── README.md                     # Project readme
+```
+
+## Node System Architecture
+
+### What is a Node?
+
+Nodes are WebAssembly modules that:
+
+- Have a unique ID (e.g., `max/plantarium/stem`)
+- Define inputs with types and default values
+- Define outputs they produce
+- Execute logic when called with arguments
+
+### Node Definition Schema
+
+Nodes are defined via `definition.json` embedded in each WASM module:
+
+```json
+{
+  "id": "namespace/category/node-name",
+  "outputs": ["geometry"],
+  "inputs": {
+    "height": { "type": "float", "value": 1.0 },
+    "radius": { "type": "float", "value": 0.1 }
+  }
+}
+```
+
+For now the outputs are limited to a single output.
+
+### Node Execution
+
+Nodes receive serialized arguments and return serialized outputs. The `nodarium_utils` Rust crate provides helpers for:
+
+- Parsing input arguments
+- Creating geometry data
+- Concatenating output vectors
+
+### Node Registration
+
+Nodes are:
+
+1. Compiled to WASM files in `target/wasm32-unknown-unknown/release/`
+2. Copied to `app/static/nodes/` for serving
+3. Registered in the browser via IndexedDB using the registry package
+
+## Key Dependencies
+
+**Frontend:**
+
+- `@sveltejs/kit` - Application framework
+- `@threlte/core` & `@threlte/extras` - Three.js Svelte integration
+- `three` - 3D graphics library
+- `tailwindcss` - CSS framework
+- `comlink` - WebWorker RPC
+- `idb` - IndexedDB wrapper
+- `wabt` - WebAssembly binary toolkit
+
+**Rust/WASM:**
+
+- Language: Rust (compiled with plain cargo)
+- Output: WebAssembly (wasm32-unknown-unknown target)
+- Generic WASM wrapper for language-agnostic node development
+- `glam` - Math library (Vec2, Vec3, Mat4, etc.)
+- `nodarium_macros` - Custom procedural macros
+- `nodarium_utils` - Shared node utilities
+
+## Build Commands
+
+From root directory:
+
+```bash
+# Install dependencies
+pnpm i
+
+# Build all WASM nodes (compiles Rust, copies to app/static)
+pnpm build:nodes
+
+# Build the app (builds UI library + SvelteKit app)
+pnpm build:app
+
+# Full build (nodes + app)
+pnpm build
+
+# Development
+pnpm dev              # Run all dev commands in parallel
+pnpm dev:nodes        # Watch nodes/, auto-rebuild on changes
+pnpm dev:app_ui       # Watch app and UI package
+pnpm dev_ui           # Watch UI package only
+```
+
+## Workspace Packages
+
+The project uses pnpm workspaces with the following packages:
+
+| Package            | Location           | Purpose                        |
+| ------------------ | ------------------ | ------------------------------ |
+| @nodarium/app      | app/               | Main SvelteKit application     |
+| @nodarium/ui       | packages/ui/       | Reusable UI component library  |
+| @nodarium/registry | packages/registry/ | Node registry with persistence |
+| @nodarium/types    | packages/types/    | Shared TypeScript types        |
+| @nodarium/utils    | packages/utils/    | Shared utilities               |
+| nodarium macros    | packages/macros/   | Rust procedural macros         |
+
+## Configuration Files
+
+- `.dprint.jsonc` - Dprint formatter configuration
+- `svelte.config.js` - SvelteKit configuration (app and ui)
+- `vite.config.ts` - Vite bundler configuration
+- `tsconfig.json` - TypeScript configuration (app and packages)
+- `Cargo.toml` - Rust workspace with member packages
+- `flake.nix` - Nix development environment
+
+## Development Workflow
+
+### Adding a New Node
+
+1. Copy the `.template` directory in `nodes/max/plantarium/` to create a new node directory
+2. Define node in `src/definition.json`
+3. Implement logic in `src/lib.rs`
+4. Build with `cargo build --release --target wasm32-unknown-unknown`
+5. Test by dragging onto the node graph
+
+### Modifying UI Components
+
+1. Changes to `packages/ui/` automatically rebuild with watch mode
+2. App imports from `@nodarium/ui`
+3. Run `pnpm dev:app_ui` for hot reload
+
+## Important Notes for AI Agents
+
+1. **WASM Compilation**: Nodes require `wasm32-unknown-unknown` target (`rustup target add wasm32-unknown-unknown`)
+2. **Cross-Compilation**: WASM build happens on host, not in containers/VMs
+3. **Static Serving**: Compiled WASM files must exist in `app/static/nodes/` before dev server runs
+4. **Workspace Dependencies**: Use `workspace:*` protocol for internal packages
+5. **Threlte Version**: Uses Threlte 8.x, not 7.x (important for 3D component APIs)
+6. **Svelte 5**: Project uses Svelte 5 with runes (`$state`, `$derived`, `$effect`)
+7. **Tailwind 4**: Uses Tailwind CSS v4 with `@tailwindcss/vite` plugin
+8. **IndexedDB**: Registry uses IDB for persistent node storage in browser
--- a/SUMMARY_RUNTIME.md
+++ b/SUMMARY_RUNTIME.md
@@ -0,0 +1,294 @@
+# Node Compilation and Runtime Execution
+
+## Overview
+
+Nodarium nodes are WebAssembly modules written in Rust. Each node is a compiled WASM binary that exposes a standardized C ABI interface. The system uses procedural macros to generate the necessary boilerplate for node definitions, memory management, and execution.
+
+## Node Compilation
+
+### 1. Node Definition (JSON)
+
+Each node has a `src/input.json` file that defines:
+
+```json
+{
+  "id": "max/plantarium/stem",
+  "meta": { "description": "Creates a stem" },
+  "outputs": ["path"],
+  "inputs": {
+    "origin": { "type": "vec3", "value": [0, 0, 0], "external": true },
+    "amount": { "type": "integer", "value": 1, "min": 1, "max": 64 },
+    "length": { "type": "float", "value": 5 },
+    "thickness": { "type": "float", "value": 0.2 }
+  }
+}
+```
+
+### 2. Procedural Macros
+
+The `nodarium_macros` crate provides two procedural macros:
+
+#### `#[nodarium_execute]`
+
+Transforms a Rust function into a WASM-compatible entry point:
+
+```rust
+#[nodarium_execute]
+pub fn execute(input: &[i32]) -> Vec<i32> {
+    // Node logic here
+}
+```
+
+The macro generates:
+- **C ABI wrapper**: Converts the WASM interface to a standard C FFI
+- **`execute` function**: Takes `(ptr: *const i32, len: usize)` and returns `*mut i32`
+- **Memory allocation**: `__alloc(len: usize) -> *mut i32` for buffer allocation
+- **Memory deallocation**: `__free(ptr: *mut i32, len: usize)` for cleanup
+- **Static output buffer**: `OUTPUT_BUFFER` for returning results
+- **Panic hook**: Routes panics through `host_log_panic` for debugging
+- **Internal logic wrapper**: Wraps the original function
+
+#### `nodarium_definition_file!("path")`
+
+Embeds the node definition JSON into the WASM binary:
+
+```rust
+nodarium_definition_file!("src/input.json");
+```
+
+Generates:
+- **`DEFINITION_DATA`**: Static byte array in `nodarium_definition` section
+- **`get_definition_ptr()`**: Returns pointer to definition data
+- **`get_definition_len()`**: Returns length of definition data
+
+### 3. Build Process
+
+Nodes are compiled with:
+```bash
+cargo build --release --target wasm32-unknown-unknown
+```
+
+The resulting `.wasm` files are copied to `app/static/nodes/` for serving.
+
+## Node Execution Runtime
+
+### Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    WebWorker Thread                          │
+│  ┌─────────────────────────────────────────────────────────┐│
+│  │              WorkerRuntimeExecutor                       ││
+│  │  ┌───────────────────────────────────────────────────┐  ││
+│  │  │           MemoryRuntimeExecutor                    ││
+│  │  │  ┌─────────────────────────────────────────────┐  ││
+│  │  │  │  Node Registry (WASM + Definitions)         ││
+│  │  │  └─────────────────────────────────────────────┘  ││
+│  │  │  ┌─────────────────────────────────────────────┐  ││
+│  │  │  │  Execution Engine (Bottom-Up Evaluation)    ││
+│  │  │  └─────────────────────────────────────────────┘  ││
+│  │  └───────────────────────────────────────────────────┘  ││
+│  └─────────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────────┘
+```
+
+### 1. MemoryRuntimeExecutor
+
+The core execution engine in `runtime-executor.ts`:
+
+#### Metadata Collection (`addMetaData`)
+
+1. Load node definitions from registry
+2. Build parent/child relationships from graph edges
+3. Calculate execution depth via reverse BFS from output node
+
+#### Node Sorting
+
+Nodes are sorted by depth (highest depth first) for bottom-up execution:
+
+```
+Depth 3:  n3  n6
+Depth 2:  n2  n4  n5
+Depth 1:  n1
+Depth 0:  Output
+Execution order: n3, n6, n2, n4, n5, n1, Output
+```
+
+#### Input Collection
+
+For each node, inputs are gathered from:
+1. **Connected nodes**: Results from parent nodes in the graph
+2. **Node props**: Values stored directly on the node instance
+3. **Settings**: Global settings mapped via `setting` property
+4. **Defaults**: Values from node definition
+
+#### Input Encoding
+
+Values are encoded as `Int32Array`:
+- **Floats**: IEEE 754 bits cast to i32
+- **Vectors**: `[0, count, v1, v2, v3, 1, 1]` (nested bracket format)
+- **Booleans**: `0` or `1`
+- **Integers**: Direct i32 value
+
+#### Caching
+
+Results are cached using:
+```typescript
+inputHash = `node-${node.id}-${fastHashArrayBuffer(encoded_inputs)}`
+```
+
+The cache uses LRU eviction (default size: 50 entries).
+
+### 2. Execution Flow
+
+```typescript
+async execute(graph: Graph, settings) {
+  // 1. Load definitions and build node relationships
+  const [outputNode, nodes] = await this.addMetaData(graph);
+
+  // 2. Sort nodes by depth (bottom-up)
+  const sortedNodes = nodes.sort((a, b) => b.depth - a.depth);
+
+  // 3. Execute each node
+  for (const node of sortedNodes) {
+    const inputs = this.collectInputs(node, settings);
+    const encoded = concatEncodedArrays(inputs);
+    const result = nodeType.execute(encoded);
+    this.results[node.id] = result;
+  }
+
+  // 4. Return output node result
+  return this.results[outputNode.id];
+}
+```
+
+### 3. Worker Isolation
+
+`WorkerRuntimeExecutor` runs execution in a WebWorker via Comlink:
+
+```typescript
+class WorkerRuntimeExecutor implements RuntimeExecutor {
+  private worker = new ComlinkWorker(...);
+
+  async execute(graph, settings) {
+    return this.worker.executeGraph(graph, settings);
+  }
+}
+```
+
+The worker backend (`worker-runtime-executor-backend.ts`):
+- Creates a single `MemoryRuntimeExecutor` instance
+- Manages caching state
+- Collects performance metrics
+
+### 4. Remote Execution (Optional)
+
+`RemoteRuntimeExecutor` can execute graphs on a remote server:
+
+```typescript
+class RemoteRuntimeExecutor implements RuntimeExecutor {
+  async execute(graph, settings) {
+    const res = await fetch(this.url, {
+      method: "POST",
+      body: JSON.stringify({ graph, settings })
+    });
+    return new Int32Array(await res.arrayBuffer());
+  }
+}
+```
+
+## Data Encoding Format
+
+### Bracket Notation
+
+Inputs and outputs use a nested bracket encoding:
+
+```
+[0, count, item1, item2, ..., 1, 1]
+   ^    ^       items                ^  ^
+   |    |                         |  |
+   |    |                         |  +-- closing bracket
+   |    +-- number of items + 1   |
+   +-- opening bracket (0)         +-- closing bracket (1)
+```
+
+### Example Encodings
+
+**Float (5.0)**:
+```typescript
+encodeFloat(5.0) // → 1084227584 (IEEE 754 bits as i32)
+```
+
+**Vec3 ([1, 2, 3])**:
+```typescript
+[0, 4, encodeFloat(1), encodeFloat(2), encodeFloat(3), 1, 1]
+```
+
+**Nested Math Expression**:
+```
+[0, 3, 0, 2, 0, 3, 0, 0, 0, 3, 7549747, 127, 1, 1, ...]
+```
+
+### Decoding Utilities
+
+From `packages/utils/src/tree.rs`:
+- `split_args()`: Parses nested bracket arrays into segments
+- `evaluate_float()`: Recursively evaluates and decodes float expressions
+- `evaluate_int()`: Evaluates integer/math node expressions
+- `evaluate_vec3()`: Decodes vec3 arrays
+
+## Geometry Data Format
+
+### Path Data
+
+Paths represent procedural plant structures:
+
+```
+[0, count, [0, header_size, node_type, depth, x, y, z, w, ...], 1, 1]
+```
+
+Each point has 4 values: x, y, z position + thickness (w).
+
+### Geometry Data
+
+Meshes use a similar format with vertices and face indices.
+
+## Performance Tracking
+
+The runtime collects detailed performance metrics:
+- `collect-metadata`: Time to build node graph
+- `collected-inputs`: Time to gather inputs
+- `encoded-inputs`: Time to encode inputs
+- `hash-inputs`: Time to compute cache hash
+- `cache-hit`: 1 if cache hit, 0 if miss
+- `node/{node_type}`: Time per node execution
+
+## Caching Strategy
+
+### MemoryRuntimeCache
+
+LRU cache implementation:
+```typescript
+class MemoryRuntimeCache {
+  private map = new Map<string, unknown>();
+  size: number = 50;
+
+  get(key) { /* move to front */ }
+  set(key, value) { /* evict oldest if at capacity */ }
+}
+```
+
+### IndexDBCache
+
+For persistence across sessions, the registry uses IndexedDB caching.
+
+## Summary
+
+The Nodarium node system works as follows:
+
+1. **Compilation**: Rust functions are decorated with macros that generate C ABI WASM exports
+2. **Registration**: Node definitions are embedded in WASM and loaded at runtime
+3. **Graph Analysis**: Runtime builds node relationships and execution order
+4. **Bottom-Up Execution**: Nodes execute from leaves to output
+5. **Caching**: Results are cached per-node-inputs hash for performance
+6. **Isolation**: Execution runs in a WebWorker to prevent main thread blocking
--- a/app/Dockerfile
+++ b/app/Dockerfile
@@ -28,5 +28,6 @@ RUN rm /etc/nginx/conf.d/default.conf
 COPY app/docker/app.conf /etc/nginx/conf.d/app.conf

 COPY --from=builder /app/app/build /app
+COPY --from=builder /app/packages/ui/build /app/ui

 EXPOSE 80
--- a/app/benchmark/.gitignore
+++ b/app/benchmark/.gitignore
@@ -0,0 +1 @@
+out/
--- a/app/benchmark/benchmarkRegistry.ts
+++ b/app/benchmark/benchmarkRegistry.ts
@@ -0,0 +1,47 @@
+import { NodeDefinition, NodeId, NodeRegistry } from '@nodarium/types';
+import { createWasmWrapper } from '@nodarium/utils';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+export class BenchmarkRegistry implements NodeRegistry {
+  status: 'loading' | 'ready' | 'error' = 'loading';
+
+  private nodes = new Map<string, NodeDefinition>();
+
+  async load(nodeIds: NodeId[]): Promise<NodeDefinition[]> {
+    const nodes = await Promise.all(nodeIds.map(async id => {
+      const p = resolve('static/nodes/' + id + '.wasm');
+      const file = await readFile(p);
+      const node = createWasmWrapper(file as unknown as ArrayBuffer);
+      const d = node.get_definition();
+      return {
+        ...d,
+        execute: node.execute
+      };
+    }));
+    for (const n of nodes) {
+      this.nodes.set(n.id, n);
+    }
+    this.status = 'ready';
+    return nodes;
+  }
+
+  async register(id: string, wasmBuffer: ArrayBuffer): Promise<NodeDefinition> {
+    const wasm = createWasmWrapper(wasmBuffer);
+    const d = wasm.get_definition();
+    const node = {
+      ...d,
+      execute: wasm.execute
+    };
+    this.nodes.set(id, node);
+    return node;
+  }
+
+  getNode(id: NodeId | string): NodeDefinition | undefined {
+    return this.nodes.get(id);
+  }
+
+  getAllNodes(): NodeDefinition[] {
+    return [];
+  }
+}
--- a/app/benchmark/index.ts
+++ b/app/benchmark/index.ts
@@ -0,0 +1,56 @@
+import type { Graph, Graph as GraphType, NodeId } from '@nodarium/types';
+import { createLogger, createPerformanceStore } from '@nodarium/utils';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { MemoryRuntimeExecutor } from '../src/lib/runtime/runtime-executor.ts';
+import { BenchmarkRegistry } from './benchmarkRegistry.ts';
+import defaultPlantTemplate from './templates/default.json' assert { type: 'json' };
+import lottaFacesTemplate from './templates/lotta-faces.json' assert { type: 'json' };
+import plantTemplate from './templates/plant.json' assert { type: 'json' };
+
+const registry = new BenchmarkRegistry();
+const r = new MemoryRuntimeExecutor(registry);
+const perfStore = createPerformanceStore();
+
+const log = createLogger('bench');
+
+const templates: Record<string, Graph> = {
+  'plant': plantTemplate as unknown as GraphType,
+  'lotta-faces': lottaFacesTemplate as unknown as GraphType,
+  'default': defaultPlantTemplate as unknown as GraphType
+};
+
+async function run(g: GraphType, amount: number) {
+  await registry.load(plantTemplate.nodes.map(n => n.type) as NodeId[]);
+  log.log('loaded ' + g.nodes.length + ' nodes');
+
+  log.log('warming up');
+
+  // Warm up the runtime? maybe this does something?
+  for (let index = 0; index < 10; index++) {
+    await r.execute(g, { randomSeed: true });
+  }
+
+  log.log('executing');
+  r.perf = perfStore;
+  for (let i = 0; i < amount; i++) {
+    r.perf?.startRun();
+    await r.execute(g, { randomSeed: true });
+    r.perf?.stopRun();
+  }
+  log.log('finished');
+  return r.perf.get();
+}
+
+async function main() {
+  const outPath = resolve('benchmark/out/');
+  await mkdir(outPath, { recursive: true });
+  for (const key in templates) {
+    log.log('executing ' + key);
+    const perfData = await run(templates[key], 100);
+    await writeFile(resolve(outPath, key + '.json'), JSON.stringify(perfData));
+    await new Promise(res => setTimeout(res, 200));
+  }
+}
+
+main();
--- a/app/benchmark/templates/default.json
+++ b/app/benchmark/templates/default.json
@@ -0,0 +1,95 @@
+{
+  "settings": { "resolution.circle": 26, "resolution.curve": 39 },
+  "nodes": [
+    { "id": 9, "position": [220, 80], "type": "max/plantarium/output", "props": {} },
+    {
+      "id": 10,
+      "position": [95, 80],
+      "type": "max/plantarium/stem",
+      "props": { "amount": 5, "length": 11, "thickness": 0.1 }
+    },
+    {
+      "id": 14,
+      "position": [195, 80],
+      "type": "max/plantarium/gravity",
+      "props": {
+        "strength": 0.38,
+        "scale": 39,
+        "fixBottom": 0,
+        "directionalStrength": [1, 1, 1],
+        "depth": 1,
+        "curviness": 1
+      }
+    },
+    {
+      "id": 15,
+      "position": [120, 80],
+      "type": "max/plantarium/noise",
+      "props": {
+        "strength": 4.9,
+        "scale": 2.2,
+        "fixBottom": 1,
+        "directionalStrength": [1, 1, 1],
+        "depth": 1,
+        "octaves": 1
+      }
+    },
+    {
+      "id": 16,
+      "position": [70, 80],
+      "type": "max/plantarium/vec3",
+      "props": { "0": 0, "1": 0, "2": 0 }
+    },
+    {
+      "id": 17,
+      "position": [45, 80],
+      "type": "max/plantarium/random",
+      "props": { "min": -2, "max": 2 }
+    },
+    {
+      "id": 18,
+      "position": [170, 80],
+      "type": "max/plantarium/branch",
+      "props": {
+        "length": 1.6,
+        "thickness": 0.69,
+        "amount": 36,
+        "offsetSingle": 0.5,
+        "lowestBranch": 0.46,
+        "highestBranch": 1,
+        "depth": 1,
+        "rotation": 180
+      }
+    },
+    {
+      "id": 19,
+      "position": [145, 80],
+      "type": "max/plantarium/gravity",
+      "props": {
+        "strength": 0.38,
+        "scale": 39,
+        "fixBottom": 0,
+        "directionalStrength": [1, 1, 1],
+        "depth": 1,
+        "curviness": 1
+      }
+    },
+    {
+      "id": 20,
+      "position": [70, 120],
+      "type": "max/plantarium/random",
+      "props": { "min": 0.073, "max": 0.15 }
+    }
+  ],
+  "edges": [
+    [14, 0, 9, "input"],
+    [10, 0, 15, "plant"],
+    [16, 0, 10, "origin"],
+    [17, 0, 16, "0"],
+    [17, 0, 16, "2"],
+    [18, 0, 14, "plant"],
+    [15, 0, 19, "plant"],
+    [19, 0, 18, "plant"],
+    [20, 0, 10, "thickness"]
+  ]
+}
--- a/app/benchmark/templates/lotta-faces.json
+++ b/app/benchmark/templates/lotta-faces.json
@@ -0,0 +1,44 @@
+{
+  "settings": { "resolution.circle": 64, "resolution.curve": 64, "randomSeed": false },
+  "nodes": [
+    { "id": 9, "position": [260, 0], "type": "max/plantarium/output", "props": {} },
+    {
+      "id": 18,
+      "position": [185, 0],
+      "type": "max/plantarium/stem",
+      "props": { "amount": 64, "length": 12, "thickness": 0.15 }
+    },
+    {
+      "id": 19,
+      "position": [210, 0],
+      "type": "max/plantarium/noise",
+      "props": { "scale": 1.3, "strength": 5.4 }
+    },
+    {
+      "id": 20,
+      "position": [235, 0],
+      "type": "max/plantarium/branch",
+      "props": { "length": 0.8, "thickness": 0.8, "amount": 3 }
+    },
+    {
+      "id": 21,
+      "position": [160, 0],
+      "type": "max/plantarium/vec3",
+      "props": { "0": 0.39, "1": 0, "2": 0.41 }
+    },
+    {
+      "id": 22,
+      "position": [130, 0],
+      "type": "max/plantarium/random",
+      "props": { "min": -2, "max": 2 }
+    }
+  ],
+  "edges": [
+    [18, 0, 19, "plant"],
+    [19, 0, 20, "plant"],
+    [20, 0, 9, "input"],
+    [21, 0, 18, "origin"],
+    [22, 0, 21, "0"],
+    [22, 0, 21, "2"]
+  ]
+}
--- a/app/benchmark/templates/plant.json
+++ b/app/benchmark/templates/plant.json
@@ -0,0 +1,71 @@
+{
+  "settings": { "resolution.circle": 26, "resolution.curve": 39 },
+  "nodes": [
+    { "id": 9, "position": [180, 80], "type": "max/plantarium/output", "props": {} },
+    {
+      "id": 10,
+      "position": [55, 80],
+      "type": "max/plantarium/stem",
+      "props": { "amount": 1, "length": 11, "thickness": 0.71 }
+    },
+    {
+      "id": 11,
+      "position": [80, 80],
+      "type": "max/plantarium/noise",
+      "props": {
+        "strength": 35,
+        "scale": 4.6,
+        "fixBottom": 1,
+        "directionalStrength": [1, 0.74, 0.083],
+        "depth": 1
+      }
+    },
+    {
+      "id": 12,
+      "position": [105, 80],
+      "type": "max/plantarium/branch",
+      "props": {
+        "length": 3,
+        "thickness": 0.6,
+        "amount": 10,
+        "rotation": 180,
+        "offsetSingle": 0.34,
+        "lowestBranch": 0.53,
+        "highestBranch": 1,
+        "depth": 1
+      }
+    },
+    {
+      "id": 13,
+      "position": [130, 80],
+      "type": "max/plantarium/noise",
+      "props": {
+        "strength": 8,
+        "scale": 7.7,
+        "fixBottom": 1,
+        "directionalStrength": [1, 0, 1],
+        "depth": 1
+      }
+    },
+    {
+      "id": 14,
+      "position": [155, 80],
+      "type": "max/plantarium/gravity",
+      "props": {
+        "strength": 0.11,
+        "scale": 39,
+        "fixBottom": 0,
+        "directionalStrength": [1, 1, 1],
+        "depth": 1,
+        "curviness": 1
+      }
+    }
+  ],
+  "edges": [
+    [10, 0, 11, "plant"],
+    [11, 0, 12, "plant"],
+    [12, 0, 13, "plant"],
+    [13, 0, 14, "plant"],
+    [14, 0, 9, "input"]
+  ]
+}
--- a/app/package.json
+++ b/app/package.json
@@ -1,7 +1,7 @@
 {
  "name": "@nodarium/app",
  "private": true,
-  "version": "0.0.4",
+  "version": "0.0.5",
  "type": "module",
  "scripts": {
    "dev": "vite dev",
@@ -14,7 +14,8 @@
    "format": "dprint fmt -c '../.dprint.jsonc' .",
    "format:check": "dprint check -c '../.dprint.jsonc' .",
    "lint": "eslint .",
-    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json"
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "bench": "tsx ./benchmark/index.ts"
  },
  "dependencies": {
    "@nodarium/ui": "workspace:*",
@@ -51,6 +52,7 @@
    "svelte": "^5.49.2",
    "svelte-check": "^4.3.6",
    "tslib": "^2.8.1",
+    "tsx": "^4.21.0",
    "typescript": "^5.9.3",
    "typescript-eslint": "^8.54.0",
    "vite": "^7.3.1",
--- a/app/src/lib/graph-interface/graph-manager.svelte.ts
+++ b/app/src/lib/graph-interface/graph-manager.svelte.ts
@@ -25,7 +25,7 @@ const clone = 'structuredClone' in self
  ? self.structuredClone
  : (args: unknown) => JSON.parse(JSON.stringify(args));

-function areSocketsCompatible(
+export function areSocketsCompatible(
  output: string | undefined,
  inputs: string | (string | undefined)[] | undefined
 ) {
@@ -33,7 +33,7 @@ function areSocketsCompatible(
  if (Array.isArray(inputs) && output) {
    return inputs.includes('*') || inputs.includes(output);
  }
-  return inputs === output;
+  return inputs === output || inputs === '*';
 }

 function areEdgesEqual(firstEdge: Edge, secondEdge: Edge) {
@@ -269,14 +269,7 @@ export class GraphManager extends EventEmitter<{
  private _init(graph: Graph) {
    const nodes = new SvelteMap(
      graph.nodes.map((node) => {
-        const nodeType = this.registry.getNode(node.type);
-        const n = node as NodeInstance;
-        if (nodeType) {
-          n.state = {
-            type: nodeType
-          };
-        }
-        return [node.id, n];
+        return [node.id, node as NodeInstance];
      })
    );

@@ -301,6 +294,30 @@ export class GraphManager extends EventEmitter<{
    this.execute();
  }

+  private async loadAllCollections() {
+    // Fetch all nodes from all collections of the loaded nodes
+    const nodeIds = Array.from(new Set([...this.graph.nodes.map((n) => n.type)]));
+    const allCollections = new Set<`${string}/${string}`>();
+    for (const id of nodeIds) {
+      const [user, collection] = id.split('/');
+      allCollections.add(`${user}/${collection}`);
+    }
+
+    const allCollectionIds = await Promise
+      .all([...allCollections]
+        .map(async (collection) =>
+          remoteRegistry
+            .fetchCollection(collection)
+            .then((collection: { nodes: { id: NodeId }[] }) => {
+              return collection.nodes.map(n => n.id.replace(/\.wasm$/, '') as NodeId);
+            })
+        ));
+
+    const missingNodeIds = [...new Set(allCollectionIds.flat())];
+
+    this.registry.load(missingNodeIds);
+  }
+
  async load(graph: Graph) {
    const a = performance.now();

@@ -385,7 +402,9 @@ export class GraphManager extends EventEmitter<{

    this.loaded = true;
    logger.log(`Graph loaded in ${performance.now() - a}ms`);
+
    setTimeout(() => this.execute(), 100);
+    this.loadAllCollections(); // lazily load all nodes from all collections
  }

  getAllNodes() {
@@ -492,10 +511,10 @@ export class GraphManager extends EventEmitter<{
    const inputs = Object.entries(to.state?.type?.inputs ?? {});
    const outputs = from.state?.type?.outputs ?? [];
    for (let i = 0; i < inputs.length; i++) {
-      const [inputName, input] = inputs[0];
+      const [inputName, input] = inputs[i];
      for (let o = 0; o < outputs.length; o++) {
-        const output = outputs[0];
-        if (input.type === output) {
+        const output = outputs[o];
+        if (input.type === output || input.type === '*') {
          return this.createEdge(from, o, to, inputName);
        }
      }
@@ -597,11 +616,14 @@ export class GraphManager extends EventEmitter<{
      return;
    }

+    const fromType = from.state.type || this.registry.getNode(from.type);
+    const toType = to.state.type || this.registry.getNode(to.type);
+
    // check if socket types match
-    const fromSocketType = from.state?.type?.outputs?.[fromSocket];
-    const toSocketType = [to.state?.type?.inputs?.[toSocket]?.type];
-    if (to.state?.type?.inputs?.[toSocket]?.accepts) {
-      toSocketType.push(...(to?.state?.type?.inputs?.[toSocket]?.accepts || []));
+    const fromSocketType = fromType?.outputs?.[fromSocket];
+    const toSocketType = [toType?.inputs?.[toSocket]?.type];
+    if (toType?.inputs?.[toSocket]?.accepts) {
+      toSocketType.push(...(toType?.inputs?.[toSocket]?.accepts || []));
    }

    if (!areSocketsCompatible(fromSocketType, toSocketType)) {
@@ -724,8 +746,9 @@ export class GraphManager extends EventEmitter<{
  }

  getPossibleSockets({ node, index }: Socket): [NodeInstance, string | number][] {
-    const nodeType = node?.state?.type;
+    const nodeType = this.registry.getNode(node.type);
    if (!nodeType) return [];
+    console.log({ index });

    const sockets: [NodeInstance, string | number][] = [];

@@ -740,7 +763,7 @@ export class GraphManager extends EventEmitter<{
      const ownType = nodeType?.inputs?.[index].type;

      for (const node of nodes) {
-        const nodeType = node?.state?.type;
+        const nodeType = this.registry.getNode(node.type);
        const inputs = nodeType?.outputs;
        if (!inputs) continue;
        for (let index = 0; index < inputs.length; index++) {
@@ -772,7 +795,7 @@ export class GraphManager extends EventEmitter<{
      const ownType = nodeType.outputs?.[index];

      for (const node of nodes) {
-        const inputs = node?.state?.type?.inputs;
+        const inputs = this.registry.getNode(node.type)?.inputs;
        if (!inputs) continue;
        for (const key in inputs) {
          const otherType = [inputs[key].type];
@@ -788,6 +811,7 @@ export class GraphManager extends EventEmitter<{
      }
    }

+    console.log(`Found ${sockets.length} possible sockets`, sockets);
    return sockets;
  }

--- a/app/src/lib/graph-interface/graph-state.svelte.ts
+++ b/app/src/lib/graph-interface/graph-state.svelte.ts
@@ -259,7 +259,7 @@ export class GraphState {

    let { node, index, position } = socket;

-    // remove existing edge
+    // if the socket is an input socket -> remove existing edges
    if (typeof index === 'string') {
      const edges = this.graph.getEdgesToNode(node);
      for (const edge of edges) {
--- a/app/src/lib/graph-interface/graph/Wrapper.svelte
+++ b/app/src/lib/graph-interface/graph/Wrapper.svelte
@@ -33,6 +33,7 @@
    backgroundType = $bindable('grid'),
    snapToGrid = $bindable(true),
    showHelp = $bindable(false),
+    settings = $bindable(),
    settingTypes = $bindable(),
    onsave,
    onresult
--- a/app/src/lib/node-registry/node-registry-client.ts
+++ b/app/src/lib/node-registry/node-registry-client.ts
@@ -2,6 +2,7 @@ import {
  type AsyncCache,
  type NodeDefinition,
  NodeDefinitionSchema,
+  type NodeId,
  type NodeRegistry
 } from '@nodarium/types';
 import { createLogger, createWasmWrapper } from '@nodarium/utils';
@@ -12,6 +13,7 @@ log.mute();
 export class RemoteNodeRegistry implements NodeRegistry {
  status: 'loading' | 'ready' | 'error' = 'loading';
  private nodes: Map<string, NodeDefinition> = new Map();
+  private memory = new WebAssembly.Memory({ initial: 1024, maximum: 8192 });

  constructor(
    private url: string,
@@ -170,6 +172,13 @@ export class RemoteNodeRegistry implements NodeRegistry {
  }

  getAllNodes() {
-    return [...this.nodes.values()];
+    const allNodes = [...this.nodes.values()];
+    log.info('getting all nodes', allNodes);
+    return allNodes;
+  }
+
+  async overwriteNode(nodeId: NodeId, node: NodeDefinition) {
+    log.info('Overwritten node', { nodeId, node });
+    this.nodes.set(nodeId, node);
  }
 }
--- a/app/src/lib/runtime/helpers.ts
+++ b/app/src/lib/runtime/helpers.ts
@@ -0,0 +1,39 @@
+export function logInt32ArrayChanges(
+  before: Int32Array,
+  after: Int32Array,
+  clamp = 10
+): void {
+  if (before.length !== after.length) {
+    throw new Error('Arrays must have the same length');
+  }
+
+  let rangeStart: number | null = null;
+  let collected: number[] = [];
+
+  const flush = (endIndex: number) => {
+    if (rangeStart === null) return;
+
+    const preview = collected.slice(0, clamp);
+    const suffix = collected.length > clamp ? '...' : '';
+
+    console.log(
+      `Change ${rangeStart}-${endIndex}: [${preview.join(', ')}${suffix}]`
+    );
+
+    rangeStart = null;
+    collected = [];
+  };
+
+  for (let i = 0; i < before.length; i++) {
+    if (before[i] !== after[i]) {
+      if (rangeStart === null) {
+        rangeStart = i;
+      }
+      collected.push(after[i]);
+    } else {
+      flush(i - 1);
+    }
+  }
+
+  flush(before.length - 1);
+}
--- a/app/src/lib/runtime/runtime-executor.ts
+++ b/app/src/lib/runtime/runtime-executor.ts
@@ -1,3 +1,5 @@
+import type { SettingsToStore } from '$lib/settings/app-settings.svelte';
+import { RemoteNodeRegistry } from '@nodarium/registry';
 import type {
  Graph,
  NodeDefinition,
@@ -7,24 +9,38 @@ import type {
  SyncCache
 } from '@nodarium/types';
 import {
-  concatEncodedArrays,
  createLogger,
+  createWasmWrapper,
  encodeFloat,
-  fastHashArrayBuffer,
  type PerformanceStore
 } from '@nodarium/utils';
+import { DevSettingsType } from '../../routes/dev/settings.svelte';
+import { logInt32ArrayChanges } from './helpers';
 import type { RuntimeNode } from './types';

 const log = createLogger('runtime-executor');
-log.mute();
+// log.mute(); // Keep logging enabled for debug info

-function getValue(input: NodeInput, value?: unknown) {
+const remoteRegistry = new RemoteNodeRegistry('');
+
+type WasmExecute = (outputPos: number, args: number[]) => number;
+
+function getValue(input: NodeInput, value?: unknown): number | number[] | Int32Array {
  if (value === undefined && 'value' in input) {
    value = input.value;
  }

-  if (input.type === 'float') {
-    return encodeFloat(value as number);
+  switch (input.type) {
+    case 'float':
+      return encodeFloat(value as number);
+
+    case 'select':
+      return (value as number) ?? 0;
+
+    case 'vec3': {
+      const arr = Array.isArray(value) ? value : [];
+      return [0, arr.length + 1, ...arr.map(v => encodeFloat(v)), 1, 1];
+    }
  }

  if (Array.isArray(value)) {
@@ -40,23 +56,26 @@ function getValue(input: NodeInput, value?: unknown) {
    return [0, value.length + 1, ...value, 1, 1] as number[];
  }

-  if (typeof value === 'boolean') {
-    return value ? 1 : 0;
-  }
+  if (typeof value === 'boolean') return value ? 1 : 0;
+  if (typeof value === 'number') return value;
+  if (value instanceof Int32Array) return value;

-  if (typeof value === 'number') {
-    return value;
-  }
-
-  if (value instanceof Int32Array) {
-    return value;
-  }
-
-  throw new Error(`Unknown input type ${input.type}`);
+  throw new Error(`Unsupported input type: ${input.type}`);
 }

-export class MemoryRuntimeExecutor implements RuntimeExecutor {
-  private definitionMap: Map<string, NodeDefinition> = new Map();
+function compareInt32(a: Int32Array, b: Int32Array): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+export type Pointer = {
+  start: number;
+  end: number;
+  _title?: string;
+};

  private seed = Math.floor(Math.random() * 100000000);
  private debugData: Record<number, { type: string; data: Int32Array }> = {};
@@ -64,34 +83,55 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
  perf?: PerformanceStore;

  constructor(
-    private registry: NodeRegistry,
+    private readonly registry: NodeRegistry,
    public cache?: SyncCache<Int32Array>
  ) {
    this.cache = undefined;
+    this.refreshView();
+    log.info('MemoryRuntimeExecutor initialized');
  }

+  private refreshView(): void {
+    this.memoryView = new Int32Array(this.memory.buffer);
+    log.info(`Memory view refreshed, length: ${this.memoryView.length}`);
+  }
+
+  public getMemory(): Int32Array {
+    return new Int32Array(this.memory.buffer);
+  }
+
+  private map = new Map<string, { definition: NodeDefinition; execute: WasmExecute }>();
  private async getNodeDefinitions(graph: Graph) {
    if (this.registry.status !== 'ready') {
      throw new Error('Node registry is not ready');
    }

-    await this.registry.load(graph.nodes.map((node) => node.type));
+    await this.registry.load(graph.nodes.map(n => n.type));
+    log.info(`Loaded ${graph.nodes.length} node types from registry`);

-    const typeMap = new Map<string, NodeDefinition>();
-    for (const node of graph.nodes) {
-      if (!typeMap.has(node.type)) {
-        const type = this.registry.getNode(node.type);
-        if (type) {
-          typeMap.set(node.type, type);
-        }
-      }
+    for (const { type } of graph.nodes) {
+      if (this.map.has(type)) continue;
+
+      const def = this.registry.getNode(type);
+      if (!def) continue;
+
+      log.info(`Fetching WASM for node type: ${type}`);
+      const buffer = await remoteRegistry.fetchArrayBuffer(`nodes/${type}.wasm`);
+      const wrapper = createWasmWrapper(buffer, this.memory);
+
+      this.map.set(type, {
+        definition: def,
+        execute: wrapper.execute
+      });
+      log.info(`Node type ${type} loaded and wrapped`);
    }
-    return typeMap;
+
+    return this.map;
  }

  private async addMetaData(graph: Graph) {
-    // First, lets check if all nodes have a definition
-    this.definitionMap = await this.getNodeDefinitions(graph);
+    this.nodes = await this.getNodeDefinitions(graph);
+    log.info(`Metadata added for ${this.nodes.size} nodes`);

    const graphNodes = graph.nodes.map(node => {
      const n = node as RuntimeNode;
@@ -104,25 +144,21 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
      return n;
    });

-    const outputNode = graphNodes.find((node) => node.type.endsWith('/output'));
-    if (!outputNode) {
-      throw new Error('No output node found');
-    }
+    const outputNode = graphNodes.find(n => n.type.endsWith('/output') || n.type.endsWith('/debug'))
+      ?? graphNodes[0];

-    const nodeMap = new Map(
-      graphNodes.map((node) => [node.id, node])
-    );
+    const nodeMap = new Map(graphNodes.map(n => [n.id, n]));

    // loop through all edges and assign the parent and child nodes to each node
    for (const edge of graph.edges) {
      const [parentId, /*_parentOutput*/, childId, childInput] = edge;
      const parent = nodeMap.get(parentId);
      const child = nodeMap.get(childId);
-      if (parent && child) {
-        parent.state.children.push(child);
-        child.state.parents.push(parent);
-        child.state.inputNodes[childInput] = parent;
-      }
+      if (!parent || !child) continue;
+
+      parent.state.children.push(child);
+      child.state.parents.push(parent);
+      child.state.inputNodes[childInput] = parent;
    }

    const nodes = new Map<number, RuntimeNode>();
@@ -130,10 +166,8 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
    // loop through all the nodes and assign each nodes its depth
    const stack = [outputNode, ...graphNodes.filter(n => n.type.endsWith('/debug'))];
    while (stack.length) {
-      const node = stack.pop();
-      if (!node) continue;
+      const node = stack.pop()!;
      for (const parent of node.state.parents) {
-        parent.state = parent.state || {};
        parent.state.depth = node.state.depth + 1;
        stack.push(parent);
      }
@@ -157,17 +191,21 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
    return [outputNode, _nodes] as const;
  }

-  async execute(graph: Graph, settings: Record<string, unknown>) {
-    this.perf?.addPoint('runtime');
+  private writeToMemory(value: number | number[] | Int32Array, title?: string): Pointer {
+    const start = this.offset;
+
+    if (typeof value === 'number') {
+      this.memoryView[this.offset++] = value;
+    } else {
+      this.memoryView.set(value, this.offset);
+      this.offset += value.length;
+    }

    let a = performance.now();
    this.debugData = {};

    // Then we add some metadata to the graph
-    const [outputNode, nodes] = await this.addMetaData(graph);
-    let b = performance.now();
-
-    this.perf?.addPoint('collect-metadata', b - a);
+    const [_outputNode, nodes] = await this.addMetaData(graph);

    /*
     * Here we sort the nodes into buckets, which we then execute one by one
@@ -185,58 +223,75 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
      (a, b) => (b.state?.depth || 0) - (a.state?.depth || 0)
    );

-    // here we store the intermediate results of the nodes
-    const results: Record<string, Int32Array> = {};
+    console.log({ settings });

-    if (settings['randomSeed']) {
-      this.seed = Math.floor(Math.random() * 100000000);
-    }
+    this.printMemory();
+    const seedPtr = this.writeToMemory(this.seed, 'seed');
+
+    const settingPtrs = new Map<string, Pointer>(
+      Object.entries(settings).map((
+        [key, value]
+      ) => [key as string, this.writeToMemory(value as number, `setting.${key}`)])
+    );

    for (const node of sortedNodes) {
-      const node_type = this.definitionMap.get(node.type)!;
+      const node_type = this.nodes.get(node.type)!;
+
+      console.log('---------------');
+      console.log('STARTING NODE EXECUTION', node_type.definition.id + '/' + node.id);
+      this.printMemory();
+
+      // console.log(node_type.definition.inputs);
+      const inputs = Object.entries(node_type.definition.inputs || {}).map(
+        ([key, input]) => {
+          // We should probably initially write this to memory
+          if (input.type === 'seed') {
+            return seedPtr;
+          }
+
+          const title = `${node.id}.${key}`;
+
+          // We should probably initially write this to memory
+          // If the input is linked to a setting, we use that value
+          // TODO: handle nodes which reference undefined settings
+          if (input.setting) {
+            return settingPtrs.get(input.setting)!;
+          }
+
+          // check if the input is connected to another node
+          const inputNode = node.state.inputNodes[key];
+          if (inputNode) {
+            if (this.results[inputNode.id] === undefined) {
+              throw new Error(
+                `Node ${node.type}/${node.id} is missing input from node ${inputNode.type}/${inputNode.id}`
+              );
+            }
+            return this.results[inputNode.id];
+          }
+
+          // If the value is stored in the node itself, we use that value
+          if (node.props?.[key] !== undefined) {
+            const value = getValue(input, node.props[key]);
+            console.log(`Writing prop for ${node.id} -> ${key} to memory`, node.props[key], value);
+            return this.writeToMemory(value, title);
+          }
+
+          return this.writeToMemory(getValue(input), title);
+        }
+      );
+
+      this.printMemory();

      if (!node_type || !node.state || !node_type.execute) {
        log.warn(`Node ${node.id} has no definition`);
        continue;
      }

-      a = performance.now();
-
-      // Collect the inputs for the node
-      const inputs = Object.entries(node_type.inputs || {}).map(
-        ([key, input]) => {
-          if (input.type === 'seed') {
-            return this.seed;
-          }
-
-          // If the input is linked to a setting, we use that value
-          if (input.setting) {
-            return getValue(input, settings[input.setting]);
-          }
-
-          // check if the input is connected to another node
-          const inputNode = node.state.inputNodes[key];
-          if (inputNode) {
-            if (results[inputNode.id] === undefined) {
-              throw new Error(
-                `Node ${node.type} is missing input from node ${inputNode.type}`
-              );
-            }
-            return results[inputNode.id];
-          }
-
-          // If the value is stored in the node itself, we use that value
-          if (node.props?.[key] !== undefined) {
-            return getValue(input, node.props[key]);
-          }
-
-          return getValue(input);
-        }
-      );
-      b = performance.now();
-
-      this.perf?.addPoint('collected-inputs', b - a);
+      this.inputPtrs[node.id] = inputs;
+      const args = inputs.map(s => [s.start, s.end]).flat();
+      console.log('ARGS', inputs);

+      this.printMemory();
      try {
        a = performance.now();
        const encoded_inputs = concatEncodedArrays(inputs);
@@ -277,28 +332,138 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
        b = performance.now();

        if (this.cache && node.id !== outputNode.id) {
-          this.cache.set(inputHash, results[node.id]);
+          this.cache.set(inputHash, this.results[node.id]);
        }

        this.perf?.addPoint('node/' + node_type.id, b - a);
        log.log('Result:', results[node.id]);
        log.groupEnd();
      } catch (e) {
-        log.groupEnd();
-        log.error(`Error executing node ${node_type.id || node.id}`, e);
+        console.error(`Failed to execute node ${node.type}/${node.id}`, e);
+        this.isRunning = false;
      }
    }

-    // return the result of the parent of the output node
-    const res = results[outputNode.id];
+    this.isRunning = true;
+    log.info('Execution started');

-    if (this.cache) {
-      this.cache.size = sortedNodes.length * 2;
+    try {
+      this.offset = 0;
+      this.results = {};
+      this.inputPtrs = {};
+      this.allPtrs = [];
+      this.seed += 2;
+
+      this.refreshView();
+
+      const [outputNode, nodes] = await this.addMetaData(graph);
+
+      const sortedNodes = [...nodes].sort(
+        (a, b) => (b.state.depth ?? 0) - (a.state.depth ?? 0)
+      );
+
+      const seedPtr = this.writeToMemory(this.seed, 'seed');
+
+      const settingPtrs = new Map<string, Pointer>();
+      for (const [key, value] of Object.entries(settings)) {
+        const ptr = this.writeToMemory(value as number, `setting.${key}`);
+        settingPtrs.set(key, ptr);
+      }
+
+      let lastNodePtr: Pointer | undefined = undefined;
+
+      for (const node of sortedNodes) {
+        const nodeType = this.nodes.get(node.type);
+        if (!nodeType) continue;
+
+        log.info(`Executing node: ${node.id} (type: ${node.type})`);
+
+        const inputs = Object.entries(nodeType.definition.inputs || {}).map(
+          ([key, input]) => {
+            if (input.type === 'seed') return seedPtr;
+
+            if (input.setting) {
+              const ptr = settingPtrs.get(input.setting);
+              if (!ptr) throw new Error(`Missing setting: ${input.setting}`);
+              return ptr;
+            }
+
+            const src = node.state.inputNodes[key];
+            if (src) {
+              const res = this.results[src.id];
+              if (!res) {
+                throw new Error(`Missing input from ${src.type}/${src.id}`);
+              }
+              return res;
+            }
+
+            if (node.props?.[key] !== undefined) {
+              return this.writeToMemory(
+                getValue(input, node.props[key]),
+                `${node.id}.${key}`
+              );
+            }
+
+            return this.writeToMemory(getValue(input), `${node.id}.${key}`);
+          }
+        );
+
+        this.inputPtrs[node.id] = inputs;
+        const args = inputs.flatMap(p => [p.start * 4, p.end * 4]);
+
+        log.info(`Executing node ${node.type}/${node.id}`);
+        const memoryBefore = this.memoryView.slice(0, this.offset);
+        const bytesWritten = nodeType.execute(this.offset * 4, args);
+        this.refreshView();
+        const memoryAfter = this.memoryView.slice(0, this.offset);
+        logInt32ArrayChanges(memoryBefore, memoryAfter);
+        this.refreshView();
+
+        const outLen = bytesWritten >> 2;
+        const outputStart = this.offset;
+
+        if (
+          args.length === 2
+          && inputs[0].end - inputs[0].start === outLen
+          && compareInt32(
+            this.memoryView.slice(inputs[0].start, inputs[0].end),
+            this.memoryView.slice(outputStart, outputStart + outLen)
+          )
+        ) {
+          this.results[node.id] = inputs[0];
+          this.allPtrs.push(this.results[node.id]);
+          log.info(`Node ${node.id} result reused input memory`);
+        } else {
+          this.results[node.id] = {
+            start: outputStart,
+            end: outputStart + outLen,
+            _title: `${node.id} ->`
+          };
+          this.allPtrs.push(this.results[node.id]);
+          this.offset += outLen;
+          lastNodePtr = this.results[node.id];
+          log.info(
+            `Node ${node.id} wrote result to memory: start=${outputStart}, end=${outputStart + outLen
+            }`
+          );
+        }
+      }
+
+      const res = this.results[outputNode.id] ?? lastNodePtr;
+      if (!res) throw new Error('Output node produced no result');
+
+      log.info(`Execution finished, output pointer: start=${res.start}, end=${res.end}`);
+      this.refreshView();
+      return this.memoryView.slice(res.start, res.end);
+    } catch (e) {
+      log.info('Execution error:', e);
+      console.error(e);
+    } finally {
+      this.isRunning = false;
+      console.log('Final Memory', [...this.memoryView.slice(0, 20)]);
+      this.perf?.endPoint('runtime');
+      log.info('Executor state reset');
    }
-
-    this.perf?.endPoint('runtime');
-
-    return res as unknown as Int32Array;
  }

  getDebugData() {
--- a/app/src/routes/+page.svelte
+++ b/app/src/routes/+page.svelte
@@ -90,11 +90,6 @@
  let graphSettingTypes = $state({
    randomSeed: { type: 'boolean', value: false }
  });
-  $effect(() => {
-    if (graphSettings && graphSettingTypes) {
-      manager?.setSettings($state.snapshot(graphSettings));
-    }
-  });

  async function update(
    g: Graph,
--- a/app/src/routes/dev/+layout.svelte
+++ b/app/src/routes/dev/+layout.svelte
@@ -3,6 +3,6 @@
  const { children } = $props<{ children?: Snippet }>();
 </script>

-<main class="w-screen overflow-x-hidden">
+<main class="w-screen h-screen overflow-x-hidden">
  {@render children()}
 </main>
--- a/app/src/routes/dev/+page.svelte
+++ b/app/src/routes/dev/+page.svelte
@@ -44,8 +44,9 @@
    }
  }

-  $effect(() => {
-    fetchNodeData(activeNode.value);
+  let graphSettings = $state<Record<string, any>>({});
+  let graphSettingTypes = $state({
+    randomSeed: { type: "boolean", value: false },
  });

  $effect(() => {
@@ -61,19 +62,85 @@
  });
 </script>

-<div class="node-wrapper absolute bottom-8 left-8">
-  {#if nodeInstance}
-    <NodeHTML inView position="relative" z={5} bind:node={nodeInstance} />
-  {/if}
-</div>
+<svelte:window
+  bind:innerHeight={windowHeight}
+  onkeydown={(ev) => ev.key === "r" && handleResult()}
+/>

 <Grid.Row>
  <Grid.Cell>
-    <pre>
-      <code>
-        {JSON.stringify(nodeInstance?.props)}
-      </code>
-    </pre>
+    {#if visibleRows?.length}
+      <table
+        class="min-w-full select-none overflow-auto text-left text-sm flex-1"
+        onscroll={(e) => {
+          const scrollTop = e.currentTarget.scrollTop;
+          start.value = Math.floor(scrollTop / rowHeight);
+        }}
+      >
+        <thead class="">
+          <tr>
+            <th class="px-4 py-2 border-b border-[var(--outline)]">i</th>
+            <th
+              class="px-4 py-2 border-b border-[var(--outline)] w-[50px]"
+              style:width="50px">Ptrs</th
+            >
+            <th class="px-4 py-2 border-b border-[var(--outline)]">Value</th>
+            <th class="px-4 py-2 border-b border-[var(--outline)]">Float</th>
+          </tr>
+        </thead>
+        <tbody
+          onscroll={(e) => {
+            const scrollTop = e.currentTarget.scrollTop;
+            start.value = Math.floor(scrollTop / rowHeight);
+          }}
+        >
+          {#each visibleRows as r, i}
+            {@const index = i + start.value}
+            {@const ptr = ptrs[i]}
+            <tr class="h-[40px] odd:bg-[var(--layer-1)]">
+              <td class="px-4 border-b border-[var(--outline)] w-8">{index}</td>
+              <td
+                class="border-b border-[var(--outline)] overflow-hidden text-ellipsis pl-2
+                        {ptr?._title?.includes('->')
+                  ? 'bg-red-500'
+                  : 'bg-blue-500'}"
+                style="width: 100px; min-width: 100px; max-width: 100px;"
+              >
+                {ptr?._title}
+              </td>
+              <td
+                class="px-4 border-b border-[var(--outline)] cursor-pointer text-blue-600 hover:text-blue-800"
+                onclick={() =>
+                  (rowIsFloat.value[index] = !rowIsFloat.value[index])}
+              >
+                {decodeValue(r, rowIsFloat.value[index])}
+              </td>
+              <td class="px-4 border-b border-[var(--outline)] italic w-5">
+                <input
+                  type="checkbox"
+                  checked={rowIsFloat.value[index]}
+                  onclick={() =>
+                    (rowIsFloat.value[index] = !rowIsFloat.value[index])}
+                />
+              </td>
+            </tr>
+          {/each}
+        </tbody>
+      </table>
+      <button
+        onclick={() => copyVisibleMemory(visibleRows, ptrs, start.value)}
+        class="flex items-center cursor-pointer absolute bottom-4 left-4 z-100 bg-gray-200 px-2 py-1 rounded hover:bg-gray-300"
+      >
+        Copy Visible Memory
+      </button>
+      <input
+        class="absolute bottom-4 right-4 bg-white"
+        bind:value={start.value}
+        min="0"
+        type="number"
+        step="1"
+      />
+    {/if}
  </Grid.Cell>

  <Grid.Cell>
@@ -82,6 +149,20 @@
 </Grid.Row>

 <Sidebar>
+  <Panel id="general" title="General" icon="i-[tabler--settings]">
+    <h3 class="p-4 pb-0">Debug Settings</h3>
+    <NestedSettings
+      id="Debug"
+      bind:value={devSettings.value}
+      type={DevSettingsType}
+    />
+    <hr />
+    <NestedSettings
+      id="general"
+      bind:value={appSettings.value}
+      type={AppSettingTypes}
+    />
+  </Panel>
  <Panel
    id="node-store"
    classes="text-green-400"
--- a/app/src/routes/dev/dev-graph.json
+++ b/app/src/routes/dev/dev-graph.json
@@ -0,0 +1,74 @@
+{
+  "settings": {
+    "resolution.circle": 26,
+    "resolution.curve": 39
+  },
+  "nodes": [
+    {
+      "id": 9,
+      "position": [
+        225,
+        65
+      ],
+      "type": "max/plantarium/output",
+      "props": {
+        "out": 0
+      }
+    },
+    {
+      "id": 10,
+      "position": [
+        200,
+        60
+      ],
+      "type": "max/plantarium/math",
+      "props": {
+        "op_type": 3,
+        "a": 2,
+        "b": 0.38
+      }
+    },
+    {
+      "id": 11,
+      "position": [
+        175,
+        60
+      ],
+      "type": "max/plantarium/float",
+      "props": {
+        "value": 0.66
+      }
+    },
+    {
+      "id": 12,
+      "position": [
+        175,
+        80
+      ],
+      "type": "max/plantarium/float",
+      "props": {
+        "value": 1
+      }
+    }
+  ],
+  "edges": [
+    [
+      11,
+      0,
+      10,
+      "a"
+    ],
+    [
+      12,
+      0,
+      10,
+      "b"
+    ],
+    [
+      10,
+      0,
+      9,
+      "out"
+    ]
+  ]
+}
--- a/app/src/routes/dev/helpers.ts
+++ b/app/src/routes/dev/helpers.ts
@@ -0,0 +1,48 @@
+import type { Pointer } from '$lib/runtime';
+
+export function copyVisibleMemory(rows: Int32Array, currentPtrs: Pointer[], start: number) {
+  if (!rows?.length) return;
+
+  // Build an array of rows for the table
+  const tableRows = [...rows].map((value, i) => {
+    const index = start + i;
+    const ptr = currentPtrs[i];
+    return {
+      index,
+      ptr: ptr?._title ?? '',
+      value: value
+    };
+  });
+
+  // Compute column widths
+  const indexWidth = Math.max(
+    5,
+    ...tableRows.map((r) => r.index.toString().length)
+  );
+  const ptrWidth = Math.max(
+    10,
+    ...tableRows.map((r) => r.ptr.length)
+  );
+  const valueWidth = Math.max(
+    10,
+    ...tableRows.map((r) => r.value.toString().length)
+  );
+
+  // Build header
+  let output =
+    `| ${'Index'.padEnd(indexWidth)} | ${'Ptr'.padEnd(ptrWidth)} | ${'Value'.padEnd(valueWidth)
+    } |\n`
+    + `|-${'-'.repeat(indexWidth)}-|-${'-'.repeat(ptrWidth)}-|-${'-'.repeat(valueWidth)}-|\n`;
+
+  // Add rows
+  for (const row of tableRows) {
+    output += `| ${row.index.toString().padEnd(indexWidth)} | ${row.ptr.padEnd(ptrWidth)} | ${row.value.toString().padEnd(valueWidth)
+      } |\n`;
+  }
+
+  // Copy to clipboard
+  navigator.clipboard
+    .writeText(output)
+    .then(() => console.log('Memory + metadata copied as table'))
+    .catch((err) => console.error('Failed to copy memory:', err));
+}
--- a/app/src/routes/dev/settings.svelte.ts
+++ b/app/src/routes/dev/settings.svelte.ts
@@ -0,0 +1,15 @@
+import { localState } from '$lib/helpers/localState.svelte';
+import { settingsToStore } from '$lib/settings/app-settings.svelte';
+
+export const DevSettingsType = {
+  debugNode: {
+    type: 'boolean',
+    label: 'Debug Nodes',
+    value: true
+  }
+} as const;
+
+export let devSettings = localState(
+  'dev-settings',
+  settingsToStore(DevSettingsType)
+);
--- a/docs/DEVELOPING_NODES.md
+++ b/docs/DEVELOPING_NODES.md
@@ -4,20 +4,19 @@ This guide will help you developing your first Nodarium Node written in Rust. As

 ## Prerequesites

-You need to have [Rust](https://www.rust-lang.org/tools/install) and [wasm-pack](https://rustwasm.github.io/docs/wasm-pack/) installed. Rust is the language we are going to develop our node in and wasm-pack helps us compile our rust code into a webassembly file.
+You need to have [Rust](https://www.rust-lang.org/tools/install) installed. Rust is the language we are going to develop our node in and cargo compiles our rust code into webassembly.

 ```bash
 # install rust
 curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-# install wasm-pack
-cargo install wasm-pack
 ```

 ## Clone Template

 ```bash
-wasm-pack new my-new-node --template https://github.com/jim-fx/nodarium_template
-cd my-new-node
+# copy the template directory
+cp -r nodes/max/plantarium/.template nodes/max/plantarium/my-new-node
+cd nodes/max/plantarium/my-new-node
 ```

 ## Setup Definition
--- a/nodes/max/plantarium/box/src/lib.rs
+++ b/nodes/max/plantarium/box/src/lib.rs
@@ -1,20 +1,18 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
 use nodarium_utils::{
-    encode_float, evaluate_float, geometry::calculate_normals,log,
-    split_args, wrap_arg,
+    encode_float, evaluate_float, geometry::calculate_normals, wrap_arg,
+    read_i32_slice
 };

 nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
+pub fn execute(size: (i32, i32)) -> Vec<i32> {

-    let args = split_args(input);
+    let args = read_i32_slice(size);

-    log!("WASM(cube): input: {:?} -> {:?}", input, args);
-
-    let size = evaluate_float(args[0]);
+    let size = evaluate_float(&args);

    let p = encode_float(size);
    let n = encode_float(-size);
@@ -77,8 +75,6 @@ pub fn execute(input: &[i32]) -> Vec<i32> {

    let res = wrap_arg(&cube_geometry);

-    log!("WASM(box): output: {:?}", res);
-
    res

 }
--- a/nodes/max/plantarium/branch/src/lib.rs
+++ b/nodes/max/plantarium/branch/src/lib.rs
@@ -1,5 +1,6 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
+use nodarium_utils::read_i32_slice;
 use nodarium_utils::{
    concat_arg_vecs, evaluate_float, evaluate_int,
    geometry::{
@@ -13,15 +14,25 @@ use std::f32::consts::PI;
 nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
-    let args = split_args(input);
-
-    let paths = split_args(args[0]);
+pub fn execute(
+    path: (i32, i32),
+    length: (i32, i32),
+    thickness: (i32, i32),
+    offset_single: (i32, i32),
+    lowest_branch: (i32, i32),
+    highest_branch: (i32, i32),
+    depth: (i32, i32),
+    amount: (i32, i32),
+    resolution_curve: (i32, i32),
+    rotation: (i32, i32),
+) -> Vec<i32> {
+    let arg = read_i32_slice(path);
+    let paths = split_args(arg.as_slice());

    let mut output: Vec<Vec<i32>> = Vec::new();

-    let resolution = evaluate_int(args[8]).max(4) as usize;
-    let depth = evaluate_int(args[6]);
+    let resolution = evaluate_int(read_i32_slice(resolution_curve).as_slice()).max(4) as usize;
+    let depth = evaluate_int(read_i32_slice(depth).as_slice());

    let mut max_depth = 0;
    for path_data in paths.iter() {
@@ -40,18 +51,18 @@ pub fn execute(input: &[i32]) -> Vec<i32> {

        let path = wrap_path(path_data);

-        let branch_amount = evaluate_int(args[7]).max(1);
+        let branch_amount = evaluate_int(read_i32_slice(amount).as_slice()).max(1);

-        let lowest_branch = evaluate_float(args[4]);
-        let highest_branch = evaluate_float(args[5]);
+        let lowest_branch = evaluate_float(read_i32_slice(lowest_branch).as_slice());
+        let highest_branch = evaluate_float(read_i32_slice(highest_branch).as_slice());

        for i in 0..branch_amount {
            let a = i as f32 / (branch_amount - 1).max(1) as f32;

-            let length = evaluate_float(args[1]);
-            let thickness = evaluate_float(args[2]);
+            let length = evaluate_float(read_i32_slice(length).as_slice());
+            let thickness = evaluate_float(read_i32_slice(thickness).as_slice());
            let offset_single = if i % 2 == 0 {
-                evaluate_float(args[3])
+                evaluate_float(read_i32_slice(offset_single).as_slice())
            } else {
                0.0
            };
@@ -65,7 +76,8 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
                root_alpha + (offset_single - 0.5) * 6.0 / resolution as f32,
            );

-            let rotation_angle = (evaluate_float(args[9]) * PI / 180.0) * i as f32;
+            let rotation_angle =
+                (evaluate_float(read_i32_slice(rotation).as_slice()) * PI / 180.0) * i as f32;

            // check if diration contains NaN
            if orthogonal[0].is_nan() || orthogonal[1].is_nan() || orthogonal[2].is_nan() {
--- a/nodes/max/plantarium/debug/.gitignore
+++ b/nodes/max/plantarium/debug/.gitignore
@@ -0,0 +1,6 @@
+/target
+**/*.rs.bk
+Cargo.lock
+bin/
+pkg/
+wasm-pack.log
--- a/nodes/max/plantarium/debug/Cargo.toml
+++ b/nodes/max/plantarium/debug/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "debug"
+version = "0.1.0"
+authors = ["Max Richter <jim-x@web.de>"]
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+nodarium_macros = { version = "0.1.0", path = "../../../../packages/macros" }
+nodarium_utils = { version = "0.1.0", path = "../../../../packages/utils" }
--- a/nodes/max/plantarium/debug/src/input.json
+++ b/nodes/max/plantarium/debug/src/input.json
@@ -0,0 +1,22 @@
+{
+  "id": "max/plantarium/debug",
+  "outputs": [],
+  "inputs": {
+    "input": {
+      "type": "float",
+      "accepts": [
+        "*"
+      ],
+      "external": true
+    },
+    "type": {
+      "type": "select",
+      "options": [
+        "float",
+        "vec3",
+        "geometry"
+      ],
+      "internal": true
+    }
+  }
+}
--- a/nodes/max/plantarium/debug/src/lib.rs
+++ b/nodes/max/plantarium/debug/src/lib.rs
@@ -0,0 +1,25 @@
+use nodarium_macros::nodarium_definition_file;
+use nodarium_macros::nodarium_execute;
+use nodarium_utils::encode_float;
+use nodarium_utils::evaluate_float;
+use nodarium_utils::evaluate_vec3;
+use nodarium_utils::read_i32;
+use nodarium_utils::read_i32_slice;
+
+nodarium_definition_file!("src/input.json");
+
+#[nodarium_execute]
+pub fn execute(input: (i32, i32), input_type: (i32, i32)) -> Vec<i32> {
+    let inp = read_i32_slice(input);
+    let t = read_i32(input_type.0);
+    if t == 0 {
+        let f = evaluate_float(inp.as_slice());
+        return vec![encode_float(f)];
+    }
+    if t == 1 {
+        let f = evaluate_vec3(inp.as_slice());
+        return vec![encode_float(f[0]), encode_float(f[1]), encode_float(f[2])];
+    }
+
+    return inp;
+}
--- a/nodes/max/plantarium/float/Cargo.toml
+++ b/nodes/max/plantarium/float/Cargo.toml
@@ -2,11 +2,14 @@
 name = "float"
 version = "0.1.0"
 authors = ["Max Richter <jim-x@web.de>"]
-edition = "2018"
+edition = "2021"

 [lib]
 crate-type = ["cdylib", "rlib"]

+[profile.dev]
+panic = "unwind"
+
 [dependencies]
 nodarium_macros = { version = "0.1.0", path = "../../../../packages/macros" }
 nodarium_utils = { version = "0.1.0", path = "../../../../packages/utils" }
--- a/nodes/max/plantarium/float/src/lib.rs
+++ b/nodes/max/plantarium/float/src/lib.rs
@@ -1,9 +1,10 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
+use nodarium_utils::read_i32;

 nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-pub fn execute(args: &[i32]) -> Vec<i32> {
-    args.into()
+pub fn execute(a: (i32, i32)) -> Vec<i32> {
+    vec![read_i32(a.0)]
 }
--- a/nodes/max/plantarium/gravity/src/lib.rs
+++ b/nodes/max/plantarium/gravity/src/lib.rs
@@ -1,6 +1,7 @@
 use glam::Vec3;
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
+use nodarium_utils::read_i32_slice;
 use nodarium_utils::{
    concat_args, evaluate_float, evaluate_int,
    geometry::{wrap_path, wrap_path_mut},
@@ -14,13 +15,17 @@ fn lerp_vec3(a: Vec3, b: Vec3, t: f32) -> Vec3 {
 }

 #[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
+pub fn execute(
+    plant: (i32, i32),
+    strength: (i32, i32),
+    curviness: (i32, i32),
+    depth: (i32, i32),
+) -> Vec<i32> {
    reset_call_count();

-    let args = split_args(input);
-
-    let plants = split_args(args[0]);
-    let depth = evaluate_int(args[3]);
+    let arg = read_i32_slice(plant);
+    let plants = split_args(arg.as_slice());
+    let depth = evaluate_int(read_i32_slice(depth).as_slice());

    let mut max_depth = 0;
    for path_data in plants.iter() {
@@ -55,9 +60,9 @@ pub fn execute(input: &[i32]) -> Vec<i32> {

                let length = direction.length();

-                let curviness = evaluate_float(args[2]);
-                let strength =
-                    evaluate_float(args[1]) / curviness.max(0.0001) * evaluate_float(args[1]);
+                let str = evaluate_float(read_i32_slice(strength).as_slice());
+                let curviness = evaluate_float(read_i32_slice(curviness).as_slice());
+                let strength = str / curviness.max(0.0001) * str;

                log!(
                    "length: {}, curviness: {}, strength: {}",
--- a/nodes/max/plantarium/instance/src/lib.rs
+++ b/nodes/max/plantarium/instance/src/lib.rs
@@ -13,7 +13,7 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
    let args = split_args(input);
    let mut inputs = split_args(args[0]);

-    let mut geo_data = args[1].to_vec();
+    let mut geo_data = read_i32_slice(geometry);
    let geo = wrap_geometry_data(&mut geo_data);

    let mut transforms: Vec<Mat4> = Vec::new();
--- a/nodes/max/plantarium/math/src/lib.rs
+++ b/nodes/max/plantarium/math/src/lib.rs
@@ -1,13 +1,15 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
-use nodarium_utils::{
-    concat_args, split_args
-};
-
-#[nodarium_execute]
-pub fn execute(args: &[i32]) -> Vec<i32> {
-    let args = split_args(args);
-    concat_args(vec![&[0], args[0], args[1], args[2]])
-}
+use nodarium_utils::log;
+use nodarium_utils::{concat_arg_vecs, read_i32_slice};

 nodarium_definition_file!("src/input.json");
+
+#[nodarium_execute]
+pub fn execute(op_type: (i32, i32), a: (i32, i32), b: (i32, i32)) -> Vec<i32> {
+    log!("math.op {:?}", op_type);
+    let op = read_i32_slice(op_type);
+    let a_val = read_i32_slice(a);
+    let b_val = read_i32_slice(b);
+    concat_arg_vecs(vec![vec![0], op, a_val, b_val])
+}
--- a/nodes/max/plantarium/noise/Cargo.toml
+++ b/nodes/max/plantarium/noise/Cargo.toml
@@ -2,7 +2,7 @@
 name = "noise"
 version = "0.1.0"
 authors = ["Max Richter <jim-x@web.de>"]
-edition = "2018"
+edition = "2021"

 [lib]
 crate-type = ["cdylib", "rlib"]
--- a/nodes/max/plantarium/noise/src/lib.rs
+++ b/nodes/max/plantarium/noise/src/lib.rs
@@ -1,7 +1,8 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
+use nodarium_utils::read_i32_slice;
 use nodarium_utils::{
-    concat_args, evaluate_float, evaluate_int, evaluate_vec3, geometry::wrap_path_mut,
+    concat_args, evaluate_float, evaluate_int, evaluate_vec3, geometry::wrap_path_mut, read_i32,
    reset_call_count, split_args,
 };
 use noise::{HybridMulti, MultiFractal, NoiseFn, OpenSimplex};
@@ -13,23 +14,31 @@ fn lerp(a: f32, b: f32, t: f32) -> f32 {
 }

 #[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
+pub fn execute(
+    plant: (i32, i32),
+    scale: (i32, i32),
+    strength: (i32, i32),
+    fix_bottom: (i32, i32),
+    seed: (i32, i32),
+    directional_strength: (i32, i32),
+    depth: (i32, i32),
+    octaves: (i32, i32),
+) -> Vec<i32> {
    reset_call_count();

-    let args = split_args(input);
+    let arg = read_i32_slice(plant);
+    let plants = split_args(arg.as_slice());
+    let scale = (evaluate_float(read_i32_slice(scale).as_slice()) * 0.1) as f64;
+    let strength = evaluate_float(read_i32_slice(strength).as_slice());
+    let fix_bottom = evaluate_float(read_i32_slice(fix_bottom).as_slice());

-    let plants = split_args(args[0]);
-    let scale = (evaluate_float(args[1]) * 0.1) as f64;
-    let strength = evaluate_float(args[2]);
-    let fix_bottom = evaluate_float(args[3]);
+    let seed = read_i32(seed.0);

-    let seed = args[4][0];
+    let directional_strength = evaluate_vec3(read_i32_slice(directional_strength).as_slice());

-    let directional_strength = evaluate_vec3(args[5]);
+    let depth = evaluate_int(read_i32_slice(depth).as_slice());

-    let depth = evaluate_int(args[6]);
-
-    let octaves = evaluate_int(args[7]);
+    let octaves = evaluate_int(read_i32_slice(octaves).as_slice());

    let noise_x: HybridMulti<OpenSimplex> =
        HybridMulti::new(seed as u32 + 1).set_octaves(octaves as usize);
--- a/nodes/max/plantarium/output/src/inputs.json
+++ b/nodes/max/plantarium/output/src/inputs.json
@@ -5,7 +5,7 @@
    "input": {
      "type": "path",
      "accepts": [
-        "geometry"
+        "*"
      ],
      "external": true
    },
--- a/nodes/max/plantarium/output/src/lib.rs
+++ b/nodes/max/plantarium/output/src/lib.rs
@@ -1,44 +1,11 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
-use nodarium_utils::{
-    concat_args, evaluate_int,
-    geometry::{extrude_path, wrap_path},
-    log, split_args,
-};
+use nodarium_utils::read_i32_slice;

-nodarium_definition_file!("src/inputs.json");
+nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
-    log!("WASM(output): input: {:?}", input);
-
-    let args = split_args(input);
-
-    log!("WASM(output) args: {:?}", args);
-
-    assert_eq!(args.len(), 2, "Expected 2 arguments, got {}", args.len());
-    let inputs = split_args(args[0]);
-
-    let resolution = evaluate_int(args[1]) as usize;
-
-    log!("inputs: {}, resolution: {}", inputs.len(), resolution);
-
-    let mut output: Vec<Vec<i32>> = Vec::new();
-    for arg in inputs {
-        let arg_type = arg[2];
-        log!("arg_type: {}, \n {:?}", arg_type, arg,);
-
-        if arg_type == 0 {
-            // if this is path we need to extrude it
-            output.push(arg.to_vec());
-            let path_data = wrap_path(arg);
-            let geometry = extrude_path(path_data, resolution);
-            output.push(geometry);
-            continue;
-        }
-
-        output.push(arg.to_vec());
-    }
-
-    concat_args(output.iter().map(|v| v.as_slice()).collect())
+pub fn execute(input: (i32, i32), _res: (i32, i32)) -> Vec<i32> {
+    let inp = read_i32_slice(input);
+    return inp;
 }
--- a/nodes/max/plantarium/random/src/definition.json
+++ b/nodes/max/plantarium/random/src/definition.json
--- a/nodes/max/plantarium/random/src/lib.rs
+++ b/nodes/max/plantarium/random/src/lib.rs
@@ -1,11 +1,17 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
-use nodarium_utils::{concat_args, split_args};
+use nodarium_utils::concat_arg_vecs;
+use nodarium_utils::read_i32_slice;

-nodarium_definition_file!("src/definition.json");
+nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-pub fn execute(args: &[i32]) -> Vec<i32> {
-    let args = split_args(args);
-    concat_args(vec![&[1], args[0], args[1], args[2]])
+pub fn execute(min: (i32, i32), max: (i32, i32), seed: (i32, i32)) -> Vec<i32> {
+    nodarium_utils::log!("random execute start");
+    concat_arg_vecs(vec![
+        vec![1],
+        read_i32_slice(min),
+        read_i32_slice(max),
+        read_i32_slice(seed),
+    ])
 }
--- a/nodes/max/plantarium/rotate/src/lib.rs
+++ b/nodes/max/plantarium/rotate/src/lib.rs
@@ -1,23 +1,26 @@
 use glam::{Mat4, Vec3};
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
+use nodarium_utils::read_i32_slice;
 use nodarium_utils::{
-    concat_args, evaluate_float, evaluate_int, geometry::wrap_path_mut, log,
-    split_args,
+    concat_args, evaluate_float, evaluate_int, geometry::wrap_path_mut, log, split_args,
 };

 nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
+pub fn execute(
+    plant: (i32, i32),
+    axis: (i32, i32),
+    angle: (i32, i32),
+    spread: (i32, i32),
+) -> Vec<i32> {
+    log!("DEBUG args: {:?}", plant);

-    log!("DEBUG args: {:?}", input);
-
-    let args = split_args(input);
-
-    let plants = split_args(args[0]);
-    let axis = evaluate_int(args[1]); // 0 =x, 1 = y, 2 = z
-    let spread = evaluate_int(args[3]);
+    let arg = read_i32_slice(plant);
+    let plants = split_args(arg.as_slice());
+    let axis = evaluate_int(read_i32_slice(axis).as_slice()); // 0 =x, 1 = y, 2 = z
+    let spread = evaluate_int(read_i32_slice(spread).as_slice());

    let output: Vec<Vec<i32>> = plants
        .iter()
@@ -32,7 +35,7 @@ pub fn execute(input: &[i32]) -> Vec<i32> {

            let path = wrap_path_mut(&mut path_data);

-            let angle = evaluate_float(args[2]);
+            let angle = evaluate_float(read_i32_slice(angle).as_slice());

            let origin = [path.points[0], path.points[1], path.points[2]];

--- a/nodes/max/plantarium/stem/src/lib.rs
+++ b/nodes/max/plantarium/stem/src/lib.rs
@@ -3,30 +3,29 @@ use nodarium_macros::nodarium_execute;
 use nodarium_utils::{
    evaluate_float, evaluate_int, evaluate_vec3,
    geometry::{create_multiple_paths, wrap_multiple_paths},
-    log, reset_call_count, split_args,
+    log, reset_call_count,
+    read_i32_slice, read_i32, 
 };

 nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
+pub fn execute(origin: (i32, i32), _amount: (i32,i32), length: (i32, i32), thickness: (i32, i32), resolution_curve: (i32, i32)) -> Vec<i32> {
    reset_call_count();

-    let args = split_args(input);
+    let amount = evaluate_int(read_i32_slice(_amount).as_slice()) as usize;
+    let path_resolution = read_i32(resolution_curve.0) as usize;

-    let amount = evaluate_int(args[1]) as usize;
-    let path_resolution = evaluate_int(args[4]) as usize;
-
-    log!("stem args: {:?}", args);
+    log!("stem args: amount={:?}", amount);

    let mut stem_data = create_multiple_paths(amount, path_resolution, 1);

    let mut stems = wrap_multiple_paths(&mut stem_data);

    for stem in stems.iter_mut() {
-        let origin = evaluate_vec3(args[0]);
-        let length = evaluate_float(args[2]);
-        let thickness = evaluate_float(args[3]);
+        let origin = evaluate_vec3(read_i32_slice(origin).as_slice());
+        let length = evaluate_float(read_i32_slice(length).as_slice());
+        let thickness = evaluate_float(read_i32_slice(thickness).as_slice());
        let amount_points = stem.points.len() / 4;

        for i in 0..amount_points {
--- a/nodes/max/plantarium/triangle/src/lib.rs
+++ b/nodes/max/plantarium/triangle/src/lib.rs
@@ -1,45 +1,48 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
-use nodarium_utils::{
-    decode_float, encode_float, evaluate_int, split_args, wrap_arg, log
-};
+use nodarium_utils::read_i32_slice;
+use nodarium_utils::{decode_float, encode_float, evaluate_int, log, wrap_arg};

 nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
-
-    let args = split_args(input);
-
-    let size = evaluate_int(args[0]);
+pub fn execute(size: (i32, i32)) -> Vec<i32> {
+    let size = evaluate_int(read_i32_slice(size).as_slice());
    let decoded = decode_float(size);
    let negative_size = encode_float(-decoded);

-    log!("WASM(triangle): input: {:?} -> {}", args[0],decoded);
+    log!("WASM(triangle): input: {:?} -> {}", size, decoded);

    // [[1,3, x, y, z, x, y,z,x,y,z]];
    wrap_arg(&[
-        1,          // 1: geometry
-        3,          // 3 vertices
-        1,          // 1 face
+        1, // 1: geometry
+        3, // 3 vertices
+        1, // 1 face
        // this are the indeces for the face
-        0, 2, 1,
+        0,
+        2,
+        1,
        //
-        negative_size,  // x -> point 1
-        0,              // y
-        0,              // z
+        negative_size, // x -> point 1
+        0,             // y
+        0,             // z
        //
-        size,       // x -> point 2
-        0,          // y
-        0,          // z
+        size, // x -> point 2
+        0,    // y
+        0,    // z
        //
-        0,          // x -> point 3
-        0,          // y
-        size,       // z
+        0,    // x -> point 3
+        0,    // y
+        size, // z
        // this is the normal for the single face 1065353216 == 1.0f encoded is i32
-        0, 1065353216, 0,
-        0, 1065353216, 0,
-        0, 1065353216, 0,
+        0,
+        1065353216,
+        0,
+        0,
+        1065353216,
+        0,
+        0,
+        1065353216,
+        0,
    ])
-
 }
--- a/nodes/max/plantarium/vec3/src/lib.rs
+++ b/nodes/max/plantarium/vec3/src/lib.rs
@@ -1,13 +1,17 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
-use nodarium_utils::{concat_args, log, split_args};
+use nodarium_utils::concat_args;
+use nodarium_utils::log;
+use nodarium_utils::read_i32_slice;

 nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
-    let args = split_args(input);
-    log!("vec3 input: {:?}", input);
-    log!("vec3 args: {:?}", args);
-    concat_args(args)
+pub fn execute(x: (i32, i32), y: (i32, i32), z: (i32, i32)) -> Vec<i32> {
+    log!("vec3 x: {:?}", x);
+    concat_args(vec![
+        read_i32_slice(x).as_slice(),
+        read_i32_slice(y).as_slice(),
+        read_i32_slice(z).as_slice(),
+    ])
 }
--- a/packages/macros/src/lib.rs
+++ b/packages/macros/src/lib.rs
@@ -6,96 +6,202 @@ use std::env;
 use std::fs;
 use std::path::Path;
 use syn::parse_macro_input;
+use syn::spanned::Spanned;

 fn add_line_numbers(input: String) -> String {
-    return input
+    input
        .split('\n')
        .enumerate()
        .map(|(i, line)| format!("{:2}: {}", i + 1, line))
        .collect::<Vec<String>>()
-        .join("\n");
+        .join("\n")
+}
+
+fn read_node_definition(file_path: &Path) -> NodeDefinition {
+    let project_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let full_path = Path::new(&project_dir).join(file_path);
+    let json_content = fs::read_to_string(&full_path).unwrap_or_else(|err| {
+        panic!(
+            "Failed to read JSON file at '{}/{}': {}",
+            project_dir,
+            file_path.to_string_lossy(),
+            err
+        )
+    });
+    serde_json::from_str(&json_content).unwrap_or_else(|err| {
+        panic!(
+            "JSON file contains invalid JSON: \n{} \n{}",
+            err,
+            add_line_numbers(json_content.clone())
+        )
+    })
 }

 #[proc_macro_attribute]
 pub fn nodarium_execute(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input_fn = parse_macro_input!(item as syn::ItemFn);
-    let _fn_name = &input_fn.sig.ident;
-    let _fn_vis = &input_fn.vis;
+    let fn_name = &input_fn.sig.ident;
+    let fn_vis = &input_fn.vis;
    let fn_body = &input_fn.block;
+    let inner_fn_name = syn::Ident::new(&format!("__nodarium_inner_{}", fn_name), fn_name.span());

-    let first_arg_ident = if let Some(syn::FnArg::Typed(pat_type)) = input_fn.sig.inputs.first() {
-        if let syn::Pat::Ident(pat_ident) = &*pat_type.pat {
-            &pat_ident.ident
-        } else {
-            panic!("Expected a simple identifier for the first argument");
-        }
-    } else {
-        panic!("The execute function must have at least one argument (the input slice)");
-    };
+    let def: NodeDefinition = read_node_definition(Path::new("src/input.json"));
+
+    let input_count = def.inputs.as_ref().map(|i| i.len()).unwrap_or(0);
+
+    validate_signature(&input_fn.sig, input_count, &def);
+
+    let input_param_names: Vec<_> = input_fn
+        .sig
+        .inputs
+        .iter()
+        .filter_map(|arg| {
+            if let syn::FnArg::Typed(pat_type) = arg {
+                if let syn::Pat::Ident(pat_ident) = &*pat_type.pat {
+                    Some(pat_ident.ident.clone())
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    let param_count = input_fn.sig.inputs.len();
+    let total_c_params = param_count * 2;
+
+    let arg_names: Vec<_> = (0..total_c_params)
+        .map(|i| syn::Ident::new(&format!("arg{i}"), input_fn.sig.span()))
+        .collect();
+
+    let mut tuple_args = Vec::new();
+    for i in 0..param_count {
+        let start_name = &arg_names[i * 2];
+        let end_name = &arg_names[i * 2 + 1];
+        let tuple_arg = quote! {
+            (#start_name, #end_name)
+        };
+        tuple_args.push(tuple_arg);
+    }

-    // We create a wrapper that handles the C ABI and pointer math
    let expanded = quote! {
+
        extern "C" {
-            fn host_log_panic(ptr: *const u8, len: usize);
-            fn host_log(ptr: *const u8, len: usize);
+            fn __nodarium_log(ptr: *const u8, len: usize);
        }

-        fn setup_panic_hook() {
-            static SET_HOOK: std::sync::Once = std::sync::Once::new();
-            SET_HOOK.call_once(|| {
-                std::panic::set_hook(Box::new(|info| {
-                    let msg = info.to_string();
-                    unsafe { host_log_panic(msg.as_ptr(), msg.len()); }
-                }));
-            });
-        }
-        
-        #[no_mangle]
-        pub extern "C" fn __alloc(len: usize) -> *mut i32 {
-            let mut buf = Vec::with_capacity(len);
-            let ptr = buf.as_mut_ptr();
-            std::mem::forget(buf);
-            ptr
+        #[cfg(target_arch = "wasm32")]
+        fn init_panic_hook() {
+            std::panic::set_hook(Box::new(|_info| {
+                unsafe {
+                    __nodarium_log(b"PANIC\0".as_ptr(), 5);
+                }
+            }));
        }

        #[no_mangle]
-        pub extern "C" fn __free(ptr: *mut i32, len: usize) {
-            unsafe {
-                let _ = Vec::from_raw_parts(ptr, 0, len);
-            }
+        pub extern "C" fn init_allocator() {
+            nodarium_utils::allocator::ALLOCATOR.init();
        }

-        static mut OUTPUT_BUFFER: Vec<i32> = Vec::new();
-
-        #[no_mangle]
-        pub extern "C" fn execute(ptr: *const i32, len: usize) -> *mut i32 {
-            setup_panic_hook();
-            // 1. Convert raw pointer to slice
-            let input = unsafe { core::slice::from_raw_parts(ptr, len) };
-
-            // 2. Call the logic (which we define below)
-            let result_data: Vec<i32> = internal_logic(input);
-
-            // 3. Use the static buffer for the result
-            let result_len = result_data.len();
-            unsafe {
-                OUTPUT_BUFFER.clear();
-                OUTPUT_BUFFER.reserve(result_len + 1);
-                OUTPUT_BUFFER.push(result_len as i32);
-                OUTPUT_BUFFER.extend(result_data);
-                
-                OUTPUT_BUFFER.as_mut_ptr()
-            }
-        }
-
-        fn internal_logic(#first_arg_ident: &[i32]) -> Vec<i32> {
+        #fn_vis fn #inner_fn_name(#( #input_param_names: (i32, i32) ),*) -> Vec<i32> {
            #fn_body
        }
+
+        #[no_mangle]
+        #fn_vis extern "C" fn execute(output_pos: i32, #( #arg_names: i32 ),*) -> i32 {
+
+            nodarium_utils::allocator::ALLOCATOR.init();
+            #[cfg(target_arch = "wasm32")]
+            init_panic_hook();
+            nodarium_utils::log!("before_fn");
+            let result = #inner_fn_name(
+                #( #tuple_args ),*
+            );
+            nodarium_utils::log!("after_fn: result_len={}", result.len());
+
+            let len_bytes = result.len() * 4;
+            unsafe {
+                let src = result.as_ptr() as *const u8;
+                let dst = output_pos as *mut u8;
+                nodarium_utils::log!("writing output_pos={:?} src={:?} len_bytes={:?}", output_pos, src, len_bytes);
+                dst.copy_from_nonoverlapping(src, len_bytes);
+            }
+
+            len_bytes as i32
+        }
    };

    TokenStream::from(expanded)
 }

+fn validate_signature(fn_sig: &syn::Signature, expected_inputs: usize, def: &NodeDefinition) {
+    let param_count = fn_sig.inputs.len();
+    let expected_params = expected_inputs;
+
+    if param_count != expected_params {
+        panic!(
+            "Execute function has {} parameters but definition has {} inputs\n\
+             Definition inputs: {:?}\n\
+             Expected signature:\n\
+             pub fn execute({}) -> Vec<i32>",
+            param_count,
+            expected_inputs,
+            def.inputs
+                .as_ref()
+                .map(|i| i.keys().collect::<Vec<_>>())
+                .unwrap_or_default(),
+            (0..expected_inputs)
+                .map(|i| format!("arg{i}: (i32, i32)"))
+                .collect::<Vec<_>>()
+                .join(", ")
+        );
+    }
+
+    for (i, arg) in fn_sig.inputs.iter().enumerate() {
+        match arg {
+            syn::FnArg::Typed(pat_type) => {
+                let type_str = quote! { #pat_type.ty }.to_string();
+                let clean_type = type_str
+                    .trim()
+                    .trim_start_matches("_")
+                    .trim_end_matches(".ty")
+                    .trim()
+                    .to_string();
+                if !clean_type.contains("(") && !clean_type.contains(",") {
+                    panic!(
+                        "Parameter {i} has type '{clean_type}' but should be a tuple (i32, i32) representing (start, end) positions in memory",
+                    );
+                }
+            }
+            syn::FnArg::Receiver(_) => {
+                panic!("Execute function cannot have 'self' parameter");
+            }
+        }
+    }
+
+    match &fn_sig.output {
+        syn::ReturnType::Type(_, ty) => {
+            let is_vec = match &**ty {
+                syn::Type::Path(tp) => tp
+                    .path
+                    .segments
+                    .first()
+                    .map(|seg| seg.ident == "Vec")
+                    .unwrap_or(false),
+                _ => false,
+            };
+            if !is_vec {
+                panic!("Execute function must return Vec<i32>");
+            }
+        }
+        syn::ReturnType::Default => {
+            panic!("Execute function must return Vec<i32>");
+        }
+    }
+}
+
 #[proc_macro]
 pub fn nodarium_definition_file(input: TokenStream) -> TokenStream {
    let path_lit = syn::parse_macro_input!(input as syn::LitStr);
@@ -105,30 +211,23 @@ pub fn nodarium_definition_file(input: TokenStream) -> TokenStream {
    let full_path = Path::new(&project_dir).join(&file_path);

    let json_content = fs::read_to_string(&full_path).unwrap_or_else(|err| {
-        panic!("Failed to read JSON file at '{}/{}': {}", project_dir, file_path, err)
+        panic!("Failed to read JSON file at '{project_dir}/{file_path}': {err}",)
    });

    let _: NodeDefinition = serde_json::from_str(&json_content).unwrap_or_else(|err| {
-        panic!("JSON file contains invalid JSON: \n{} \n{}", err, add_line_numbers(json_content.clone()))
+        panic!(
+            "JSON file contains invalid JSON: \n{} \n{}",
+            err,
+            add_line_numbers(json_content.clone())
+        )
    });

-    // We use the span from the input path literal
    let bytes = syn::LitByteStr::new(json_content.as_bytes(), path_lit.span());
    let len = json_content.len();

    let expanded = quote! {
        #[link_section = "nodarium_definition"]
        static DEFINITION_DATA: [u8; #len] = *#bytes;
-        
-        #[no_mangle]
-        pub extern "C" fn get_definition_ptr() -> *const u8 {
-            DEFINITION_DATA.as_ptr()
-        }
-
-        #[no_mangle]
-        pub extern "C" fn get_definition_len() -> usize {
-            DEFINITION_DATA.len()
-        }
    };

    TokenStream::from(expanded)
--- a/packages/types/package.json
+++ b/packages/types/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@nodarium/types",
-  "version": "0.0.4",
+  "version": "0.0.5",
  "description": "",
  "main": "src/index.ts",
  "scripts": {
--- a/packages/types/src/inputs.ts
+++ b/packages/types/src/inputs.ts
@@ -9,6 +9,7 @@ const DefaultOptionsSchema = z.object({
  accepts: z
    .array(
      z.union([
+        z.literal('*'),
        z.literal('float'),
        z.literal('integer'),
        z.literal('boolean'),
--- a/packages/types/src/types.ts
+++ b/packages/types/src/types.ts
@@ -21,7 +21,7 @@ export type NodeRuntimeState = {
  parents?: NodeInstance[];
  children?: NodeInstance[];
  inputNodes?: Record<string, NodeInstance>;
-  type?: NodeDefinition;
+  type?: NodeDefinition; // we should probably remove this and rely on registry.getNode(nodeType)
  downX?: number;
  downY?: number;
  x?: number;
@@ -65,7 +65,7 @@ export const NodeSchema = z.object({
 export type SerializedNode = z.infer<typeof NodeSchema>;

 export type NodeDefinition = z.infer<typeof NodeDefinitionSchema> & {
-  execute(input: Int32Array): Int32Array;
+  execute(outputPos: number, args: number[]): number;
 };

 export type Socket = {
--- a/packages/ui/package.json
+++ b/packages/ui/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@nodarium/ui",
-  "version": "0.0.4",
+  "version": "0.0.5",
  "scripts": {
    "dev": "vite",
    "build": "vite build && npm run package",
--- a/packages/utils/Cargo.toml
+++ b/packages/utils/Cargo.toml
@@ -9,6 +9,10 @@ description = "A collection of utilities for Nodarium"
 [lib]
 crate-type = ["rlib"]

+[features]
+default = ["std"]
+std = []
+
 [dependencies]
 glam = "0.30.10"
 noise = "0.9.0"
--- a/packages/utils/package.json
+++ b/packages/utils/package.json
@@ -1,8 +1,9 @@
 {
  "name": "@nodarium/utils",
-  "version": "0.0.4",
+  "version": "0.0.5",
  "description": "",
-  "main": "src/index.ts",
+  "main": "./src/index.ts",
+  "type": "module",
  "scripts": {
    "test": "vitest",
    "format": "dprint fmt -c '../../.dprint.jsonc' .",
--- a/packages/utils/src/allocator.rs
+++ b/packages/utils/src/allocator.rs
@@ -0,0 +1,68 @@
+use core::alloc::{GlobalAlloc, Layout};
+use core::sync::atomic::{AtomicUsize, Ordering};
+
+extern "C" {
+    fn __wasm_memory_size() -> usize;
+    fn __nodarium_manual_end() -> usize;
+}
+
+#[allow(dead_code)]
+const WASM_PAGE_SIZE: usize = 64 * 1024;
+
+pub struct UpwardBumpAllocator {
+    heap_base: AtomicUsize,
+}
+
+impl Default for UpwardBumpAllocator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl UpwardBumpAllocator {
+    pub const fn new() -> Self {
+        Self {
+            heap_base: AtomicUsize::new(0),
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn init(&self) {
+        // Start heap at 10000 to leave space for data sections
+        self.heap_base.store(10000, Ordering::Relaxed);
+    }
+}
+
+#[global_allocator]
+pub static ALLOCATOR: UpwardBumpAllocator = UpwardBumpAllocator::new();
+
+unsafe impl GlobalAlloc for UpwardBumpAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let align = layout.align();
+        let size = layout.size();
+
+        let mut current = self.heap_base.load(Ordering::Relaxed);
+
+        loop {
+            let aligned = (current + align - 1) & !(align - 1);
+            let new_current = aligned + size;
+
+            let manual_end = unsafe { __nodarium_manual_end() };
+            if new_current > manual_end {
+                return core::ptr::null_mut();
+            }
+
+            match self.heap_base.compare_exchange(
+                current,
+                new_current,
+                Ordering::SeqCst,
+                Ordering::Relaxed,
+            ) {
+                Ok(_) => return aligned as *mut u8,
+                Err(next) => current = next,
+            }
+        }
+    }
+
+    unsafe fn dealloc(&self, _: *mut u8, _: Layout) {}
+}
--- a/packages/utils/src/encoding.rs
+++ b/packages/utils/src/encoding.rs
@@ -1,3 +1,5 @@
+use crate::log;
+
 pub fn encode_float(f: f32) -> i32 {
    // Convert f32 to u32 using to_bits, then safely cast to i32
    let bits = f.to_bits();
@@ -10,6 +12,52 @@ pub fn decode_float(bits: i32) -> f32 {
    f32::from_bits(bits)
 }

+#[inline]
+pub fn read_i32(ptr: i32) -> i32 {
+    log!("read_i32 ptr: {:?}", ptr);
+    unsafe {
+        let _ptr = ptr as *const i32;
+        *_ptr
+    }
+}
+
+#[inline]
+pub fn read_f32(ptr: i32) -> f32 {
+    unsafe {
+        let _ptr = ptr as *const i32;
+        f32::from_bits(*_ptr as u32)
+    }
+}
+
+#[inline]
+pub fn read_i32_slice(range: (i32, i32)) -> Vec<i32> {
+    log!("read_i32_slice ptr: {:?}", range);
+    let (start, end) = range;
+    assert!(end >= start);
+    let byte_len = (end - start) as usize;
+    assert!(byte_len % 4 == 0);
+
+    unsafe {
+        let ptr = start as *const i32;
+        let len = byte_len / 4;
+        std::slice::from_raw_parts(ptr, len).to_vec()
+    }
+}
+
+#[inline]
+pub fn read_f32_slice(range: (i32, i32)) -> Vec<f32> {
+    let (start, end) = range;
+    assert!(end >= start);
+    let byte_len = (end - start) as usize;
+    assert!(byte_len % 4 == 0);
+
+    unsafe {
+        let ptr = start as *const f32;
+        let len = byte_len / 4;
+        std::slice::from_raw_parts(ptr, len).to_vec()
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/packages/utils/src/lib.rs
+++ b/packages/utils/src/lib.rs
@@ -1,3 +1,4 @@
+pub mod allocator;
 mod encoding;
 mod nodes;
 mod tree;
@@ -8,30 +9,30 @@ pub mod geometry;

 extern "C" {
    #[cfg(target_arch = "wasm32")]
-    pub fn host_log(ptr: *const u8, len: usize);
+    pub fn __nodarium_log(ptr: *const u8, len: usize);
 }

-#[cfg(debug_assertions)]
+// #[cfg(debug_assertions)]
 #[macro_export]
 macro_rules! log {
    ($($t:tt)*) => {{
        let msg = std::format!($($t)*);
        #[cfg(target_arch = "wasm32")]
        unsafe {
-            $crate::host_log(msg.as_ptr(), msg.len());
+            $crate::__nodarium_log(msg.as_ptr(), msg.len());
        }
        #[cfg(not(target_arch = "wasm32"))]
        println!("{}", msg);
    }}
 }

-#[cfg(not(debug_assertions))]
-#[macro_export]
-macro_rules! log {
-    ($($arg:tt)*) => {{
-        // This will expand to nothing in release builds
-    }};
-}
+// #[cfg(not(debug_assertions))]
+// #[macro_export]
+// macro_rules! log {
+//     ($($arg:tt)*) => {{
+//         // This will expand to nothing in release builds
+//     }};
+// }

 #[allow(dead_code)]
 #[rustfmt::skip]
--- a/packages/utils/src/wasm-wrapper.ts
+++ b/packages/utils/src/wasm-wrapper.ts
@@ -1,21 +1,22 @@
 interface NodariumExports extends WebAssembly.Exports {
  memory: WebAssembly.Memory;
-  execute: (ptr: number, len: number) => number;
-  __free: (ptr: number, len: number) => void;
-  __alloc: (len: number) => number;
+  execute: (outputPos: number, ...args: number[]) => number;
+  init_allocator: () => void;
 }

-export function createWasmWrapper(buffer: ArrayBuffer) {
+export function createWasmWrapper(buffer: ArrayBuffer, memory: WebAssembly.Memory) {
  let exports: NodariumExports;

+  let end = 0;
  const importObject = {
    env: {
-      host_log_panic: (ptr: number, len: number) => {
+      memory: memory,
+      __nodarium_log_panic: (ptr: number, len: number) => {
        if (!exports) return;
        const view = new Uint8Array(exports.memory.buffer, ptr, len);
        console.error('RUST PANIC:', new TextDecoder().decode(view));
      },
-      host_log: (ptr: number, len: number) => {
+      __nodarium_log: (ptr: number, len: number) => {
        if (!exports) return;
        const view = new Uint8Array(exports.memory.buffer, ptr, len);
        console.log('RUST:', new TextDecoder().decode(view));
@@ -26,20 +27,11 @@ export function createWasmWrapper(buffer: ArrayBuffer) {
  const module = new WebAssembly.Module(buffer);
  const instance = new WebAssembly.Instance(module, importObject);
  exports = instance.exports as NodariumExports;
+  exports.init_allocator();

-  function execute(args: Int32Array) {
-    const inPtr = exports.__alloc(args.length);
-    new Int32Array(exports.memory.buffer).set(args, inPtr / 4);
-
-    const outPtr = exports.execute(inPtr, args.length);
-
-    const i32Result = new Int32Array(exports.memory.buffer);
-    const outLen = i32Result[outPtr / 4];
-    const out = i32Result.slice(outPtr / 4 + 1, outPtr / 4 + 1 + outLen);
-
-    exports.__free(inPtr, args.length);
-
-    return out;
+  function execute(outputPos: number, args: number[]): number {
+    end = outputPos;
+    return exports.execute(outputPos, ...args);
  }

  function get_definition() {
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -31,10 +31,10 @@ importers:
        version: link:../packages/utils
      '@sveltejs/kit':
        specifier: ^2.50.2
-        version: 2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+        version: 2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@tailwindcss/vite':
        specifier: ^4.1.18
-        version: 4.1.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+        version: 4.1.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@threlte/core':
        specifier: 8.3.1
        version: 8.3.1(svelte@5.49.2)(three@0.182.0)
@@ -83,10 +83,10 @@ importers:
        version: 1.58.1
      '@sveltejs/adapter-static':
        specifier: ^3.0.10
-        version: 3.0.10(@sveltejs/kit@2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))
+        version: 3.0.10(@sveltejs/kit@2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))
      '@sveltejs/vite-plugin-svelte':
        specifier: ^6.2.4
-        version: 6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+        version: 6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@tsconfig/svelte':
        specifier: ^5.0.7
        version: 5.0.7
@@ -98,7 +98,7 @@ importers:
        version: 0.182.0
      '@vitest/browser-playwright':
        specifier: ^4.0.18
-        version: 4.0.18(playwright@1.58.1)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)
+        version: 4.0.18(playwright@1.58.1)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)
      dprint:
        specifier: ^0.51.1
        version: 0.51.1
@@ -120,6 +120,9 @@ importers:
      tslib:
        specifier: ^2.8.1
        version: 2.8.1
+      tsx:
+        specifier: ^4.21.0
+        version: 4.21.0
      typescript:
        specifier: ^5.9.3
        version: 5.9.3
@@ -128,19 +131,19 @@ importers:
        version: 8.54.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
      vite:
        specifier: ^7.3.1
-        version: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+        version: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
      vite-plugin-comlink:
        specifier: ^5.3.0
-        version: 5.3.0(comlink@4.4.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+        version: 5.3.0(comlink@4.4.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      vite-plugin-glsl:
        specifier: ^1.5.5
-        version: 1.5.5(@rollup/pluginutils@5.1.4(rollup@4.57.1))(esbuild@0.27.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+        version: 1.5.5(@rollup/pluginutils@5.1.4(rollup@4.57.1))(esbuild@0.27.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      vite-plugin-wasm:
        specifier: ^3.5.0
-        version: 3.5.0(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+        version: 3.5.0(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      vitest:
        specifier: ^4.0.18
-        version: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+        version: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
      vitest-browser-svelte:
        specifier: ^2.0.2
        version: 2.0.2(svelte@5.49.2)(vitest@4.0.18)
@@ -165,7 +168,7 @@ importers:
        version: 1.2.1(tailwindcss@4.1.18)
      '@tailwindcss/vite':
        specifier: ^4.1.18
-        version: 4.1.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+        version: 4.1.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@threlte/core':
        specifier: ^8.3.1
        version: 8.3.1(svelte@5.49.2)(three@0.182.0)
@@ -193,19 +196,19 @@ importers:
        version: 1.58.1
      '@sveltejs/adapter-static':
        specifier: ^3.0.10
-        version: 3.0.10(@sveltejs/kit@2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))
+        version: 3.0.10(@sveltejs/kit@2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))
      '@sveltejs/kit':
        specifier: ^2.50.2
-        version: 2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+        version: 2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@sveltejs/package':
        specifier: ^2.5.7
        version: 2.5.7(svelte@5.49.2)(typescript@5.9.3)
      '@sveltejs/vite-plugin-svelte':
        specifier: ^6.2.4
-        version: 6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+        version: 6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@testing-library/svelte':
        specifier: ^5.3.1
-        version: 5.3.1(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)
+        version: 5.3.1(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)
      '@types/eslint':
        specifier: ^9.6.1
        version: 9.6.1
@@ -220,7 +223,7 @@ importers:
        version: 8.54.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
      '@vitest/browser-playwright':
        specifier: ^4.0.18
-        version: 4.0.18(playwright@1.58.1)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)
+        version: 4.0.18(playwright@1.58.1)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)
      dprint:
        specifier: ^0.51.1
        version: 0.51.1
@@ -256,10 +259,10 @@ importers:
        version: 8.54.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
      vite:
        specifier: ^7.3.1
-        version: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+        version: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
      vitest:
        specifier: ^4.0.18
-        version: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+        version: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
      vitest-browser-svelte:
        specifier: ^2.0.2
        version: 2.0.2(svelte@5.49.2)(vitest@4.0.18)
@@ -275,10 +278,10 @@ importers:
        version: 0.51.1
      vite:
        specifier: ^7.3.1
-        version: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+        version: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
      vitest:
        specifier: ^4.0.18
-        version: 4.0.18(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+        version: 4.0.18(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)

 packages:

@@ -396,204 +399,102 @@ packages:
    cpu: [x64]
    os: [win32]

-  '@esbuild/aix-ppc64@0.23.1':
-    resolution: {integrity: sha512-6VhYk1diRqrhBAqpJEdjASR/+WVRtfjpqKuNw11cLiaWpAT/Uu+nokB+UJnevzy/P9C/ty6AOe0dwueMrGh/iQ==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [aix]
-
  '@esbuild/aix-ppc64@0.27.3':
    resolution: {integrity: sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==}
    engines: {node: '>=18'}
    cpu: [ppc64]
    os: [aix]

-  '@esbuild/android-arm64@0.23.1':
-    resolution: {integrity: sha512-xw50ipykXcLstLeWH7WRdQuysJqejuAGPd30vd1i5zSyKK3WE+ijzHmLKxdiCMtH1pHz78rOg0BKSYOSB/2Khw==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [android]
-
  '@esbuild/android-arm64@0.27.3':
    resolution: {integrity: sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==}
    engines: {node: '>=18'}
    cpu: [arm64]
    os: [android]

-  '@esbuild/android-arm@0.23.1':
-    resolution: {integrity: sha512-uz6/tEy2IFm9RYOyvKl88zdzZfwEfKZmnX9Cj1BHjeSGNuGLuMD1kR8y5bteYmwqKm1tj8m4cb/aKEorr6fHWQ==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [android]
-
  '@esbuild/android-arm@0.27.3':
    resolution: {integrity: sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==}
    engines: {node: '>=18'}
    cpu: [arm]
    os: [android]

-  '@esbuild/android-x64@0.23.1':
-    resolution: {integrity: sha512-nlN9B69St9BwUoB+jkyU090bru8L0NA3yFvAd7k8dNsVH8bi9a8cUAUSEcEEgTp2z3dbEDGJGfP6VUnkQnlReg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [android]
-
  '@esbuild/android-x64@0.27.3':
    resolution: {integrity: sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==}
    engines: {node: '>=18'}
    cpu: [x64]
    os: [android]

-  '@esbuild/darwin-arm64@0.23.1':
-    resolution: {integrity: sha512-YsS2e3Wtgnw7Wq53XXBLcV6JhRsEq8hkfg91ESVadIrzr9wO6jJDMZnCQbHm1Guc5t/CdDiFSSfWP58FNuvT3Q==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [darwin]
-
  '@esbuild/darwin-arm64@0.27.3':
    resolution: {integrity: sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==}
    engines: {node: '>=18'}
    cpu: [arm64]
    os: [darwin]

-  '@esbuild/darwin-x64@0.23.1':
-    resolution: {integrity: sha512-aClqdgTDVPSEGgoCS8QDG37Gu8yc9lTHNAQlsztQ6ENetKEO//b8y31MMu2ZaPbn4kVsIABzVLXYLhCGekGDqw==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [darwin]
-
  '@esbuild/darwin-x64@0.27.3':
    resolution: {integrity: sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==}
    engines: {node: '>=18'}
    cpu: [x64]
    os: [darwin]

-  '@esbuild/freebsd-arm64@0.23.1':
-    resolution: {integrity: sha512-h1k6yS8/pN/NHlMl5+v4XPfikhJulk4G+tKGFIOwURBSFzE8bixw1ebjluLOjfwtLqY0kewfjLSrO6tN2MgIhA==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [freebsd]
-
  '@esbuild/freebsd-arm64@0.27.3':
    resolution: {integrity: sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==}
    engines: {node: '>=18'}
    cpu: [arm64]
    os: [freebsd]

-  '@esbuild/freebsd-x64@0.23.1':
-    resolution: {integrity: sha512-lK1eJeyk1ZX8UklqFd/3A60UuZ/6UVfGT2LuGo3Wp4/z7eRTRYY+0xOu2kpClP+vMTi9wKOfXi2vjUpO1Ro76g==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [freebsd]
-
  '@esbuild/freebsd-x64@0.27.3':
    resolution: {integrity: sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==}
    engines: {node: '>=18'}
    cpu: [x64]
    os: [freebsd]

-  '@esbuild/linux-arm64@0.23.1':
-    resolution: {integrity: sha512-/93bf2yxencYDnItMYV/v116zff6UyTjo4EtEQjUBeGiVpMmffDNUyD9UN2zV+V3LRV3/on4xdZ26NKzn6754g==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [linux]
-
  '@esbuild/linux-arm64@0.27.3':
    resolution: {integrity: sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==}
    engines: {node: '>=18'}
    cpu: [arm64]
    os: [linux]

-  '@esbuild/linux-arm@0.23.1':
-    resolution: {integrity: sha512-CXXkzgn+dXAPs3WBwE+Kvnrf4WECwBdfjfeYHpMeVxWE0EceB6vhWGShs6wi0IYEqMSIzdOF1XjQ/Mkm5d7ZdQ==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [linux]
-
  '@esbuild/linux-arm@0.27.3':
    resolution: {integrity: sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==}
    engines: {node: '>=18'}
    cpu: [arm]
    os: [linux]

-  '@esbuild/linux-ia32@0.23.1':
-    resolution: {integrity: sha512-VTN4EuOHwXEkXzX5nTvVY4s7E/Krz7COC8xkftbbKRYAl96vPiUssGkeMELQMOnLOJ8k3BY1+ZY52tttZnHcXQ==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [linux]
-
  '@esbuild/linux-ia32@0.27.3':
    resolution: {integrity: sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==}
    engines: {node: '>=18'}
    cpu: [ia32]
    os: [linux]

-  '@esbuild/linux-loong64@0.23.1':
-    resolution: {integrity: sha512-Vx09LzEoBa5zDnieH8LSMRToj7ir/Jeq0Gu6qJ/1GcBq9GkfoEAoXvLiW1U9J1qE/Y/Oyaq33w5p2ZWrNNHNEw==}
-    engines: {node: '>=18'}
-    cpu: [loong64]
-    os: [linux]
-
  '@esbuild/linux-loong64@0.27.3':
    resolution: {integrity: sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==}
    engines: {node: '>=18'}
    cpu: [loong64]
    os: [linux]

-  '@esbuild/linux-mips64el@0.23.1':
-    resolution: {integrity: sha512-nrFzzMQ7W4WRLNUOU5dlWAqa6yVeI0P78WKGUo7lg2HShq/yx+UYkeNSE0SSfSure0SqgnsxPvmAUu/vu0E+3Q==}
-    engines: {node: '>=18'}
-    cpu: [mips64el]
-    os: [linux]
-
  '@esbuild/linux-mips64el@0.27.3':
    resolution: {integrity: sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==}
    engines: {node: '>=18'}
    cpu: [mips64el]
    os: [linux]

-  '@esbuild/linux-ppc64@0.23.1':
-    resolution: {integrity: sha512-dKN8fgVqd0vUIjxuJI6P/9SSSe/mB9rvA98CSH2sJnlZ/OCZWO1DJvxj8jvKTfYUdGfcq2dDxoKaC6bHuTlgcw==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [linux]
-
  '@esbuild/linux-ppc64@0.27.3':
    resolution: {integrity: sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==}
    engines: {node: '>=18'}
    cpu: [ppc64]
    os: [linux]

-  '@esbuild/linux-riscv64@0.23.1':
-    resolution: {integrity: sha512-5AV4Pzp80fhHL83JM6LoA6pTQVWgB1HovMBsLQ9OZWLDqVY8MVobBXNSmAJi//Csh6tcY7e7Lny2Hg1tElMjIA==}
-    engines: {node: '>=18'}
-    cpu: [riscv64]
-    os: [linux]
-
  '@esbuild/linux-riscv64@0.27.3':
    resolution: {integrity: sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==}
    engines: {node: '>=18'}
    cpu: [riscv64]
    os: [linux]

-  '@esbuild/linux-s390x@0.23.1':
-    resolution: {integrity: sha512-9ygs73tuFCe6f6m/Tb+9LtYxWR4c9yg7zjt2cYkjDbDpV/xVn+68cQxMXCjUpYwEkze2RcU/rMnfIXNRFmSoDw==}
-    engines: {node: '>=18'}
-    cpu: [s390x]
-    os: [linux]
-
  '@esbuild/linux-s390x@0.27.3':
    resolution: {integrity: sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==}
    engines: {node: '>=18'}
    cpu: [s390x]
    os: [linux]

-  '@esbuild/linux-x64@0.23.1':
-    resolution: {integrity: sha512-EV6+ovTsEXCPAp58g2dD68LxoP/wK5pRvgy0J/HxPGB009omFPv3Yet0HiaqvrIrgPTBuC6wCH1LTOY91EO5hQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [linux]
-
  '@esbuild/linux-x64@0.27.3':
    resolution: {integrity: sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==}
    engines: {node: '>=18'}
@@ -606,36 +507,18 @@ packages:
    cpu: [arm64]
    os: [netbsd]

-  '@esbuild/netbsd-x64@0.23.1':
-    resolution: {integrity: sha512-aevEkCNu7KlPRpYLjwmdcuNz6bDFiE7Z8XC4CPqExjTvrHugh28QzUXVOZtiYghciKUacNktqxdpymplil1beA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [netbsd]
-
  '@esbuild/netbsd-x64@0.27.3':
    resolution: {integrity: sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==}
    engines: {node: '>=18'}
    cpu: [x64]
    os: [netbsd]

-  '@esbuild/openbsd-arm64@0.23.1':
-    resolution: {integrity: sha512-3x37szhLexNA4bXhLrCC/LImN/YtWis6WXr1VESlfVtVeoFJBRINPJ3f0a/6LV8zpikqoUg4hyXw0sFBt5Cr+Q==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openbsd]
-
  '@esbuild/openbsd-arm64@0.27.3':
    resolution: {integrity: sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==}
    engines: {node: '>=18'}
    cpu: [arm64]
    os: [openbsd]

-  '@esbuild/openbsd-x64@0.23.1':
-    resolution: {integrity: sha512-aY2gMmKmPhxfU+0EdnN+XNtGbjfQgwZj43k8G3fyrDM/UdZww6xrWxmDkuz2eCZchqVeABjV5BpildOrUbBTqA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [openbsd]
-
  '@esbuild/openbsd-x64@0.27.3':
    resolution: {integrity: sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==}
    engines: {node: '>=18'}
@@ -648,48 +531,24 @@ packages:
    cpu: [arm64]
    os: [openharmony]

-  '@esbuild/sunos-x64@0.23.1':
-    resolution: {integrity: sha512-RBRT2gqEl0IKQABT4XTj78tpk9v7ehp+mazn2HbUeZl1YMdaGAQqhapjGTCe7uw7y0frDi4gS0uHzhvpFuI1sA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [sunos]
-
  '@esbuild/sunos-x64@0.27.3':
    resolution: {integrity: sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==}
    engines: {node: '>=18'}
    cpu: [x64]
    os: [sunos]

-  '@esbuild/win32-arm64@0.23.1':
-    resolution: {integrity: sha512-4O+gPR5rEBe2FpKOVyiJ7wNDPA8nGzDuJ6gN4okSA1gEOYZ67N8JPk58tkWtdtPeLz7lBnY6I5L3jdsr3S+A6A==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [win32]
-
  '@esbuild/win32-arm64@0.27.3':
    resolution: {integrity: sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==}
    engines: {node: '>=18'}
    cpu: [arm64]
    os: [win32]

-  '@esbuild/win32-ia32@0.23.1':
-    resolution: {integrity: sha512-BcaL0Vn6QwCwre3Y717nVHZbAa4UBEigzFm6VdsVdT/MbZ38xoj1X9HPkZhbmaBGUD1W8vxAfffbDe8bA6AKnQ==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [win32]
-
  '@esbuild/win32-ia32@0.27.3':
    resolution: {integrity: sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==}
    engines: {node: '>=18'}
    cpu: [ia32]
    os: [win32]

-  '@esbuild/win32-x64@0.23.1':
-    resolution: {integrity: sha512-BHpFFeslkWrXWyUPnbKm+xYYVYruCinGcftSBaa8zoF9hZO4BcSCFUvHVTtzpIY6YzUnYtuEhZ+C9iEXjxnasg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [win32]
-
  '@esbuild/win32-x64@0.27.3':
    resolution: {integrity: sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==}
    engines: {node: '>=18'}
@@ -1707,11 +1566,6 @@ packages:
    resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
    engines: {node: '>= 0.4'}

-  esbuild@0.23.1:
-    resolution: {integrity: sha512-VVNz/9Sa0bs5SELtn3f7qhJCDPCF5oMEl5cO9/SSinpE9hbPVvxbd572HH5AKiP7WD8INO53GgfDDhRjkylHEg==}
-    engines: {node: '>=18'}
-    hasBin: true
-
  esbuild@0.27.3:
    resolution: {integrity: sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==}
    engines: {node: '>=18'}
@@ -2696,8 +2550,8 @@ packages:
  tslib@2.8.1:
    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}

-  tsx@4.19.2:
-    resolution: {integrity: sha512-pOUl6Vo2LUq/bSa8S5q7b91cgNSjctn9ugq/+Mvow99qW6x/UZYwzxy/3NmqoT66eHYfCVvFvACC58UBPFf28g==}
+  tsx@4.21.0:
+    resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
    engines: {node: '>=18.0.0'}
    hasBin: true

@@ -3035,153 +2889,81 @@ snapshots:
  '@dprint/win32-x64@0.51.1':
    optional: true

-  '@esbuild/aix-ppc64@0.23.1':
-    optional: true
-
  '@esbuild/aix-ppc64@0.27.3':
    optional: true

-  '@esbuild/android-arm64@0.23.1':
-    optional: true
-
  '@esbuild/android-arm64@0.27.3':
    optional: true

-  '@esbuild/android-arm@0.23.1':
-    optional: true
-
  '@esbuild/android-arm@0.27.3':
    optional: true

-  '@esbuild/android-x64@0.23.1':
-    optional: true
-
  '@esbuild/android-x64@0.27.3':
    optional: true

-  '@esbuild/darwin-arm64@0.23.1':
-    optional: true
-
  '@esbuild/darwin-arm64@0.27.3':
    optional: true

-  '@esbuild/darwin-x64@0.23.1':
-    optional: true
-
  '@esbuild/darwin-x64@0.27.3':
    optional: true

-  '@esbuild/freebsd-arm64@0.23.1':
-    optional: true
-
  '@esbuild/freebsd-arm64@0.27.3':
    optional: true

-  '@esbuild/freebsd-x64@0.23.1':
-    optional: true
-
  '@esbuild/freebsd-x64@0.27.3':
    optional: true

-  '@esbuild/linux-arm64@0.23.1':
-    optional: true
-
  '@esbuild/linux-arm64@0.27.3':
    optional: true

-  '@esbuild/linux-arm@0.23.1':
-    optional: true
-
  '@esbuild/linux-arm@0.27.3':
    optional: true

-  '@esbuild/linux-ia32@0.23.1':
-    optional: true
-
  '@esbuild/linux-ia32@0.27.3':
    optional: true

-  '@esbuild/linux-loong64@0.23.1':
-    optional: true
-
  '@esbuild/linux-loong64@0.27.3':
    optional: true

-  '@esbuild/linux-mips64el@0.23.1':
-    optional: true
-
  '@esbuild/linux-mips64el@0.27.3':
    optional: true

-  '@esbuild/linux-ppc64@0.23.1':
-    optional: true
-
  '@esbuild/linux-ppc64@0.27.3':
    optional: true

-  '@esbuild/linux-riscv64@0.23.1':
-    optional: true
-
  '@esbuild/linux-riscv64@0.27.3':
    optional: true

-  '@esbuild/linux-s390x@0.23.1':
-    optional: true
-
  '@esbuild/linux-s390x@0.27.3':
    optional: true

-  '@esbuild/linux-x64@0.23.1':
-    optional: true
-
  '@esbuild/linux-x64@0.27.3':
    optional: true

  '@esbuild/netbsd-arm64@0.27.3':
    optional: true

-  '@esbuild/netbsd-x64@0.23.1':
-    optional: true
-
  '@esbuild/netbsd-x64@0.27.3':
    optional: true

-  '@esbuild/openbsd-arm64@0.23.1':
-    optional: true
-
  '@esbuild/openbsd-arm64@0.27.3':
    optional: true

-  '@esbuild/openbsd-x64@0.23.1':
-    optional: true
-
  '@esbuild/openbsd-x64@0.27.3':
    optional: true

  '@esbuild/openharmony-arm64@0.27.3':
    optional: true

-  '@esbuild/sunos-x64@0.23.1':
-    optional: true
-
  '@esbuild/sunos-x64@0.27.3':
    optional: true

-  '@esbuild/win32-arm64@0.23.1':
-    optional: true
-
  '@esbuild/win32-arm64@0.27.3':
    optional: true

-  '@esbuild/win32-ia32@0.23.1':
-    optional: true
-
  '@esbuild/win32-ia32@0.27.3':
    optional: true

-  '@esbuild/win32-x64@0.23.1':
-    optional: true
-
  '@esbuild/win32-x64@0.27.3':
    optional: true

@@ -3471,15 +3253,15 @@ snapshots:
    dependencies:
      acorn: 8.15.0

-  '@sveltejs/adapter-static@3.0.10(@sveltejs/kit@2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))':
+  '@sveltejs/adapter-static@3.0.10(@sveltejs/kit@2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))':
    dependencies:
-      '@sveltejs/kit': 2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@sveltejs/kit': 2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))

-  '@sveltejs/kit@2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))':
+  '@sveltejs/kit@2.50.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))(svelte@5.49.2)(typescript@5.9.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))':
    dependencies:
      '@standard-schema/spec': 1.1.0
      '@sveltejs/acorn-typescript': 1.0.8(acorn@8.15.0)
-      '@sveltejs/vite-plugin-svelte': 6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@sveltejs/vite-plugin-svelte': 6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@types/cookie': 0.6.0
      acorn: 8.15.0
      cookie: 0.6.0
@@ -3492,7 +3274,7 @@ snapshots:
      set-cookie-parser: 3.0.1
      sirv: 3.0.2
      svelte: 5.49.2
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
    optionalDependencies:
      typescript: 5.9.3

@@ -3507,22 +3289,22 @@ snapshots:
    transitivePeerDependencies:
      - typescript

-  '@sveltejs/vite-plugin-svelte-inspector@5.0.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))':
+  '@sveltejs/vite-plugin-svelte-inspector@5.0.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))':
    dependencies:
-      '@sveltejs/vite-plugin-svelte': 6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@sveltejs/vite-plugin-svelte': 6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      obug: 2.1.1
      svelte: 5.49.2
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)

-  '@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))':
+  '@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))':
    dependencies:
-      '@sveltejs/vite-plugin-svelte-inspector': 5.0.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)))(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@sveltejs/vite-plugin-svelte-inspector': 5.0.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)))(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      deepmerge: 4.3.1
      magic-string: 0.30.21
      obug: 2.1.1
      svelte: 5.49.2
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
-      vitefu: 1.1.1(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
+      vitefu: 1.1.1(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))

  '@tailwindcss/node@4.1.18':
    dependencies:
@@ -3585,12 +3367,12 @@ snapshots:
      '@tailwindcss/oxide-win32-arm64-msvc': 4.1.18
      '@tailwindcss/oxide-win32-x64-msvc': 4.1.18

-  '@tailwindcss/vite@4.1.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))':
+  '@tailwindcss/vite@4.1.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))':
    dependencies:
      '@tailwindcss/node': 4.1.18
      '@tailwindcss/oxide': 4.1.18
      tailwindcss: 4.1.18
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)

  '@testing-library/dom@10.4.1':
    dependencies:
@@ -3607,14 +3389,14 @@ snapshots:
    dependencies:
      svelte: 5.49.2

-  '@testing-library/svelte@5.3.1(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)':
+  '@testing-library/svelte@5.3.1(svelte@5.49.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)':
    dependencies:
      '@testing-library/dom': 10.4.1
      '@testing-library/svelte-core': 1.0.0(svelte@5.49.2)
      svelte: 5.49.2
    optionalDependencies:
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
-      vitest: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
+      vitest: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)

  '@threejs-kit/instanced-sprite-mesh@2.5.1(@types/three@0.182.0)(three@0.182.0)':
    dependencies:
@@ -3800,26 +3582,26 @@ snapshots:
      '@typescript-eslint/types': 8.54.0
      eslint-visitor-keys: 4.2.1

-  '@vitest/browser-playwright@4.0.18(playwright@1.58.1)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)':
+  '@vitest/browser-playwright@4.0.18(playwright@1.58.1)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)':
    dependencies:
-      '@vitest/browser': 4.0.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)
-      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@vitest/browser': 4.0.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)
+      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      playwright: 1.58.1
      tinyrainbow: 3.0.3
-      vitest: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vitest: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
    transitivePeerDependencies:
      - bufferutil
      - msw
      - utf-8-validate
      - vite

-  '@vitest/browser-playwright@4.0.18(playwright@1.58.1)(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)':
+  '@vitest/browser-playwright@4.0.18(playwright@1.58.1)(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)':
    dependencies:
-      '@vitest/browser': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)
-      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@vitest/browser': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)
+      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      playwright: 1.58.1
      tinyrainbow: 3.0.3
-      vitest: 4.0.18(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vitest: 4.0.18(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
    transitivePeerDependencies:
      - bufferutil
      - msw
@@ -3827,16 +3609,16 @@ snapshots:
      - vite
    optional: true

-  '@vitest/browser@4.0.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)':
+  '@vitest/browser@4.0.18(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)':
    dependencies:
-      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@vitest/utils': 4.0.18
      magic-string: 0.30.21
      pixelmatch: 7.1.0
      pngjs: 7.0.0
      sirv: 3.0.2
      tinyrainbow: 3.0.3
-      vitest: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vitest: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
      ws: 8.19.0
    transitivePeerDependencies:
      - bufferutil
@@ -3844,16 +3626,16 @@ snapshots:
      - utf-8-validate
      - vite

-  '@vitest/browser@4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)':
+  '@vitest/browser@4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)':
    dependencies:
-      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@vitest/utils': 4.0.18
      magic-string: 0.30.21
      pixelmatch: 7.1.0
      pngjs: 7.0.0
      sirv: 3.0.2
      tinyrainbow: 3.0.3
-      vitest: 4.0.18(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vitest: 4.0.18(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
      ws: 8.19.0
    transitivePeerDependencies:
      - bufferutil
@@ -3871,13 +3653,13 @@ snapshots:
      chai: 6.2.2
      tinyrainbow: 3.0.3

-  '@vitest/mocker@4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))':
+  '@vitest/mocker@4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))':
    dependencies:
      '@vitest/spy': 4.0.18
      estree-walker: 3.0.3
      magic-string: 0.30.21
    optionalDependencies:
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)

  '@vitest/pretty-format@4.0.18':
    dependencies:
@@ -4233,34 +4015,6 @@ snapshots:
      hasown: 2.0.2
    optional: true

-  esbuild@0.23.1:
-    optionalDependencies:
-      '@esbuild/aix-ppc64': 0.23.1
-      '@esbuild/android-arm': 0.23.1
-      '@esbuild/android-arm64': 0.23.1
-      '@esbuild/android-x64': 0.23.1
-      '@esbuild/darwin-arm64': 0.23.1
-      '@esbuild/darwin-x64': 0.23.1
-      '@esbuild/freebsd-arm64': 0.23.1
-      '@esbuild/freebsd-x64': 0.23.1
-      '@esbuild/linux-arm': 0.23.1
-      '@esbuild/linux-arm64': 0.23.1
-      '@esbuild/linux-ia32': 0.23.1
-      '@esbuild/linux-loong64': 0.23.1
-      '@esbuild/linux-mips64el': 0.23.1
-      '@esbuild/linux-ppc64': 0.23.1
-      '@esbuild/linux-riscv64': 0.23.1
-      '@esbuild/linux-s390x': 0.23.1
-      '@esbuild/linux-x64': 0.23.1
-      '@esbuild/netbsd-x64': 0.23.1
-      '@esbuild/openbsd-arm64': 0.23.1
-      '@esbuild/openbsd-x64': 0.23.1
-      '@esbuild/sunos-x64': 0.23.1
-      '@esbuild/win32-arm64': 0.23.1
-      '@esbuild/win32-ia32': 0.23.1
-      '@esbuild/win32-x64': 0.23.1
-    optional: true
-
  esbuild@0.27.3:
    optionalDependencies:
      '@esbuild/aix-ppc64': 0.27.3
@@ -4474,7 +4228,6 @@ snapshots:
  get-tsconfig@4.13.6:
    dependencies:
      resolve-pkg-maps: 1.0.0
-    optional: true

  glob-parent@5.1.2:
    dependencies:
@@ -5068,8 +4821,7 @@ snapshots:

  resolve-from@4.0.0: {}

-  resolve-pkg-maps@1.0.0:
-    optional: true
+  resolve-pkg-maps@1.0.0: {}

  rollup@4.57.1:
    dependencies:
@@ -5355,13 +5107,12 @@ snapshots:

  tslib@2.8.1: {}

-  tsx@4.19.2:
+  tsx@4.21.0:
    dependencies:
-      esbuild: 0.23.1
+      esbuild: 0.27.3
      get-tsconfig: 4.13.6
    optionalDependencies:
      fsevents: 2.3.3
-    optional: true

  tweakpane@3.1.10: {}

@@ -5396,26 +5147,26 @@ snapshots:
  v8-compile-cache-lib@3.0.1:
    optional: true

-  vite-plugin-comlink@5.3.0(comlink@4.4.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)):
+  vite-plugin-comlink@5.3.0(comlink@4.4.2)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)):
    dependencies:
      comlink: 4.4.2
      json5: 2.2.3
      magic-string: 0.30.17
      source-map: 0.7.6
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)

-  vite-plugin-glsl@1.5.5(@rollup/pluginutils@5.1.4(rollup@4.57.1))(esbuild@0.27.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)):
+  vite-plugin-glsl@1.5.5(@rollup/pluginutils@5.1.4(rollup@4.57.1))(esbuild@0.27.3)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)):
    dependencies:
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
    optionalDependencies:
      '@rollup/pluginutils': 5.1.4(rollup@4.57.1)
      esbuild: 0.27.3

-  vite-plugin-wasm@3.5.0(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)):
+  vite-plugin-wasm@3.5.0(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)):
    dependencies:
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)

-  vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2):
+  vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0):
    dependencies:
      esbuild: 0.27.3
      fdir: 6.5.0(picomatch@4.0.3)
@@ -5431,22 +5182,22 @@ snapshots:
      lightningcss: 1.30.2
      sass: 1.80.6
      terser: 5.36.0
-      tsx: 4.19.2
+      tsx: 4.21.0

-  vitefu@1.1.1(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)):
+  vitefu@1.1.1(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)):
    optionalDependencies:
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)

  vitest-browser-svelte@2.0.2(svelte@5.49.2)(vitest@4.0.18):
    dependencies:
      '@testing-library/svelte-core': 1.0.0(svelte@5.49.2)
      svelte: 5.49.2
-      vitest: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vitest: 4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)

-  vitest@4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2):
+  vitest@4.0.18(@types/node@22.8.6)(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0):
    dependencies:
      '@vitest/expect': 4.0.18
-      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@vitest/pretty-format': 4.0.18
      '@vitest/runner': 4.0.18
      '@vitest/snapshot': 4.0.18
@@ -5463,11 +5214,11 @@ snapshots:
      tinyexec: 1.0.2
      tinyglobby: 0.2.15
      tinyrainbow: 3.0.3
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
      why-is-node-running: 2.3.0
    optionalDependencies:
      '@types/node': 22.8.6
-      '@vitest/browser-playwright': 4.0.18(playwright@1.58.1)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)
+      '@vitest/browser-playwright': 4.0.18(playwright@1.58.1)(vite@7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)
      jsdom: 25.0.1
    transitivePeerDependencies:
      - jiti
@@ -5482,10 +5233,10 @@ snapshots:
      - tsx
      - yaml

-  vitest@4.0.18(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2):
+  vitest@4.0.18(@vitest/browser-playwright@4.0.18)(jiti@2.6.1)(jsdom@25.0.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0):
    dependencies:
      '@vitest/expect': 4.0.18
-      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))
+      '@vitest/mocker': 4.0.18(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))
      '@vitest/pretty-format': 4.0.18
      '@vitest/runner': 4.0.18
      '@vitest/snapshot': 4.0.18
@@ -5502,10 +5253,10 @@ snapshots:
      tinyexec: 1.0.2
      tinyglobby: 0.2.15
      tinyrainbow: 3.0.3
-      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2)
+      vite: 7.3.1(@types/node@22.8.6)(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0)
      why-is-node-running: 2.3.0
    optionalDependencies:
-      '@vitest/browser-playwright': 4.0.18(playwright@1.58.1)(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.19.2))(vitest@4.0.18)
+      '@vitest/browser-playwright': 4.0.18(playwright@1.58.1)(vite@7.3.1(jiti@2.6.1)(less@4.2.0)(lightningcss@1.30.2)(sass@1.80.6)(terser@5.36.0)(tsx@4.21.0))(vitest@4.0.18)
      jsdom: 25.0.1
    transitivePeerDependencies:
      - jiti
Author	SHA1	Message	Date
Max Richter	be8161ec8d	wip Some checks failed 📊 Benchmark the Runtime / release (pull_request) Failing after 1m16s Details 🚀 Lint & Test & Deploy / release (pull_request) Failing after 1m19s Details	2026-02-17 13:49:10 +01:00
Max Richter	4cb24e8ff9	feat: some shit	2026-02-17 13:49:10 +01:00
Max Richter	30afb30341	feat: add debug node	2026-02-17 13:49:10 +01:00
Max Richter	1d1a44324e	feat: some shit	2026-02-17 13:49:10 +01:00
Max Richter	343eca02b5	chore: make sure to specify wasm flags only on wasm build	2026-02-17 13:49:10 +01:00
Max Richter	45a9800e6a	chore: cargo fix	2026-02-17 13:49:10 +01:00
Max Richter	b384348e70	feat: make all nodes work with new runtime	2026-02-17 13:49:10 +01:00
Max Richter	25ceb6e94f	feat: first working version of new allocator	2026-02-17 13:49:09 +01:00
Max Richter	ff8c6637f8	feat: add "*"/any type input for dev page	2026-02-17 13:49:09 +01:00
Max Richter	2ec9bfc3c9	feat(ci): compress benchmark data All checks were successful 📊 Benchmark the Runtime / release (push) Successful in 1m20s Details 🚀 Lint & Test & Deploy / release (push) Successful in 4m7s Details	2026-02-13 15:21:57 +01:00
Max Richter	c97520617a	fix(ci): use older upload-artifact action All checks were successful 📊 Benchmark the Runtime / release (push) Successful in 1m16s Details 🚀 Lint & Test & Deploy / release (push) Successful in 4m23s Details	2026-02-13 15:01:59 +01:00
Max Richter	6475790176	fix(ci): build nodes before benchmarking Some checks failed 📊 Benchmark the Runtime / release (push) Failing after 1m16s Details 🚀 Lint & Test & Deploy / release (push) Has been cancelled Details	2026-02-13 14:57:07 +01:00
Max Richter	580ec73465	ci: run benchmark in ci Some checks failed 📊 Benchmark the Runtime / release (push) Failing after 42s Details 🚀 Lint & Test & Deploy / release (push) Successful in 4m20s Details	2026-02-13 14:46:21 +01:00
nodarium-bot	fd98d457a3	chore(release): v0.0.5	2026-02-13 01:47:35 +00:00