chore: format

docs: add ux guidelines
fix: pasting nodes
2026-05-07 17:40:41 +02:00 · 2026-05-07 17:40:30 +02:00 · 2026-05-07 17:39:58 +02:00 · 2026-05-07 17:19:08 +02:00 · 2026-05-07 17:03:02 +02:00 · 2026-05-07 17:02:47 +02:00
150 changed files with 9124 additions and 4646 deletions
@@ -1,9 +0,0 @@
-[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
-]
@@ -0,0 +1,28 @@
+name: Setup
+description: Restore caches and install pnpm dependencies (run after checkout)
+
+runs:
+  using: composite
+  steps:
+    - name: 💾 Setup pnpm Cache
+      uses: actions/cache@v4
+      with:
+        path: .pnpm-store
+        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
+      shell: bash
+      run: pnpm install --frozen-lockfile --store-dir .pnpm-store
@@ -12,9 +12,9 @@ env:
  CARGO_TARGET_DIR: target

 jobs:
-  release:
+  benchmark:
    runs-on: ubuntu-latest
-    container: git.max-richter.dev/max/nodarium-ci:bce06da456e3c008851ac006033cfff256015a47
+    container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69

    steps:
      - name: 📑 Checkout Code
@@ -23,27 +23,8 @@ jobs:
          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: 🔧 Setup
+        uses: ./.gitea/actions/setup

      - name: 🛠️ Build Nodes
        run: pnpm build:nodes
@@ -51,9 +32,36 @@ jobs:
      - 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
+      - name: 🔑 Setup SSH key
+        run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.GIT_SSH_PRIVATE_KEY }}" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+          cat >> ~/.ssh/config <<'EOF'
+          Host git.max-richter.dev
+            Port 2222
+            IdentityFile ~/.ssh/id_ed25519
+            IdentitiesOnly yes
+          EOF
+          ssh-keyscan -p 2222 -H git.max-richter.dev >> ~/.ssh/known_hosts
+
+      - name: 📤 Push Results
+        env:
+          BENCH_REPO: "git@git.max-richter.dev:max/nodarium-benchmarks.git"
+        run: |
+          git config --global user.name "nodarium-bot"
+          git config --global user.email "nodarium-bot@max-richter.dev"
+
+          git clone git@git.max-richter.dev:max/nodarium-benchmarks.git target_bench_repo
+
+          BRANCH="${GITHUB_HEAD_REF:-$GITHUB_REF_NAME}"
+          SAFE_PR_NAME=$(printf "%s" "$BRANCH" | tr '/' '-')
+          DEST_DIR="target_bench_repo/data/$SAFE_PR_NAME/$(date +%s)"
+          mkdir -p "$DEST_DIR"
+
+          cp app/benchmark/out/*.json "$DEST_DIR/"
+
+          cd target_bench_repo
+          git add .
+          git commit -m "Update benchmarks for $SAFE_PR_NAME: ${{ gitea.sha }}"
+          git push origin main
@@ -13,9 +13,9 @@ env:
  CARGO_TARGET_DIR: target

 jobs:
-  release:
+  quality:
    runs-on: ubuntu-latest
-    container: git.max-richter.dev/max/nodarium-ci:bce06da456e3c008851ac006033cfff256015a47
+    container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69

    steps:
      - name: 📑 Checkout Code
@@ -24,27 +24,8 @@ jobs:
          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: 🔧 Setup
+        uses: ./.gitea/actions/setup

      - name: 🧹 Quality Control
        run: |
@@ -52,7 +33,61 @@ jobs:
          pnpm format:check
          pnpm check
          pnpm build
-          xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x24" pnpm test
+
+  test-unit:
+    runs-on: ubuntu-latest
+    container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69
+
+    steps:
+      - name: 📑 Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN }}
+
+      - name: 🔧 Setup
+        uses: ./.gitea/actions/setup
+
+      - name: 🧪 Run Tests
+        run: xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x24" pnpm test:unit
+
+  test-e2e:
+    runs-on: ubuntu-latest
+    container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69
+
+    steps:
+      - name: 📑 Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN }}
+
+      - name: 🔧 Setup
+        uses: ./.gitea/actions/setup
+
+      - name: 🏗️ Build Web Assets
+        run: pnpm build
+
+      - name: 🧪 Run Tests
+        run: xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x24" pnpm test:e2e
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: [quality, test-e2e, test-unit]
+    container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69
+
+    steps:
+      - name: 📑 Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN }}
+
+      - name: 🔧 Setup
+        uses: ./.gitea/actions/setup
+
+      - name: 🏗️ Build Web Assets
+        run: pnpm build

      - name: 🚀 Create Release Commit
        if: gitea.ref_type == 'tag'
@@ -1,3 +1,134 @@
+# v0.0.6 (2026-05-05)
+
+## Features
+
+- Upgrade graph source panel and JSON viewer with click-to-copy and improved select handling.
+- Capture system stats in benchmark runs.
+- Split CI into unit and end-to-end pipelines.
+- Add `LLM.md` documentation.
+- Add 🍀 Planty Tutorial Helper
+- Add a way to group nodes
+
+## Node Groups
+
+Node Groups introduce a way to structure graphs into nested, navigable subgraphs for better organization and reuse.
+
+- Nested graph workflows with full runtime support
+- Group input and output nodes defining clear boundaries
+- Named groups for organization and identification
+- Breadcrumb navigation for navigating nested levels
+- Context-aware UI when editing inside groups
+- Reliable enter/exit transitions with state restoration
+- Ability to ungroup nodes back into the main graph
+
+## Planty
+
+Planty is a Clippy-inspired in-app tutorial and guidance system that helps users understand and use the graph editor through contextual assistance.
+
+- Context-aware hints based on user actions in the graph
+- Step-by-step onboarding flows for core features
+- Inline guidance tied to nodes, sockets, and interactions
+- Lightweight runtime integration without external build requirements
+
+## Fixes
+
+- Fix benchmark execution and CI integration issues
+- Resolve debug node ID mismatch
+- Fix ESLint, TypeScript, Playwright, and test synchronization issues
+- Fix packaging issues in `@nodarium/planty` and UI library
+- Restore correct graph references after exiting node groups
+
+## Refactors
+
+- Remove graph element handling from `graphManager`
+- Restrict panel rendering to selected nodes only
+- Move JSON viewer into shared UI package
+- Clean up CI workflows
+
+## Chores
+
+- Upgrade dependencies via `pnpm upgrade`
+- Add SvelteKit sync before E2E tests
+- Remove flaky screenshot artifacts
+- General formatting, linting, and test maintenance
+
+---
+
+- [82c2f08](https://git.max-richter.dev/max/nodarium/commit/82c2f08a5653ccd596c6982a1d9efa4b20a0b624) chore: cleanup changelog
+- [a00db40](https://git.max-richter.dev/max/nodarium/commit/a00db400bba909db5da499e8484d6ed5541c4ad7) fix: dont crash when no groups exist
+- [2d9eb0c](https://git.max-richter.dev/max/nodarium/commit/2d9eb0c0879611c2355e52100b150dd39b924684) fix: make planty work
+- [954f572](https://git.max-richter.dev/max/nodarium/commit/954f5726c305508329856b6707a41b77f297c4bf) Merge pull request 'feat: initial node groups' (#44) from feat/group-node-own into main
+- [63d5b80](https://git.max-richter.dev/max/nodarium/commit/63d5b8079d785b4fe1e689611cd38e5dd4d3ecb6) chore: pnpm format
+- [3e32ca4](https://git.max-richter.dev/max/nodarium/commit/3e32ca419a1b914cbe64d98d887a89f4f5abb0e2) feat: ungroup nodes
+- [f0cb12a](https://git.max-richter.dev/max/nodarium/commit/f0cb12a088609f5bd56096f7c1f244af0a1f91d8) chore: fix some type issues
+- [1d60090](https://git.max-richter.dev/max/nodarium/commit/1d60090ffe1a93af4c0df6f36741957ac13b1a73) chore: fixup graph manager tests
+- [5b55056](https://git.max-richter.dev/max/nodarium/commit/5b55056fc12271b87393cf9ef3b61cdf518a9857) chore: remove graph element in graphManager
+- [e2c2b1a](https://git.max-richter.dev/max/nodarium/commit/e2c2b1a4d73e0953ddd0125cabe83649b58c8996) chore: remove e2e test screenshots (too flaky)
+- [7f082ad](https://git.max-richter.dev/max/nodarium/commit/7f082ad8f6f144b92947000b91ceddce3c52704b) feat: implement node sockets ui
+- [ed11195](https://git.max-richter.dev/max/nodarium/commit/ed1119532750d47a1395ced92fe310a6aa5e070e) chore: refactor graphStack to be simpler
+- [8ad62cf](https://git.max-richter.dev/max/nodarium/commit/8ad62cfc8e8c60e4e72fdaa3d8caca75a7472da6) feat: add node group breadcrumbs
+- [bff140a](https://git.max-richter.dev/max/nodarium/commit/bff140a764ff0b6ed2c6e42814a088ca9e2ef1ee) feat: show different ui when inside group
+- [85e2fd1](https://git.max-richter.dev/max/nodarium/commit/85e2fd1a7126aab4a544eea3d185cfc63754cb73) fix: use correct id for debug node
+- [5beb031](https://git.max-richter.dev/max/nodarium/commit/5beb03196d46434f617442cc55d721c7d3eebe33) fix: broken format command for @nodarium/planty
+- [83e0e47](https://git.max-richter.dev/max/nodarium/commit/83e0e47082ed0d9fbd60e67a6d6c9ed65a9f4f24) refactor: only show group/node panel when selected
+- [106797d](https://git.max-richter.dev/max/nodarium/commit/106797de32f0d57059c481770e734b555900421d) feat: make group input/output node work
+- [1a56ba9](https://git.max-richter.dev/max/nodarium/commit/1a56ba986d761be545c2cf0236f9c374222da6b1) damn dude
+- [703f531](https://git.max-richter.dev/max/nodarium/commit/703f531cd370c2d440a696a68413ea6d5f54019f) chore: make eslint and playwright happy
+- [0ed22f2](https://git.max-richter.dev/max/nodarium/commit/0ed22f20b913837b8e90d45aa1a4ada1a90a9313) chore: pnpm upgrade
+- [733b0a2](https://git.max-richter.dev/max/nodarium/commit/733b0a2ceb3be6fac1eda5bbf856a4bd1f724e36) chore: sync sveltekit app before e2e
+- [8f60816](https://git.max-richter.dev/max/nodarium/commit/8f60816c7841c845120e71590e1c4672d218703e) chore: sync sveltekit app before e2e
+- [cd7b51d](https://git.max-richter.dev/max/nodarium/commit/cd7b51d86a1243e0714d9be73588db56c844086c) chore: sync sveltekit app before e2e
+- [6c9cd15](https://git.max-richter.dev/max/nodarium/commit/6c9cd1505d72c1c0600910f56ee158d07b7e4811) chore: sync sveltekit app before e2e
+- [db5ee8b](https://git.max-richter.dev/max/nodarium/commit/db5ee8ba29812e6865706966ff690ef335ff5e4f) fix: make eslint happy
+- [a6b9ca4](https://git.max-richter.dev/max/nodarium/commit/a6b9ca43155b5e9357570705b6f45ba4fc3490a8) feat: capture system stats in benchmark
+- [d4910ab](https://git.max-richter.dev/max/nodarium/commit/d4910aba8c5408fb9321b1a22d4c35eae8142309) chore: pnpm format
+- [e695c76](https://git.max-richter.dev/max/nodarium/commit/e695c7649015b88d8ca6662bfee5dc0329dd89ac) chore: make eslint happy
+- [2a54fa7](https://git.max-richter.dev/max/nodarium/commit/2a54fa7590c1834904a45fb0fc1fd0aa371f0120) feat: add name to groups
+- [6d5cac6](https://git.max-richter.dev/max/nodarium/commit/6d5cac65e8acf013ac0a4a61baf3bbc423252d53) feat(ui): click-to-copy on node values in jsonviewer
+- [3ee074b](https://git.max-richter.dev/max/nodarium/commit/3ee074b11c9bc216ce7221f5611c8177cef9b313) feat(ui): make inputselect also handle value+label options
+- [59a1e63](https://git.max-richter.dev/max/nodarium/commit/59a1e63396635d05543fa4636de5800ce4899a2a) feat: add unit tests for graph state
+- [317d155](https://git.max-richter.dev/max/nodarium/commit/317d1552cea5a234ab1ab87684be9a3724b1976f) fix: graph correctly restore html refs after exiting node group
+- [78439b1](https://git.max-richter.dev/max/nodarium/commit/78439b19e96e6dbdfb31cc794f5b6e1ff005e26e) fix: make benchmark work
+- [ef217b1](https://git.max-richter.dev/max/nodarium/commit/ef217b1c409c25d6054515e1f705831ddbf5a24b) feat: some updates
+- [7499b80](https://git.max-richter.dev/max/nodarium/commit/7499b80789e99b87df54d6891597fac7edb56b0f) fix: make the runtime work with groups
+- [a5b663f](https://git.max-richter.dev/max/nodarium/commit/a5b663f6fc5e67d5ef67b128c22cdc7363232de5) feat(ci): split e2e and unit tests
+- [0550670](https://git.max-richter.dev/max/nodarium/commit/05506704bf68dfd289a1c5130d5d86ddd98954b1) feat: let claude fix ci
+- [63188e5](https://git.max-richter.dev/max/nodarium/commit/63188e57fd2cf055161508ee88cbef0cd941e662) feat: let claude fix ci
+- [4572d30](https://git.max-richter.dev/max/nodarium/commit/4572d30005d3538f357d4e9f1fb637c1a6559fb1) feat: let claude refactor ci
+- [ccc376d](https://git.max-richter.dev/max/nodarium/commit/ccc376d158f209b85a62d98919ac716e46e3e253) feat: store total vertices/faces in benchmarkl
+- [7e432e9](https://git.max-richter.dev/max/nodarium/commit/7e432e9033f7fdc73c21bb363cf502c1d8085407) chore: update ci workflow
+- [01f5837](https://git.max-richter.dev/max/nodarium/commit/01f58377c21048f95c839504a3e8c46c27ba12ae) feat: make more node group features work
+- [6ef5dc2](https://git.max-richter.dev/max/nodarium/commit/6ef5dc28ed9a4874a7b5fb2a9dca73efd1632519) chore: move jsonviewer into ui package
+- [3450d70](https://git.max-richter.dev/max/nodarium/commit/3450d7004781ea58f61d563967441a251c817a9b) docs: add LLM.md
+- [731b9e9](https://git.max-richter.dev/max/nodarium/commit/731b9e9b1e52598e11044874a46976e517a1150c) feat: upgrade graph source panel
+- [72f07d0](https://git.max-richter.dev/max/nodarium/commit/72f07d0a501fa715c40cf0e7c17527ef3f98e96b) feat: initial node groups
+- [a56e8f4](https://git.max-richter.dev/max/nodarium/commit/a56e8f445edb6064ae7a7b3b783fb7445f1b4e69) feat(ci): install openssh client
+- [1257274](https://git.max-richter.dev/max/nodarium/commit/12572742eb3ba1641cc744a18d330e88df50e9d0) fix(planty): remove debug span
+- [7aa9979](https://git.max-richter.dev/max/nodarium/commit/7aa9979e355fcf90342e8b5f1d233b879bb6c71f) chore: update e2e tests
+- [fc35a68](https://git.max-richter.dev/max/nodarium/commit/fc35a68826885ac7e9c624b39a5c0fe7d1cb83f0) fix: dont package ui library
+- [aba6f03](https://git.max-richter.dev/max/nodarium/commit/aba6f03bcce3e4363f0f22337d0000083bfff9a9) fix: dont package ui library
+- [2d6fd00](https://git.max-richter.dev/max/nodarium/commit/2d6fd00fd1ba31bfa943b6d3a4a628bd5132f668) fix: dont package ui library
+- [d231946](https://git.max-richter.dev/max/nodarium/commit/d231946e50975dfa1b41696cefbbc2f742480ea8) fix: remove unused imports
+- [e2f4a24](https://git.max-richter.dev/max/nodarium/commit/e2f4a24f759b917d3c7c1ca0b8347312785a03e5) fix(planty): make sure config is completely static
+- [58d39cd](https://git.max-richter.dev/max/nodarium/commit/58d39cd101298e6a41922d18466899f7bf4a0f97) feat: improve planty ux
+- [7ebb129](https://git.max-richter.dev/max/nodarium/commit/7ebb1297ac75987b3348dd81a57e0d25ed0a7405) feat(app): make zoom in nicer
+- [23f65a1](https://git.max-richter.dev/max/nodarium/commit/23f65a1c63650faba2051a2c87f7625378b4b0c6) fix: remove unused header div
+- [acdc582](https://git.max-richter.dev/max/nodarium/commit/acdc582e957df149ab723d268ac2e205595db199) feat: use ui and planty without build
+- [7a3e9eb](https://git.max-richter.dev/max/nodarium/commit/7a3e9eb893182e46e72e203df1eb7532a4652ddd) chore: update test screenshot
+- [be82312](https://git.max-richter.dev/max/nodarium/commit/be82312ea049b21e5ff859163e54ba6da88328a0) chore: update test screenshot
+- [84f67e9](https://git.max-richter.dev/max/nodarium/commit/84f67e9c33a1141d7e0c3332375576cd0898a47a) fix: update planty types
+- [491e345](https://git.max-richter.dev/max/nodarium/commit/491e345c2ff1893916848380e8941fa77dff44ec) feat: build planty in post install
+- [ba501b2](https://git.max-richter.dev/max/nodarium/commit/ba501b211db1d70930fa461e1fd82abb5b639c00) fix: correct tsconfig for planty
+- [7d76b9e](https://git.max-richter.dev/max/nodarium/commit/7d76b9e1f77ab934289bb18df6197bfd58ce3eeb) fix: mark planty as type:module
+- [5d4e2e9](https://git.max-richter.dev/max/nodarium/commit/5d4e2e928093cac39192960d9de21a0e1710904e) fix: make formatter happy
+- [4de15b1](https://git.max-richter.dev/max/nodarium/commit/4de15b19c8bdb35e53ba0d3e3e459cdbb12aee9d) feat: wire up planty with nodarium/app
+- [168e6fc](https://git.max-richter.dev/max/nodarium/commit/168e6fcc19dc55383b0b21d2b3ebab733058fb94) feat: update some node default settings
+- [c0eb75d](https://git.max-richter.dev/max/nodarium/commit/c0eb75d53c4251d041744b19a37c44d0d4a1728c) feat: new planty package
+- [2ec9bfc](https://git.max-richter.dev/max/nodarium/commit/2ec9bfc3c96a97aaf29557c70f76b7bf08156e15) feat(ci): compress benchmark data
+- [c975206](https://git.max-richter.dev/max/nodarium/commit/c97520617a0d48a765544feebf2d510400db8fb8) fix(ci): use older upload-artifact action
+- [6475790](https://git.max-richter.dev/max/nodarium/commit/64757901766efb7ccbd3693ebc63ba1367fe6d88) fix(ci): build nodes before benchmarking
+- [580ec73](https://git.max-richter.dev/max/nodarium/commit/580ec7346599e5d538ff53f31808ff770b4a8095) ci: run benchmark in ci
+
 # v0.0.5 (2026-02-13)

 ## Features
@@ -24,14 +24,6 @@ dependencies = [
 "nodarium_utils",
 ]

-[[package]]
-name = "debug"
-version = "0.1.0"
-dependencies = [
- "nodarium_macros",
- "nodarium_utils",
-]
-
 [[package]]
 name = "float"
 version = "0.1.0"
@@ -5,6 +5,7 @@ ENV RUSTUP_HOME=/usr/local/rustup \
  PATH=/usr/local/cargo/bin:$PATH

 RUN apt-get update && apt-get install -y \
+  openssh-client \
  ca-certificates=20230311+deb12u1 \
  gpg=2.2.40-1.1+deb12u2 \
  gpg-agent=2.2.40-1.1+deb12u2 \
@@ -27,6 +27,7 @@ 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

@@ -1,783 +0,0 @@
-# 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         |
@@ -1,227 +0,0 @@
-# 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
@@ -1,294 +0,0 @@
-# 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
@@ -28,6 +28,5 @@ 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
@@ -1,54 +1,204 @@
 import type { Graph, Graph as GraphType, NodeId } from '@nodarium/types';
-import { createLogger, createPerformanceStore } from '@nodarium/utils';
+import { createLogger, createPerformanceStore, splitNestedArray } from '@nodarium/utils';
+
 import { mkdir, writeFile } from 'node:fs/promises';
+import { freemem, loadavg, totalmem } from 'node:os';
 import { resolve } from 'node:path';
+
 import { MemoryRuntimeExecutor } from '../src/lib/runtime/runtime-executor.ts';
 import { BenchmarkRegistry } from './benchmarkRegistry.ts';
+
+import {
+  getMachineInfo,
+  measureCpuUsage,
+  readCgroupCpuStat,
+  readCpuSnapshot,
+  readProcMemInfo,
+  SystemSample
+} from './systemStats.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,
+  plant: plantTemplate as unknown as GraphType,
  'lotta-faces': lottaFacesTemplate as unknown as GraphType,
-  'default': defaultPlantTemplate as unknown as GraphType
+  default: defaultPlantTemplate as unknown as GraphType
 };

+function average(values: number[]) {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+
+function countGeometry(result: Int32Array): {
+  totalVertices: number;
+  totalFaces: number;
+} {
+  const parts = splitNestedArray(result);
+
+  let totalVertices = 0;
+  let totalFaces = 0;
+
+  for (const part of parts) {
+    const type = part[0];
+
+    const vertexCount = part[1] >>> 0;
+    const faceCount = part[2] >>> 0;
+
+    if (type === 2) {
+      const instanceCount = part[3] >>> 0;
+
+      totalVertices += vertexCount * instanceCount;
+      totalFaces += faceCount * instanceCount;
+    } else {
+      totalVertices += vertexCount;
+      totalFaces += faceCount;
+    }
+  }
+
+  return {
+    totalVertices,
+    totalFaces
+  };
+}
+
 async function run(g: GraphType, amount: number) {
-  await registry.load(plantTemplate.nodes.map(n => n.type) as NodeId[]);
+  await registry.load(g.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 });
  }

+  const systemSamples: SystemSample[] = [];
+
+  let previousCpuSnapshot = await readCpuSnapshot();
+
+  const sampler = setInterval(async () => {
+    try {
+      const cpu = await measureCpuUsage(previousCpuSnapshot);
+
+      previousCpuSnapshot = cpu.snapshot;
+
+      const [l1, l5, l15] = loadavg();
+
+      systemSamples.push({
+        timestamp: Date.now(),
+
+        cpuUsagePercent: cpu.usagePercent,
+        cpuStealPercent: cpu.stealPercent,
+
+        load1: l1,
+        load5: l5,
+        load15: l15,
+
+        freeMemory: freemem(),
+        totalMemory: totalmem()
+      });
+    } catch (err) {
+      console.error(err);
+    }
+  }, 1000);
+
  log.log('executing');
+
+  const perfStore = createPerformanceStore();
+
  r.perf = perfStore;
+
+  let res: Int32Array | undefined;
+
+  const cgroupBefore = await readCgroupCpuStat();
+
  for (let i = 0; i < amount; i++) {
    r.perf?.startRun();
-    await r.execute(g, { randomSeed: true });
+
+    res = await r.execute(g, { randomSeed: true });
+
    r.perf?.stopRun();
+
+    const { totalVertices, totalFaces } = countGeometry(res!);
+
+    r.perf?.addToLastRun('total-vertices', totalVertices);
+    r.perf?.addToLastRun('total-faces', totalFaces);
  }
+
+  const cgroupAfter = await readCgroupCpuStat();
+
+  clearInterval(sampler);
+
  log.log('finished');
-  return r.perf.get();
+
+  return {
+    data: r.perf.get(),
+    metadata: {
+      timestamp: new Date().toISOString(),
+
+      machine: getMachineInfo(),
+
+      process: {
+        pid: process.pid,
+        uptime: process.uptime(),
+
+        memoryUsage: process.memoryUsage()
+      },
+
+      system: {
+        averages: {
+          cpuUsagePercent: average(
+            systemSamples.map(s => s.cpuUsagePercent)
+          ),
+
+          cpuStealPercent: average(
+            systemSamples.map(s => s.cpuStealPercent)
+          ),
+
+          load1: average(systemSamples.map(s => s.load1)),
+          load5: average(systemSamples.map(s => s.load5)),
+          load15: average(systemSamples.map(s => s.load15)),
+
+          freeMemory: average(
+            systemSamples.map(s => s.freeMemory)
+          )
+        },
+
+        samples: systemSamples,
+
+        meminfo: await readProcMemInfo()
+      },
+
+      cgroup: {
+        before: cgroupBefore,
+        after: cgroupAfter
+      }
+    }
+  };
 }

 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 writeFile(
+      resolve(outPath, key + '.json'),
+      JSON.stringify(perfData, null, 2)
+    );
+
    await new Promise(res => setTimeout(res, 200));
  }
 }
@@ -0,0 +1,129 @@
+import { readFile } from 'node:fs/promises';
+import { cpus, totalmem } from 'node:os';
+
+export type CpuSnapshot = {
+  idle: number;
+  total: number;
+  steal: number;
+};
+
+export type SystemSample = {
+  timestamp: number;
+  cpuUsagePercent: number;
+  cpuStealPercent: number;
+  load1: number;
+  load5: number;
+  load15: number;
+  freeMemory: number;
+  totalMemory: number;
+};
+
+export async function readCpuSnapshot(): Promise<CpuSnapshot> {
+  const stat = await readFile('/proc/stat', 'utf8');
+  const line = stat.split('\n')[0];
+
+  const parts: number[] = line
+    .trim()
+    .split(/\s+/)
+    .slice(1)
+    .map((v: unknown) => Number(v));
+
+  const idle = parts[3];
+  const iowait = parts[4];
+  const steal = parts[7];
+
+  return {
+    idle: idle + iowait,
+    total: parts.reduce((a, b) => a + b, 0),
+    steal: steal ?? 0
+  };
+}
+
+export async function measureCpuUsage(
+  previous: CpuSnapshot
+): Promise<{
+  snapshot: CpuSnapshot;
+  usagePercent: number;
+  stealPercent: number;
+}> {
+  const current = await readCpuSnapshot();
+
+  const idle = current.idle - previous.idle;
+  const total = current.total - previous.total;
+  const steal = current.steal - previous.steal;
+
+  return {
+    snapshot: current,
+    usagePercent: total === 0 ? 0 : 100 * (1 - idle / total),
+    stealPercent: total === 0 ? 0 : 100 * (steal / total)
+  };
+}
+
+export async function readCgroupCpuStat() {
+  const possiblePaths = [
+    '/sys/fs/cgroup/cpu.stat',
+    '/sys/fs/cgroup/cpu/cpu.stat'
+  ];
+
+  for (const path of possiblePaths) {
+    try {
+      const txt: string = await readFile(path, 'utf8');
+
+      return Object.fromEntries(
+        txt
+          .trim()
+          .split('\n')
+          .map(line => {
+            const [k, v] = line.trim().split(/\s+/);
+            return [k, Number(v)];
+          })
+      );
+    } catch {
+      // continue
+    }
+  }
+
+  return null;
+}
+
+export async function readProcMemInfo() {
+  try {
+    const txt = await readFile('/proc/meminfo', 'utf8');
+
+    const result: Record<string, number> = {};
+
+    for (const line of txt.split('\n')) {
+      const match = line.match(/^(\w+):\s+(\d+)/);
+
+      if (!match) continue;
+
+      result[match[1]] = Number(match[2]);
+    }
+
+    return result;
+  } catch {
+    return null;
+  }
+}
+
+export function getMachineInfo() {
+  const cpuInfo = cpus();
+
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    nodeVersion: process.version,
+
+    cpuModel: cpuInfo[0]?.model ?? 'unknown',
+    cpuCount: cpuInfo.length,
+
+    totalMemory: totalmem(),
+
+    ci: {
+      githubActions: process.env.GITHUB_ACTIONS ?? false,
+      runnerName: process.env.RUNNER_NAME ?? null,
+      runnerOs: process.env.RUNNER_OS ?? null,
+      runnerArch: process.env.RUNNER_ARCH ?? null
+    }
+  };
+}
@@ -8,9 +8,6 @@ test('test', async ({ page }) => {

  await page.goto('http://localhost:4173', { waitUntil: 'load' });

-  // await expect(page).toHaveScreenshot();
-  await expect(page.locator('.graph-wrapper')).toHaveScreenshot();
-
  await page.getByRole('button', { name: 'projects' }).click();
  await page.getByRole('button', { name: 'New', exact: true }).click();
  await page.getByRole('combobox').selectOption('2');
@@ -23,9 +20,9 @@ test('test', async ({ page }) => {
      id: '10',
      type: 'max/plantarium/stem',
      props: {
-        amount: 50,
+        amount: 4,
        length: 4,
-        thickness: 1
+        thickness: 0.2
      }
    },
    {
@@ -1,13 +1,13 @@
 {
  "name": "@nodarium/app",
  "private": true,
-  "version": "0.0.5",
+  "version": "0.0.6",
  "type": "module",
  "scripts": {
    "dev": "vite dev",
    "predev": "rm static/CHANGELOG.md && ln -s ../../CHANGELOG.md static/CHANGELOG.md",
    "build": "svelte-kit sync && vite build",
-    "test:unit": "vitest",
+    "test:unit": "vitest --browser=false",
    "test": "npm run test:unit -- --run && npm run test:e2e",
    "test:e2e": "playwright test",
    "preview": "vite preview",
@@ -18,48 +18,49 @@
    "bench": "tsx ./benchmark/index.ts"
  },
  "dependencies": {
+    "@nodarium/planty": "workspace:*",
    "@nodarium/ui": "workspace:*",
    "@nodarium/utils": "workspace:*",
-    "@sveltejs/kit": "^2.50.2",
-    "@tailwindcss/vite": "^4.1.18",
-    "@threlte/core": "8.3.1",
-    "@threlte/extras": "9.7.1",
+    "@sveltejs/kit": "^2.59.0",
+    "@tailwindcss/vite": "^4.2.4",
+    "@threlte/core": "8.5.11",
+    "@threlte/extras": "9.15.1",
    "comlink": "^4.4.2",
    "file-saver": "^2.0.5",
    "idb": "^8.0.3",
    "jsondiffpatch": "^0.7.3",
    "micromark": "^4.0.2",
-    "tailwindcss": "^4.1.18",
-    "three": "^0.182.0"
+    "tailwindcss": "^4.2.4",
+    "three": "^0.184.0"
  },
  "devDependencies": {
-    "@eslint/compat": "^2.0.2",
-    "@eslint/js": "^9.39.2",
-    "@iconify-json/tabler": "^1.2.26",
-    "@iconify/tailwind4": "^1.2.1",
+    "@eslint/compat": "^2.0.5",
+    "@eslint/js": "^10.0.1",
+    "@iconify-json/tabler": "^1.2.33",
+    "@iconify/tailwind4": "^1.2.3",
    "@nodarium/types": "workspace:^",
-    "@playwright/test": "^1.58.1",
+    "@playwright/test": "^1.59.1",
    "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/vite-plugin-svelte": "^6.2.4",
-    "@tsconfig/svelte": "^5.0.7",
+    "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "@tsconfig/svelte": "^5.0.8",
    "@types/file-saver": "^2.0.7",
-    "@types/three": "^0.182.0",
-    "@vitest/browser-playwright": "^4.0.18",
-    "dprint": "^0.51.1",
-    "eslint": "^9.39.2",
-    "eslint-plugin-svelte": "^3.14.0",
-    "globals": "^17.3.0",
-    "svelte": "^5.49.2",
-    "svelte-check": "^4.3.6",
+    "@types/three": "^0.184.0",
+    "@vitest/browser-playwright": "^4.1.5",
+    "dprint": "^0.54.0",
+    "eslint": "^10.3.0",
+    "eslint-plugin-svelte": "^3.17.1",
+    "globals": "^17.6.0",
+    "svelte": "^5.55.5",
+    "svelte-check": "^4.4.7",
    "tslib": "^2.8.1",
    "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0",
-    "vite": "^7.3.1",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.1",
+    "vite": "^8.0.10",
    "vite-plugin-comlink": "^5.3.0",
-    "vite-plugin-glsl": "^1.5.5",
-    "vite-plugin-wasm": "^3.5.0",
-    "vitest": "^4.0.18",
-    "vitest-browser-svelte": "^2.0.2"
+    "vite-plugin-glsl": "^1.6.0",
+    "vite-plugin-wasm": "^3.6.0",
+    "vitest": "^4.1.5",
+    "vitest-browser-svelte": "^2.1.1"
  }
 }
@@ -1,5 +1,7 @@
@import "tailwindcss";
@source "../../packages/ui/**/*.svelte";
+@source "../../packages/planty/src/lib/**/*.svelte";
+
@plugin "@iconify/tailwind4" {
  prefix: "i";
  icon-sets: from-folder("custom", "./src/lib/icons");
@@ -3,6 +3,7 @@
  <head>
    <meta charset="utf-8" />
    <link rel="icon" href="%sveltekit.assets%/favicon.svg" />
+    <meta name="color-scheme" content="light dark">
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    %sveltekit.head%
    <title>Nodes</title>
@@ -1,10 +1,12 @@
 <script lang="ts">
  import { appSettings } from '$lib/settings/app-settings.svelte';
-  import { T } from '@threlte/core';
+  import { T, useThrelte } from '@threlte/core';
  import { colors } from '../graph/colors.svelte';
  import BackgroundFrag from './Background.frag';
  import BackgroundVert from './Background.vert';

+  const { invalidate } = useThrelte();
+
  type Props = {
    minZoom?: number;
    maxZoom?: number;
@@ -33,9 +35,16 @@

  let bw = $derived(width / cameraPosition[2]);
  let bh = $derived(height / cameraPosition[2]);
+
+  $effect(() => {
+    if (appSettings.value.theme) {
+      setTimeout(() => invalidate(), 10);
+    }
+  });
 </script>

 <T.Group
+  visible={!appSettings.value.theme.includes('contrast')}
  position.x={cameraPosition[0]}
  position.z={cameraPosition[1]}
  position.y={-1.0}
@@ -183,8 +183,10 @@
            activeNodeId = node.id;
          }}
        >
-          {node.id.split('/').at(-1)}
+          {node.meta?.title ?? node.id.split('/').at(-1)}
        </div>
+      {:else}
+        <div class="no-results">No results for "{value}"</div>
      {/each}
    </div>
  </div>
@@ -241,4 +243,11 @@
    background: var(--color-layer-2);
    opacity: 1;
  }
+
+  .no-results {
+    padding: 1em 0.9em;
+    font-size: 0.85em;
+    opacity: 0.45;
+    font-style: italic;
+  }
 </style>
@@ -0,0 +1,68 @@
+<script lang="ts">
+  import { Button } from '@nodarium/ui';
+  import { getGraphManager } from '../graph-state.svelte';
+  const graph = getGraphManager();
+
+  function getGroupName(groupId: number) {
+    const group = graph.getGroup(groupId);
+    return group?.name || `Group#${groupId}`;
+  }
+
+  function exitToGroup(targetId?: number) {
+    while (graph.currentGroupId !== (targetId ?? null)) {
+      graph.exitGroup();
+    }
+  }
+
+  // Intermediate groups: parent stack entries that are groups (not the root graph).
+  const intermediateGroups = $derived(
+    graph.parentStack.filter(e => e.id !== graph.id)
+  );
+</script>
+
+<div class="shadow" class:is-inside-group={graph.isInsideGroup}></div>
+
+{#if graph.isInsideGroup}
+  <div class="group-name flex gap-1 items-center">
+    <Button variant="ghost" size="sm" onclick={() => exitToGroup()}>Root</Button>
+
+    {#each intermediateGroups as entry (entry.id)}
+      <span class="i-[tabler--arrow-right]"></span>
+      <Button variant="ghost" size="sm" onclick={() => exitToGroup(entry.id)}>
+        {getGroupName(entry.id)}
+      </Button>
+    {/each}
+
+    <span class="i-[tabler--arrow-right]"></span>
+    <Button variant="ghost" size="sm" class="opacity-100!">
+      {getGroupName(graph.currentGroupId!)}
+    </Button>
+  </div>
+{/if}
+
+<style>
+  .shadow {
+    position: absolute;
+    top: -5px;
+    left: -5px;
+    right: calc(var(--padding-right) - 5px);
+    bottom: -5px;
+    z-index: 1;
+    transition: box-shadow 0.3s ease;
+    box-shadow: 0 0 0px 0px var(--color-layer-2) inset;
+    pointer-events: none;
+  }
+
+  .shadow.is-inside-group  {
+    box-shadow: 0 0 0px 8px var(--color-layer-2) inset;
+  }
+
+  .group-name {
+    position: absolute;
+    left: calc(50% - var(--padding-right) / 2);
+    transition: left 0.3s ease;
+    top: 12px;
+    transform: translateX(-50%);
+    z-index: 1000;
+  }
+</style>
@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { assert, describe, expect, it } from 'vitest';
 import { GraphManager } from './graph-manager.svelte';
 import {
  createMockNodeRegistry,
@@ -9,7 +9,150 @@ import {
  mockVec3OutputNode
 } from './test-utils';

-describe('GraphManager', () => {
+describe('groupNodes', () => {
+  it('should not do anything if no nodes are selected', () => {
+    const registry = createMockNodeRegistry([
+      mockFloatOutputNode,
+      mockFloatInputNode,
+      mockGeometryOutputNode,
+      mockPathInputNode
+    ]);
+
+    const manager = new GraphManager(registry);
+
+    const floatInputNode = manager.createNode({
+      type: 'test/node/input',
+      position: [100, 100],
+      props: {}
+    });
+
+    assert.isDefined(floatInputNode);
+
+    const floatOutputNode = manager.createNode({
+      type: 'test/node/output',
+      position: [0, 0],
+      props: {}
+    });
+    assert.isDefined(floatOutputNode);
+
+    const edge = manager.createEdge(floatInputNode, 0, floatOutputNode, 'input');
+    assert.isDefined(edge);
+    manager.save();
+
+    manager.groupNodes([]);
+
+    const graph = manager.serialize();
+    expect(graph.nodes.length).toBe(2);
+    expect(graph.edges.length).toBe(1);
+    expect(graph.groups.length).toBe(0);
+  });
+
+  it('should group selected nodes and create a group node', () => {
+    const registry = createMockNodeRegistry([
+      mockFloatOutputNode,
+      mockFloatInputNode,
+      mockGeometryOutputNode,
+      mockPathInputNode
+    ]);
+
+    const manager = new GraphManager(registry);
+
+    const floatInputNode = manager.createNode({
+      type: 'test/node/input',
+      position: [100, 100],
+      props: {}
+    });
+
+    assert.isDefined(floatInputNode);
+
+    const floatOutputNode = manager.createNode({
+      type: 'test/node/output',
+      position: [0, 0],
+      props: {}
+    });
+    assert.isDefined(floatOutputNode);
+
+    const edge = manager.createEdge(floatInputNode, 0, floatOutputNode, 'input');
+    assert.isDefined(edge);
+    manager.save();
+
+    const groupNode = manager.groupNodes([floatInputNode.id]);
+    assert.isDefined(groupNode);
+
+    const graph = manager.serialize();
+
+    expect(graph.nodes.map(n => n.id), 'graph to contain group node').to.contain(groupNode.id);
+    expect(graph.groups[0].nodes.map(n => n.id), 'group graph to contain float node').to.contain(
+      floatInputNode.id
+    );
+    expect(graph.nodes.map(n => n.id)).not.to.contain(floatInputNode.id);
+
+    expect(graph.nodes.length).toBe(2);
+    expect(graph.edges.length).toBe(1);
+    expect(graph.groups.length).toBe(1);
+  });
+
+  it('should rewire external edges when grouping a middle node in a chain', () => {
+    const registry = createMockNodeRegistry([mockFloatOutputNode, mockFloatInputNode]);
+    const manager = new GraphManager(registry);
+
+    // A → B → C  (float chain: output → middle → input)
+    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    const nodeB = manager.createNode({ type: 'test/node/output', position: [100, 0], props: {} });
+    const nodeC = manager.createNode({ type: 'test/node/input', position: [200, 0], props: {} });
+
+    assert.isDefined(nodeA);
+    assert.isDefined(nodeB);
+    assert.isDefined(nodeC);
+
+    manager.createEdge(nodeA, 0, nodeB, 'input');
+    manager.createEdge(nodeB, 0, nodeC, 'value');
+
+    const groupNode = manager.groupNodes([nodeB.id]);
+    assert.isDefined(groupNode);
+
+    const graph = manager.serialize();
+
+    // Top-level: A, C, groupNode — B is gone
+    expect(graph.nodes.length, 'top-level node count').toBe(3);
+    const topLevelIds = graph.nodes.map(n => n.id);
+    expect(topLevelIds).toContain(nodeA.id);
+    expect(topLevelIds).toContain(nodeC.id);
+    expect(topLevelIds).toContain(groupNode.id);
+    expect(topLevelIds).not.toContain(nodeB.id);
+
+    // Both original edges survive, now routing through the group node
+    expect(graph.edges.length, 'edge count unchanged').toBe(2);
+    const edgeSources = graph.edges.map(e => e[0]);
+    const edgeTargets = graph.edges.map(e => e[2]);
+    expect(edgeTargets).toContain(groupNode.id); // A → groupNode
+    expect(edgeSources).toContain(groupNode.id); // groupNode → C
+
+    // One group definition was created
+    expect(graph.groups.length).toBe(1);
+    const group = graph.groups[0];
+
+    // Group contains B plus the two boundary nodes
+    const groupNodeIds = group.nodes.map(n => n.id);
+    expect(groupNodeIds).toContain(nodeB.id);
+    const inputBoundary = group.nodes.find(n => n.type === '__internal/group/input');
+    const outputBoundary = group.nodes.find(n => n.type === '__internal/group/output');
+    expect(inputBoundary, 'group input boundary node').toBeDefined();
+    expect(outputBoundary, 'group output boundary node').toBeDefined();
+
+    // Group declares one input slot and one output slot
+    expect(Object.keys(group.inputs ?? {}).length, 'group input count').toBe(1);
+    expect(group.outputs?.length, 'group output count').toBe(1);
+
+    // Internal edges wire: inputBoundary → B → outputBoundary
+    expect(group.edges.length, 'internal edge count').toBe(2);
+    const internalSources = group.edges.map(e => e[0]);
+    const internalTargets = group.edges.map(e => e[2]);
+    expect(internalTargets).toContain(nodeB.id);
+    expect(internalSources).toContain(nodeB.id);
+  });
+});
+
 describe('getPossibleSockets', () => {
  describe('when dragging an output socket', () => {
    it('should return compatible input sockets based on type', () => {
@@ -262,4 +405,3 @@ describe('GraphManager', () => {
    });
  });
 });
-});
@@ -0,0 +1,262 @@
+import { assert, describe, expect, it } from 'vitest';
+import { GraphManager } from './graph-manager.svelte';
+import { GraphState } from './graph-state.svelte';
+import { createMockNodeRegistry, mockFloatInputNode, mockFloatOutputNode } from './test-utils';
+
+// GraphState constructor reads localStorage synchronously — mock before any instantiation
+Object.defineProperty(globalThis, 'localStorage', {
+  value: {
+    getItem: () => null,
+    setItem: () => {},
+    removeItem: () => {},
+    clear: () => {},
+    length: 0,
+    key: () => null
+  } as Storage,
+  writable: true,
+  configurable: true
+});
+
+function createFixture() {
+  const registry = createMockNodeRegistry([mockFloatOutputNode, mockFloatInputNode]);
+  const manager = new GraphManager(registry);
+  const state = new GraphState(manager);
+  return { manager, state };
+}
+
+describe('clearSelection', () => {
+  it('empties selectedNodes', () => {
+    const { state } = createFixture();
+    state.selectedNodes.add(1);
+    state.selectedNodes.add(2);
+    state.clearSelection();
+    expect(state.selectedNodes.size).toBe(0);
+  });
+});
+
+describe('projectScreenToWorld', () => {
+  it('maps the viewport centre to the camera position', () => {
+    const { state } = createFixture();
+    // cameraPosition default: [140, 100, 3.5], width=100, height=100
+    state.width = 100;
+    state.height = 100;
+    state.cameraPosition = [140, 100, 3.5];
+    const [wx, wy] = state.projectScreenToWorld(50, 50);
+    expect(wx).toBeCloseTo(140);
+    expect(wy).toBeCloseTo(100);
+  });
+
+  it('offsets correctly for a point not at centre', () => {
+    const { state } = createFixture();
+    state.width = 100;
+    state.height = 100;
+    state.cameraPosition = [0, 0, 2];
+    const [wx, wy] = state.projectScreenToWorld(100, 50);
+    // x: 0 + (100 - 50) / 2 = 25
+    expect(wx).toBeCloseTo(25);
+    expect(wy).toBeCloseTo(0);
+  });
+});
+
+describe('groupSelectedNodes', () => {
+  it('delegates to graph.groupNodes with selected IDs and activeNodeId', () => {
+    const { manager, state } = createFixture();
+
+    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    const nodeB = manager.createNode({ type: 'test/node/input', position: [100, 0], props: {} });
+    assert.isDefined(nodeA);
+    assert.isDefined(nodeB);
+
+    state.selectedNodes.add(nodeA!.id);
+    state.activeNodeId = nodeB!.id;
+
+    const groupNode = state.groupSelectedNodes();
+    assert.isDefined(groupNode);
+
+    const graph = manager.serialize();
+    expect(graph.groups.length).toBe(1);
+    expect(graph.nodes.map(n => n.id)).toContain(groupNode!.id);
+  });
+
+  it('works when only activeNodeId is set with no extra selection', () => {
+    const { manager, state } = createFixture();
+
+    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    assert.isDefined(nodeA);
+
+    state.activeNodeId = nodeA!.id;
+    const groupNode = state.groupSelectedNodes();
+    assert.isDefined(groupNode);
+
+    expect(manager.groups.length).toBe(1);
+  });
+});
+
+describe('enterGroupNode', () => {
+  it('does nothing when activeNodeId is -1', () => {
+    const { manager, state } = createFixture();
+    state.activeNodeId = -1;
+    state.enterGroupNode();
+    expect(manager.parentStack.length).toBe(0);
+  });
+
+  it('does nothing when the active node is not a group instance', () => {
+    const { manager, state } = createFixture();
+    const node = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    assert.isDefined(node);
+    state.activeNodeId = node!.id;
+    state.enterGroupNode();
+    expect(manager.parentStack.length).toBe(0);
+  });
+
+  it('enters the group, pushes graphStack, and clears UI state', () => {
+    const { manager, state } = createFixture();
+
+    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    assert.isDefined(nodeA);
+    const groupNode = manager.groupNodes([nodeA!.id]);
+    assert.isDefined(groupNode);
+
+    state.selectedNodes.add(nodeA!.id);
+    state.activeNodeId = groupNode!.id;
+    state.cameraPosition = [10, 20, 5];
+
+    state.enterGroupNode();
+
+    expect(manager.parentStack.length).toBe(1);
+    expect(state.activeNodeId).toBe(-1);
+    expect(state.selectedNodes.size).toBe(0);
+    expect(manager.isInsideGroup).toBe(true);
+  });
+});
+
+describe('exitGroupNode', () => {
+  it('does nothing when not inside a group', () => {
+    const { manager, state } = createFixture();
+    const before = [...state.cameraPosition];
+    state.exitGroupNode();
+    expect(manager.parentStack.length).toBe(0);
+    expect(state.cameraPosition).toEqual(before);
+  });
+
+  it('clears activeNodeId and selection after exit', () => {
+    const { manager, state } = createFixture();
+
+    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    assert.isDefined(nodeA);
+    const groupNode = manager.groupNodes([nodeA!.id]);
+    assert.isDefined(groupNode);
+
+    state.activeNodeId = groupNode!.id;
+    state.enterGroupNode();
+    state.activeNodeId = 99;
+    state.selectedNodes.add(99);
+
+    state.exitGroupNode();
+
+    // Group instance node is re-selected on exit; internal selection is cleared
+    expect(state.activeNodeId).toBe(groupNode!.id);
+    expect(state.selectedNodes.size).toBe(0);
+  });
+
+  it('restores outer nodes to manager after exit', () => {
+    const { manager, state } = createFixture();
+
+    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    const nodeB = manager.createNode({ type: 'test/node/input', position: [100, 0], props: {} });
+    assert.isDefined(nodeA);
+    assert.isDefined(nodeB);
+
+    manager.createEdge(nodeA!, 0, nodeB!, 'value');
+    const groupNode = manager.groupNodes([nodeA!.id]);
+    assert.isDefined(groupNode);
+
+    state.activeNodeId = groupNode!.id;
+    state.enterGroupNode();
+
+    // Inside the group: nodeA is an internal node so it IS active; the outer
+    // nodes (nodeB, groupNode) are saved and no longer in the active Map.
+    expect(manager.nodes.has(nodeA!.id)).toBe(true);
+    expect(manager.nodes.has(nodeB!.id)).toBe(false);
+
+    state.exitGroupNode();
+
+    // After exit: outer nodes are restored
+    expect(manager.nodes.has(nodeB!.id)).toBe(true);
+    expect(manager.nodes.has(groupNode!.id)).toBe(true);
+    expect(manager.isInsideGroup).toBe(false);
+  });
+
+  it('isInsideGroup is false after exiting the only group level', () => {
+    const { manager, state } = createFixture();
+
+    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    assert.isDefined(nodeA);
+    const groupNode = manager.groupNodes([nodeA!.id]);
+    assert.isDefined(groupNode);
+
+    state.activeNodeId = groupNode!.id;
+    state.enterGroupNode();
+    expect(manager.isInsideGroup).toBe(true);
+
+    state.exitGroupNode();
+    expect(manager.isInsideGroup).toBe(false);
+  });
+});
+
+describe('copyNodes / pasteNodes', () => {
+  it('copies the active node into the clipboard', () => {
+    const { manager, state } = createFixture();
+    const node = manager.createNode({ type: 'test/node/output', position: [10, 20], props: {} });
+    assert.isDefined(node);
+
+    state.activeNodeId = node!.id;
+    state.mousePosition = [0, 0];
+    state.copyNodes();
+
+    assert.isNotNull(state.clipboard);
+    expect(state.clipboard!.nodes.map(n => n.id)).toContain(node!.id);
+  });
+
+  it('includes edges between copied nodes', () => {
+    const { manager, state } = createFixture();
+    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    const nodeB = manager.createNode({ type: 'test/node/input', position: [100, 0], props: {} });
+    assert.isDefined(nodeA);
+    assert.isDefined(nodeB);
+
+    manager.createEdge(nodeA!, 0, nodeB!, 'value');
+
+    state.activeNodeId = nodeA!.id;
+    state.selectedNodes.add(nodeB!.id);
+    state.mousePosition = [0, 0];
+    state.copyNodes();
+
+    assert.isNotNull(state.clipboard);
+    expect(state.clipboard!.edges.length).toBe(1);
+  });
+
+  it('pastes nodes and adds them to the graph', () => {
+    const { manager, state } = createFixture();
+    const node = manager.createNode({ type: 'test/node/output', position: [10, 20], props: {} });
+    assert.isDefined(node);
+
+    state.activeNodeId = node!.id;
+    state.mousePosition = [0, 0];
+    state.copyNodes();
+
+    const countBefore = manager.nodes.size;
+    state.mousePosition = [50, 50];
+    state.pasteNodes();
+
+    expect(manager.nodes.size).toBe(countBefore + 1);
+  });
+
+  it('does nothing when clipboard is empty', () => {
+    const { manager, state } = createFixture();
+    manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
+    const countBefore = manager.nodes.size;
+    state.pasteNodes();
+    expect(manager.nodes.size).toBe(countBefore);
+  });
+});
@@ -1,10 +1,16 @@
-import type { NodeInstance, Socket } from '@nodarium/types';
+import { animate, lerp } from '$lib/helpers';
+import type { NodeInstance, SerializedEdge, SerializedNode, Socket } from '@nodarium/types';
 import { getContext, setContext } from 'svelte';
 import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import type { OrthographicCamera, Vector3 } from 'three';
 import type { GraphManager } from './graph-manager.svelte';
 import { ColorGenerator } from './graph/colors';
-import { getNodeHeight, getSocketPosition } from './helpers/nodeHelpers';
+import {
+  getNodeHeight,
+  getParameterHeight,
+  serializeEdge,
+  serializeNode
+} from './helpers/nodeHelpers';

 const graphStateKey = Symbol('graph-state');
 export function getGraphState() {
@@ -94,8 +100,8 @@ export class GraphState {
  cameraPosition: [number, number, number] = $state([140, 100, 3.5]);

  clipboard: null | {
-    nodes: NodeInstance[];
-    edges: [number, number, number, string][];
+    nodes: SerializedNode[];
+    edges: SerializedEdge[];
  } = null;

  cameraBounds = $derived([
@@ -124,6 +130,9 @@ export class GraphState {
  activeNodeId = $state(-1);
  selectedNodes = new SvelteSet<number>();
  activeSocket = $state<Socket | null>(null);
+  safePadding = $state<{ left?: number; right?: number; bottom?: number; top?: number } | null>(
+    null
+  );
  hoveredSocket = $state<Socket | null>(null);
  possibleSockets = $state<Socket[]>([]);
  possibleSocketIds = $derived(
@@ -148,10 +157,6 @@ export class GraphState {
    this.edges.delete(edgeId);
  }

-  getEdgeData() {
-    return this.edges;
-  }
-
  updateNodePosition(node: NodeInstance) {
    if (
      node.state.x === node.position[0]
@@ -186,39 +191,14 @@ export class GraphState {
    return 1;
  }

-  tryConnectToDebugNode(nodeId: number) {
-    const node = this.graph.nodes.get(nodeId);
-    if (!node) return;
-    if (node.type.endsWith('/debug')) return;
-    if (!node.state.type?.outputs?.length) return;
-    for (const _node of this.graph.nodes.values()) {
-      if (_node.type.endsWith('/debug')) {
-        this.graph.createEdge(node, 0, _node, 'input');
-        return;
-      }
-    }
-
-    const debugNode = this.graph.createNode({
-      type: 'max/plantarium/debug',
-      position: [node.position[0] + 30, node.position[1]],
-      props: {}
-    });
-
-    if (debugNode) {
-      this.graph.createEdge(node, 0, debugNode, 'input');
-    }
-  }
-
  copyNodes() {
    if (this.activeNodeId === -1 && !this.selectedNodes?.size) {
      return;
    }
-    let nodes = [
-      this.activeNodeId,
-      ...(this.selectedNodes?.values() || [])
-    ]
+    const ids = new SvelteSet([this.activeNodeId, ...(this.selectedNodes?.values() || [])]);
+    let nodes = [...ids]
      .map((id) => this.graph.getNode(id))
-      .filter(b => !!b);
+      .filter((b): b is NodeInstance => !!b);

    const edges = this.graph.getEdgesBetweenNodes(nodes);
    nodes = nodes.map((node) => ({
@@ -226,26 +206,67 @@ export class GraphState {
      position: [
        this.mousePosition[0] - node.position[0],
        this.mousePosition[1] - node.position[1]
-      ],
-      tmp: undefined
+      ]
    }));

    this.clipboard = {
-      nodes: nodes,
-      edges: edges
+      nodes: nodes.map(n => serializeNode(n)),
+      edges: edges.map(e => serializeEdge(e))
    };
  }

+  unGroupSelectedNodes() {
+    return this.graph.ungroupNode(this.activeNodeId);
+  }
+
+  groupSelectedNodes() {
+    return this.graph.groupNodes([...this.selectedNodes.keys(), this.activeNodeId]);
+  }
+
+  centerNode(node?: NodeInstance) {
+    const average = [0, 0, 4];
+    if (node) {
+      average[0] = node.position[0] + (this.safePadding?.right || 0) / 10;
+      average[1] = node.position[1];
+      average[2] = 10;
+    } else {
+      for (const node of this.graph.nodes.values()) {
+        average[0] += node.position[0];
+        average[1] += node.position[1];
+      }
+      average[0] = (average[0] / this.graph.nodes.size)
+        + (this.safePadding?.right || 0) / (average[2] * 2);
+      average[1] /= this.graph.nodes.size;
+    }
+
+    const camX = this.cameraPosition[0];
+    const camY = this.cameraPosition[1];
+    const camZ = this.cameraPosition[2];
+
+    const ease = (t: number) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t);
+    const easeZoom = (t: number) => t * t * (3 - 2 * t);
+
+    animate(500, (a: number) => {
+      this.cameraPosition[0] = lerp(camX, average[0], ease(a));
+      this.cameraPosition[1] = lerp(camY, average[1], ease(a));
+      this.cameraPosition[2] = lerp(camZ, average[2], easeZoom(a));
+      if (this.mouseDown) return false;
+    });
+  }
+
  pasteNodes() {
    if (!this.clipboard) return;

-    const nodes = this.clipboard.nodes
-      .map((node) => {
-        node.position[0] = this.mousePosition[0] - node.position[0];
-        node.position[1] = this.mousePosition[1] - node.position[1];
-        return node;
-      })
-      .filter(Boolean) as NodeInstance[];
+    // Create fresh node objects — never mutate clipboard so repeat pastes work correctly.
+    // State is also spread (with cleared parents/children) so createGraph's mutations
+    // don't corrupt the clipboard's stored state references.
+    const nodes = this.clipboard.nodes.map((node) => ({
+      ...node,
+      position: [
+        this.mousePosition[0] - node.position[0],
+        this.mousePosition[1] - node.position[1]
+      ] as [number, number]
+    }));

    const newNodes = this.graph.createGraph(nodes, this.clipboard.edges);
    this.selectedNodes.clear();
@@ -259,14 +280,14 @@ export class GraphState {

    let { node, index, position } = socket;

-    // if the socket is an input socket -> remove existing edges
+    // remove existing edge
    if (typeof index === 'string') {
      const edges = this.graph.getEdgesToNode(node);
      for (const edge of edges) {
        if (edge[3] === index) {
          node = edge[0];
          index = edge[1];
-          position = getSocketPosition(node, index);
+          position = this.getSocketPosition(node, index);
          this.graph.removeEdge(edge);
          break;
        }
@@ -286,7 +307,7 @@ export class GraphState {
        return {
          node,
          index,
-          position: getSocketPosition(node, index)
+          position: this.getSocketPosition(node, index)
        };
      });
  }
@@ -323,7 +344,8 @@ export class GraphState {
        for (const node of this.graph.nodes.values()) {
          const x = node.position[0];
          const y = node.position[1];
-          const height = getNodeHeight(node.state.type!);
+          const nodeType = this.graph.getNodeType(node);
+          const height = nodeType ? getNodeHeight(nodeType) : 20;
          if (downX > x && downX < x + 20 && downY > y && downY < y + height) {
            clickedNodeId = node.id;
            break;
@@ -335,7 +357,8 @@ export class GraphState {
  }

  isNodeInView(node: NodeInstance) {
-    const height = getNodeHeight(node.state.type!);
+    if (!node) return false;
+    const height = getNodeHeight(this.graph.getNodeType(node)!);
    const width = 20;
    return node.position[0] > this.cameraBounds[0] - width
      && node.position[0] < this.cameraBounds[1]
@@ -346,4 +369,57 @@ export class GraphState {
  openNodePalette() {
    this.addMenuPosition = [this.mousePosition[0], this.mousePosition[1]];
  }
+
+  enterGroupNode() {
+    if (this.activeNodeId === -1) return;
+    const node = this.graph.getNode(this.activeNodeId);
+    if (!node || node.type !== '__internal/group/instance') return;
+    const ok = this.graph.enterGroup(this.activeNodeId);
+    if (ok) {
+      this.activeNodeId = -1;
+      this.clearSelection();
+    }
+  }
+
+  exitGroupNode() {
+    const result = this.graph.exitGroup();
+    if (!result) return;
+    this.activeNodeId = result.nodeId;
+    this.clearSelection();
+  }
+
+  getSocketPosition(
+    node: NodeInstance,
+    index: string | number
+  ): [number, number] {
+    if (node.type === '__internal/group/input' && typeof index === 'number') {
+      return [
+        (node?.state?.x ?? node.position[0]) + 20,
+        (node?.state?.y ?? node.position[1]) + 2.5 + 5 * index + 5
+      ];
+    }
+
+    if (typeof index === 'number') {
+      return [
+        (node?.state?.x ?? node.position[0]) + 20,
+        (node?.state?.y ?? node.position[1]) + 2.5 + 10 * index
+      ];
+    } else {
+      let height = 5;
+      const nodeType = this.graph.getNodeType(node)!;
+      const inputs = nodeType.inputs || {};
+      for (const inputKey in inputs) {
+        const h = getParameterHeight(nodeType, inputKey) / 10;
+        if (inputKey === index) {
+          height += h / 2;
+          break;
+        }
+        height += h;
+      }
+      return [
+        node?.state?.x ?? node.position[0],
+        (node?.state?.y ?? node.position[1]) + height
+      ];
+    }
+  }
 }
@@ -7,22 +7,23 @@
  import AddMenu from '../components/AddMenu.svelte';
  import BoxSelection from '../components/BoxSelection.svelte';
  import Camera from '../components/Camera.svelte';
+  import GroupBreadcrumps from '../components/GroupBreadcrumps.svelte';
  import HelpView from '../components/HelpView.svelte';
  import Debug from '../debug/Debug.svelte';
  import EdgeEl from '../edges/Edge.svelte';
  import { getGraphManager, getGraphState } from '../graph-state.svelte';
-  import { getSocketPosition } from '../helpers/nodeHelpers';
  import NodeEl from '../node/Node.svelte';
  import { maxZoom, minZoom } from './constants';
  import { FileDropEventManager } from './drop.events';
  import { MouseEventManager } from './mouse.events';
+  import ZoomIndicator from './ZoomIndicator.svelte';

  const {
    keymap,
-    addMenuPadding
+    safePadding
  }: {
    keymap: ReturnType<typeof createKeyMap>;
-    addMenuPadding?: { left?: number; right?: number; bottom?: number; top?: number };
+    safePadding?: { left?: number; right?: number; bottom?: number; top?: number };
  } = $props();

  const graph = getGraphManager();
@@ -39,8 +40,8 @@
      return [0, 0, 0, 0];
    }

-    const pos1 = getSocketPosition(fromNode, edge[1]);
-    const pos2 = getSocketPosition(toNode, edge[3]);
+    const pos1 = graphState.getSocketPosition(fromNode, edge[1]);
+    const pos2 = graphState.getSocketPosition(toNode, edge[3]);
    return [pos1[0], pos1[1], pos2[0], pos2[1]];
  }

@@ -97,10 +98,17 @@
  }

  function getSocketType(node: NodeInstance, index: number | string): string {
+    const nodeType = graph.getNodeType(node);
    if (typeof index === 'string') {
-      return node.state.type?.inputs?.[index].type || 'unknown';
+      return nodeType?.inputs?.[index].type || 'unknown';
    }
-    return node.state.type?.outputs?.[index] || 'unknown';
+
+    if (node.type === '__internal/group/input') {
+      const key = Object.keys(nodeType?.inputs || {})[index];
+      return nodeType?.inputs?.[key].type || 'unknown';
+    }
+
+    return nodeType?.outputs?.[index] || 'unknown';
  }
 </script>

@@ -114,6 +122,7 @@
  bind:this={graphState.wrapper}
  class="graph-wrapper"
  style="height: 100%"
+  class:is-inside-group={graph.isInsideGroup}
  class:is-panning={graphState.isPanning}
  class:is-hovering={graphState.hoveredNodeId !== -1}
  aria-label="Graph"
@@ -121,6 +130,7 @@
  tabindex="0"
  bind:clientWidth={graphState.width}
  bind:clientHeight={graphState.height}
+  style:--padding-right="{safePadding?.right || 0}px"
  onkeydown={(ev) => keymap.handleKeyboardEvent(ev)}
  onmousedown={(ev) => mouseEvents.handleMouseDown(ev)}
  oncontextmenu={(ev) => mouseEvents.handleContextMenu(ev)}
@@ -136,6 +146,8 @@
  />
  <label for="drop-zone"></label>

+  <GroupBreadcrumps />
+
  <Canvas shadows={false} renderMode="on-demand" colorManagementEnabled={false}>
    <Camera
      bind:camera={graphState.camera}
@@ -172,10 +184,10 @@
      {#if graphState.addMenuPosition}
        <AddMenu
          onnode={handleNodeCreation}
-          paddingTop={addMenuPadding?.top}
-          paddingRight={addMenuPadding?.right}
-          paddingBottom={addMenuPadding?.bottom}
-          paddingLeft={addMenuPadding?.left}
+          paddingTop={safePadding?.top}
+          paddingRight={safePadding?.right}
+          paddingBottom={safePadding?.bottom}
+          paddingLeft={safePadding?.left}
        />
      {/if}

@@ -216,10 +228,10 @@
          style:transform={`scale(${graphState.cameraPosition[2] * 0.1})`}
          class:hovering-sockets={graphState.activeSocket}
        >
-          {#each graph.nodes.values() as node (node.id)}
+          {#each graph.nodeArray as node, index (node)}
            <NodeEl
-              {node}
-              inView={graphState.isNodeInView(node)}
+              bind:node={graph.nodeArray[index]}
+              inView={node ? graphState.isNodeInView(node) : false}
            />
          {/each}
        </div>
@@ -236,6 +248,8 @@
  <HelpView registry={graph.registry} />
 {/if}

+<ZoomIndicator {safePadding} />
+
 <style>
  .graph-wrapper {
    position: relative;
@@ -1,6 +1,7 @@
 <script lang="ts">
  import { createKeyMap } from '$lib/helpers/createKeyMap';
  import type { Graph, NodeInstance, NodeRegistry } from '@nodarium/types';
+  import { onMount } from 'svelte';
  import { GraphManager } from '../graph-manager.svelte';
  import { GraphState, setGraphManager, setGraphState } from '../graph-state.svelte';
  import { setupKeymaps } from '../keymaps';
@@ -18,7 +19,7 @@
    showHelp?: boolean;
    settingTypes?: Record<string, unknown>;

-    addMenuPadding?: { left?: number; right?: number; bottom?: number; top?: number };
+    safePadding?: { left?: number; right?: number; bottom?: number; top?: number };

    onsave?: (save: Graph) => void;
    onresult?: (result: unknown) => void;
@@ -27,13 +28,13 @@
  let {
    graph,
    registry,
-    addMenuPadding,
+    safePadding,
+    // eslint-disable-next-line no-useless-assignment
    settings = $bindable(),
    activeNode = $bindable(),
    backgroundType = $bindable('grid'),
    snapToGrid = $bindable(true),
    showHelp = $bindable(false),
-    settings = $bindable(),
    settingTypes = $bindable(),
    onsave,
    onresult
@@ -45,29 +46,32 @@
  export const manager = new GraphManager(registry);
  setGraphManager(manager);

-  const graphState = new GraphState(manager);
+  export const state = new GraphState(manager);
  $effect(() => {
-    graphState.backgroundType = backgroundType;
-    graphState.snapToGrid = snapToGrid;
-    graphState.showHelp = showHelp;
+    if (safePadding) {
+      state.safePadding = safePadding;
+    }
+    state.backgroundType = backgroundType;
+    state.snapToGrid = snapToGrid;
+    state.showHelp = showHelp;
  });

-  setGraphState(graphState);
+  setGraphState(state);

-  setupKeymaps(keymap, manager, graphState);
+  setupKeymaps(keymap, manager, state);

  $effect(() => {
-    if (graphState.activeNodeId !== -1) {
-      activeNode = manager.getNode(graphState.activeNodeId);
+    if (state.activeNodeId !== -1) {
+      activeNode = manager.getNode(state.activeNodeId);
    } else if (activeNode) {
      activeNode = undefined;
    }
  });

  $effect(() => {
-    if (!graphState.addMenuPosition) {
-      graphState.edgeEndPosition = null;
-      graphState.activeSocket = null;
+    if (!state.addMenuPosition) {
+      state.edgeEndPosition = null;
+      state.activeSocket = null;
    }
  });

@@ -80,11 +84,11 @@

  manager.on('save', (save) => onsave?.(save));

-  $effect(() => {
+  onMount(() => {
    if (graph) {
      manager.load(graph);
    }
  });
 </script>

-<GraphEl {keymap} {addMenuPadding} />
+<GraphEl {keymap} {safePadding} />
@@ -0,0 +1,52 @@
+<script lang="ts">
+  import { getGraphState } from '../graph-state.svelte';
+
+  const { safePadding }: {
+    safePadding?: { left?: number; right?: number; bottom?: number; top?: number };
+  } = $props();
+
+  const graphState = getGraphState();
+</script>
+
+<div class="zoom-indicator" style:right="calc({safePadding?.right ?? 0}px + 10px)">
+  <button
+    class="fit-btn"
+    title="Fit to view (.)"
+    onclick={() => graphState.centerNode()}
+    aria-label="Fit nodes to view"
+  >
+    ⊡
+  </button>
+  <span>{Math.round(graphState.cameraPosition[2] * 10)}%</span>
+</div>
+
+<style>
+  .zoom-indicator {
+    position: absolute;
+    bottom: 10px;
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    font-family: var(--font-family);
+    font-size: 0.75em;
+    color: var(--color-text);
+    opacity: 0.35;
+    z-index: 10;
+    transition: opacity 0.15s, right 0.2s;
+    pointer-events: auto;
+  }
+
+  .zoom-indicator:hover {
+    opacity: 0.9;
+  }
+
+  .fit-btn {
+    background: none;
+    border: none;
+    color: inherit;
+    cursor: pointer;
+    font-size: 1.1em;
+    line-height: 1;
+    padding: 0;
+  }
+</style>
@@ -2,7 +2,7 @@ type Color = { hue: number; saturation: number; lightness: number };

 export class ColorGenerator {
  private colors: Map<string, Color> = new Map();
-  private lightnessLevels = [10, 60];
+  // private lightnessLevels = [10, 60];

  constructor(predefined: Record<string, Color>) {
    for (const [id, colorStr] of Object.entries(predefined)) {
@@ -10,6 +10,14 @@ export class ColorGenerator {
    }
  }

+  public getColors() {
+    return Object.fromEntries(
+      this.colors.entries().map(([key, col]) => {
+        return [key, this.colorToHsl(col)];
+      })
+    );
+  }
+
  public getColor(id: string): string {
    if (this.colors.has(id)) {
      return this.colorToHsl(this.colors.get(id)!);
@@ -190,7 +190,7 @@ export class MouseEventManager {
    // if we clicked on a node
    if (clickedNodeId !== -1) {
      if (event.ctrlKey && event.shiftKey) {
-        this.state.tryConnectToDebugNode(clickedNodeId);
+        this.graph.tryConnectToDebugNode(clickedNodeId);
        return;
      }
      if (this.state.activeNodeId === -1) {
@@ -1,6 +1,16 @@
-import type { NodeDefinition, NodeInstance } from '@nodarium/types';
+import type {
+  Edge,
+  NodeDefinition,
+  NodeInstance,
+  SerializedEdge,
+  SerializedNode
+} from '@nodarium/types';

 export function getParameterHeight(node: NodeDefinition, inputKey: string) {
+  if (node.id === '__internal/group/input') {
+    return 50;
+  }
+
  const input = node.inputs?.[inputKey];
  if (!input) {
    return 0;
@@ -23,42 +33,31 @@ export function getParameterHeight(node: NodeDefinition, inputKey: string) {
  return 50;
 }

-export function getSocketPosition(
-  node: NodeInstance,
-  index: string | number
-): [number, number] {
-  if (typeof index === 'number') {
-    return [
-      (node?.state?.x ?? node.position[0]) + 20,
-      (node?.state?.y ?? node.position[1]) + 2.5 + 10 * index
-    ];
-  } else {
-    let height = 5;
-    const nodeType = node.state.type!;
-    const inputs = nodeType.inputs || {};
-    for (const inputKey in inputs) {
-      const h = getParameterHeight(nodeType, inputKey) / 10;
-      if (inputKey === index) {
-        height += h / 2;
-        break;
+export function serializeNode(node: SerializedNode | NodeInstance): SerializedNode {
+  return {
+    id: node.id,
+    position: [...node.position],
+    type: node.type,
+    props: node.props
+  };
 }
-      height += h;
-    }
-    return [
-      node?.state?.x ?? node.position[0],
-      (node?.state?.y ?? node.position[1]) + height
-    ];
+
+export function serializeEdge(edge: SerializedEdge | Edge): SerializedEdge {
+  if (typeof edge[0] === 'number' && typeof edge[2] === 'number') {
+    return [edge[0], edge[1], edge[2], edge[3]];
  }
+  const e = edge as Edge;
+  return [e[0].id, e[1], e[2].id, e[3]];
 }

 const nodeHeightCache: Record<string, number> = {};
 export function getNodeHeight(node: NodeDefinition) {
+  if (!node || !('inputs' in node)) {
+    return 5;
+  }
  if (node.id in nodeHeightCache) {
    return nodeHeightCache[node.id];
  }
-  if (!node?.inputs) {
-    return 5;
-  }
  let height = 5;

  for (const key in node.inputs) {
@@ -69,3 +68,34 @@ export function getNodeHeight(node: NodeDefinition) {
  nodeHeightCache[node.id] = height;
  return height;
 }
+
+export function areSocketsCompatible(
+  output: string | undefined,
+  inputs: string | (string | undefined)[] | undefined
+) {
+  if (output === '*') return true;
+  if (Array.isArray(inputs) && output) {
+    return inputs.includes('*') || inputs.includes(output);
+  }
+  return inputs === output;
+}
+
+export function areEdgesEqual(firstEdge: Edge, secondEdge: Edge) {
+  if (firstEdge[0].id !== secondEdge[0].id) {
+    return false;
+  }
+
+  if (firstEdge[1] !== secondEdge[1]) {
+    return false;
+  }
+
+  if (firstEdge[2].id !== secondEdge[2].id) {
+    return false;
+  }
+
+  if (firstEdge[3] !== secondEdge[3]) {
+    return false;
+  }
+
+  return true;
+}
@@ -1,6 +1,6 @@
-import { animate, lerp } from '$lib/helpers';
 import type { createKeyMap } from '$lib/helpers/createKeyMap';
 import { panelState } from '$lib/sidebar/PanelState.svelte';
+import { toast } from '@nodarium/ui';
 import FileSaver from 'file-saver';
 import type { GraphManager } from './graph-manager.svelte';
 import type { GraphState } from './graph-state.svelte';
@@ -48,6 +48,10 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
    key: 'Escape',
    description: 'Deselect nodes',
    callback: () => {
+      if (graph.isInsideGroup) {
+        graphState.exitGroupNode();
+        return;
+      }
      graphState.activeNodeId = -1;
      graphState.clearSelection();
      graphState.edgeEndPosition = null;
@@ -55,6 +59,29 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
    }
  });

+  keymap.addShortcut({
+    key: 'g',
+    ctrl: true,
+    preventDefault: true,
+    description: 'Group selected nodes',
+    callback: () => graphState.groupSelectedNodes()
+  });
+
+  keymap.addShortcut({
+    key: 'g',
+    alt: true,
+    preventDefault: true,
+    description: 'Ungroup selected nodes',
+    callback: () => graphState.unGroupSelectedNodes()
+  });
+
+  keymap.addShortcut({
+    key: 'Tab',
+    preventDefault: true,
+    description: 'Enter selected node group',
+    callback: () => graphState.enterGroupNode()
+  });
+
  keymap.addShortcut({
    key: 'A',
    shift: true,
@@ -67,27 +94,7 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
    description: 'Center camera',
    callback: () => {
      if (!graphState.isBodyFocused()) return;
-
-      const average = [0, 0];
-      for (const node of graph.nodes.values()) {
-        average[0] += node.position[0];
-        average[1] += node.position[1];
-      }
-      average[0] = average[0] ? average[0] / graph.nodes.size : 0;
-      average[1] = average[1] ? average[1] / graph.nodes.size : 0;
-
-      const camX = graphState.cameraPosition[0];
-      const camY = graphState.cameraPosition[1];
-      const camZ = graphState.cameraPosition[2];
-
-      const ease = (t: number) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t);
-
-      animate(500, (a: number) => {
-        graphState.cameraPosition[0] = lerp(camX, average[0], ease(a));
-        graphState.cameraPosition[1] = lerp(camY, average[1], ease(a));
-        graphState.cameraPosition[2] = lerp(camZ, 2, ease(a));
-        if (graphState.mouseDown) return false;
-      });
+      graphState.centerNode(graph.getNode(graphState.activeNodeId));
    }
  });

@@ -140,6 +147,7 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
        type: 'application/json;charset=utf-8'
      });
      FileSaver.saveAs(blob, 'nodarium-graph.json');
+      toast('Graph downloaded', 'success', 1500);
    }
  });

@@ -3,13 +3,14 @@
  import type { NodeInstance } from '@nodarium/types';
  import { T } from '@threlte/core';
  import { type Mesh } from 'three';
-  import { getGraphState } from '../graph-state.svelte';
+  import { getGraphManager, getGraphState } from '../graph-state.svelte';
  import { colors } from '../graph/colors.svelte';
  import { getNodeHeight, getParameterHeight } from '../helpers/nodeHelpers';
  import NodeFrag from './Node.frag';
  import NodeVert from './Node.vert';
  import NodeHtml from './NodeHTML.svelte';

+  const graph = getGraphManager();
  const graphState = getGraphState();

  type Props = {
@@ -18,7 +19,7 @@
  };
  let { node = $bindable(), inView }: Props = $props();

-  const nodeType = $derived(node.state.type!);
+  const nodeType = $derived(node ? graph.getNodeType(node) : undefined);

  const isActive = $derived(graphState.activeNodeId === node.id);
  const isSelected = $derived(graphState.selectedNodes.has(node.id));
@@ -32,15 +33,17 @@
  );

  const sectionHeights = $derived(
-    Object
-      .keys(nodeType.inputs || {})
+    nodeType
+      ? Object
+        .keys(nodeType?.inputs || {})
        .map(key => getParameterHeight(nodeType, key) / 10)
        .filter(b => !!b)
+      : [5]
  );

  let meshRef: Mesh | undefined = $state();

-  const height = getNodeHeight(node.state.type!);
+  const height = $derived(nodeType ? getNodeHeight(nodeType) : 20);

  const zoom = $derived(graphState.cameraPosition[2]);

@@ -1,11 +1,12 @@
 <script lang="ts">
  import type { NodeInstance } from '@nodarium/types';
-  import { getGraphState } from '../graph-state.svelte';
+  import { getGraphManager, getGraphState } from '../graph-state.svelte';
  import NodeHeader from './NodeHeader.svelte';
  import NodeParameter from './NodeParameter.svelte';

  let ref: HTMLDivElement;

+  const graph = getGraphManager();
  const graphState = getGraphState();

  type Props = {
@@ -30,8 +31,12 @@
  const zOffset = Math.random() - 0.5;
  const zLimit = 2 - zOffset;

-  const parameters = Object.entries(node.state?.type?.inputs || {}).filter(
+  const nodeType = $derived(graph.getNodeType(node));
+
+  const parameters = $derived(
+    Object.entries(nodeType?.inputs || {}).filter(
      (p) => p[1].type !== 'seed' && !('setting' in p[1]) && p[1]?.hidden !== true
+    ) || {}
  );

  $effect(() => {
@@ -1,11 +1,11 @@
 <script lang="ts">
  import { appSettings } from '$lib/settings/app-settings.svelte';
  import type { NodeInstance, Socket } from '@nodarium/types';
-  import { getGraphState } from '../graph-state.svelte';
+  import { getGraphManager, getGraphState } from '../graph-state.svelte';
  import { createNodePath } from '../helpers/index.js';
-  import { getSocketPosition } from '../helpers/nodeHelpers';

  const graphState = getGraphState();
+  const graph = getGraphManager();

  const { node }: { node: NodeInstance } = $props();

@@ -16,13 +16,24 @@
      graphState.setDownSocket?.({
        node,
        index: 0,
-        position: getSocketPosition?.(node, 0)
+        position: graphState.getSocketPosition?.(node, 0)
      });
    }
  }

  const cornerTop = 10;
-  const rightBump = $derived(!!node?.state?.type?.outputs?.length);
+  const nodeType = $derived(graph.getNodeType(node));
+  const rightBump = $derived(
+    !!nodeType?.outputs?.length && node.type !== '__internal/group/input'
+  );
+  const cornerBottom = $derived(
+    node.type === '__internal/group/input'
+      ? (Object.keys(nodeType?.inputs ?? {}).length ? 0 : 10)
+      : node.type === '__internal/group/output'
+      ? (nodeType?.outputs?.length ? 0 : 10)
+      : 0
+  );
+
  const aspectRatio = 0.25;

  const path = $derived(
@@ -31,6 +42,7 @@
      height: 34,
      y: 49,
      cornerTop,
+      cornerBottom,
      rightBump,
      aspectRatio
    })
@@ -41,6 +53,7 @@
      height: 40,
      y: 49,
      cornerTop,
+      cornerBottom,
      rightBump,
      aspectRatio
    })
@@ -70,8 +83,9 @@
    {#if appSettings.value.debug.advancedMode}
      <span class="bg-white text-black! mr-2 px-1 rounded-sm opacity-30">{node.id}</span>
    {/if}
-    {node.type.split('/').pop()}
+    {nodeType?.meta?.title || node.type?.split('/').pop()}
  </div>
+  {#if rightBump}
    <div
      class="target"
      role="button"
@@ -79,6 +93,7 @@
      onmousedown={handleMouseDown}
    >
    </div>
+  {/if}
  <svg
    xmlns="http://www.w3.org/2000/svg"
    viewBox="0 0 100 100"
@@ -2,7 +2,7 @@
  import type { NodeInput, NodeInstance, Socket } from '@nodarium/types';
  import { getGraphManager, getGraphState } from '../graph-state.svelte';
  import { createNodePath } from '../helpers';
-  import { getParameterHeight, getSocketPosition } from '../helpers/nodeHelpers';
+  import { getParameterHeight } from '../helpers/nodeHelpers';
  import NodeInputEl from './NodeInput.svelte';

  type Props = {
@@ -19,7 +19,7 @@

  let { node = $bindable(), input, id, isLast }: Props = $props();

-  const nodeType = $derived(node.state.type!);
+  let nodeType = $derived(graph.getNodeType(node)!);

  const inputType = $derived(nodeType.inputs?.[id]);

@@ -29,14 +29,27 @@
  function handleMouseDown(ev: MouseEvent) {
    ev.preventDefault();
    ev.stopPropagation();
+
+    if (node.type === '__internal/group/input') {
+      const outputIndex = Object.entries(nodeType?.inputs ?? {}).findIndex(([key]) => key === id);
+      graphState.setDownSocket({
+        node,
+        index: outputIndex,
+        position: graphState.getSocketPosition(node, outputIndex)
+      });
+    } else {
      graphState.setDownSocket({
        node,
        index: id,
-      position: getSocketPosition(node, id)
+        position: graphState.getSocketPosition(node, id)
      });
    }
+  }

-  const leftBump = $derived(nodeType.inputs?.[id].internal !== true);
+  const leftBump = $derived(
+    nodeType.inputs?.[id].internal !== true && node.type !== '__internal/group/input'
+  );
+  const rightBump = $derived(node.type === '__internal/group/input');
  const cornerBottom = $derived(isLast ? 5 : 0);
  const aspectRatio = 0.5;

@@ -46,6 +59,7 @@
      height: 2000 / height,
      y: 50.5,
      cornerBottom,
+      rightBump,
      leftBump,
      aspectRatio
    })
@@ -55,6 +69,7 @@
      depth: 7,
      height: 2200 / height,
      y: 50.5,
+      rightBump,
      cornerBottom,
      leftBump,
      aspectRatio
@@ -76,6 +91,7 @@
 <div
  class="wrapper"
  data-node-type={node.type}
+  class:is-group-input={node.type === '__internal/group/input'}
  data-node-input={id}
  style:height="{height}px"
  style:--socket-color={hoverColor}
@@ -130,6 +146,11 @@
    transform: translateY(-50%) translateX(-50%);
  }

+  .is-group-input .target {
+    right: 0px;
+    transform: translateY(-50%) translateX(50%);
+  }
+
  .possible-socket .target::before {
    content: "";
    position: absolute;
@@ -23,7 +23,11 @@ export function createMockNodeRegistry(nodes: NodeDefinition[]): NodeRegistry {

 export const mockFloatOutputNode: NodeDefinition = {
  id: 'test/node/output',
-  inputs: {},
+  inputs: {
+    'input': {
+      type: 'float'
+    }
+  },
  outputs: ['float'],
  meta: { title: 'Float Output' },
  execute: () => new Int32Array()
@@ -32,7 +36,7 @@ export const mockFloatOutputNode: NodeDefinition = {
 export const mockFloatInputNode: NodeDefinition = {
  id: 'test/node/input',
  inputs: { value: { type: 'float' } },
-  outputs: [],
+  outputs: ['float'],
  meta: { title: 'Float Input' },
  execute: () => new Int32Array()
 };
@@ -4,7 +4,8 @@ export function grid(width: number, height: number) {
  const graph: Graph = {
    id: Math.floor(Math.random() * 100000),
    edges: [],
-    nodes: []
+    nodes: [],
+    groups: []
  };

  const amount = width * height;
@@ -6,3 +6,4 @@ export { default as lottaNodes } from './lotta-nodes.json';
 export { plant } from './plant';
 export { default as simple } from './simple.json';
 export { tree } from './tree';
+export { default as tutorial } from './tutorial.json';
@@ -3,7 +3,7 @@
  "settings": {
    "resolution.circle": 54,
    "resolution.curve": 20,
-    "randomSeed": true
+    "randomSeed": false
  },
  "meta": {
    "title": "New Project",
@@ -27,9 +27,9 @@
      ],
      "type": "max/plantarium/stem",
      "props": {
-        "amount": 50,
+        "amount": 4,
        "length": 4,
-        "thickness": 1
+        "thickness": 0.2
      }
    },
    {
@@ -47,6 +47,7 @@ export function tree(depth: number): Graph {
  return {
    id: Math.floor(Math.random() * 100000),
    nodes,
-    edges
+    edges,
+    groups: []
  };
 }
@@ -0,0 +1,24 @@
+{
+  "id": 0,
+  "settings": {
+    "resolution.circle": 54,
+    "resolution.curve": 20,
+    "randomSeed": false
+  },
+  "meta": {
+    "title": "New Project",
+    "lastModified": "2026-02-03T16:56:40.375Z"
+  },
+  "nodes": [
+    {
+      "id": 9,
+      "position": [
+        215,
+        85
+      ],
+      "type": "max/plantarium/output",
+      "props": {}
+    }
+  ],
+  "edges": []
+}
@@ -1,8 +1,12 @@
 export const debugNode = {
-  id: 'max/plantarium/debug',
+  id: '__internal/node/debug',
+  meta: {
+    title: 'Debug'
+  },
  inputs: {
    input: {
-      type: '*'
+      type: '*',
+      label: ''
    }
  },
  execute(_data: Int32Array): Int32Array {
@@ -0,0 +1,14 @@
+export const groupNode = {
+  id: '__internal/group/instance',
+  meta: { title: 'Group' },
+  inputs: {
+    groupId: {
+      label: '',
+      type: 'select',
+      values: []
+    }
+  },
+  execute(_data: Int32Array): Int32Array {
+    return _data;
+  }
+} as const;
@@ -2,7 +2,6 @@ import {
  type AsyncCache,
  type NodeDefinition,
  NodeDefinitionSchema,
-  type NodeId,
  type NodeRegistry
 } from '@nodarium/types';
 import { createLogger, createWasmWrapper } from '@nodarium/utils';
@@ -13,7 +12,6 @@ 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,
@@ -90,6 +88,7 @@ export class RemoteNodeRegistry implements NodeRegistry {
  }

  async fetchNodeDefinition(nodeId: `${string}/${string}/${string}`) {
+    if (nodeId.startsWith('__internal/')) return;
    return this.fetchJson(`nodes/${nodeId}.json`);
  }

@@ -111,6 +110,8 @@ export class RemoteNodeRegistry implements NodeRegistry {
          return this.nodes.get(id)!;
        }

+        if (id.startsWith('__internal/')) return;
+
        const wasmBuffer = await this.fetchNodeWasm(id);

        try {
@@ -172,13 +173,6 @@ export class RemoteNodeRegistry implements NodeRegistry {
  }

  getAllNodes() {
-    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);
+    return [...this.nodes.values()];
  }
 }
@@ -1,7 +1,7 @@
 <script lang="ts">
  import { defaultPlant, lottaFaces, plant, simple } from '$lib/graph-templates';
  import type { Graph } from '$lib/types';
-  import { InputSelect } from '@nodarium/ui';
+  import { Button, ConfirmDialog, InputSelect, Spinner } from '@nodarium/ui';
  import type { ProjectManager } from './project-manager.svelte';

  const { projectManager } = $props<{ projectManager: ProjectManager }>();
@@ -31,16 +31,27 @@
    newProjectName = '';
    showNewProject = false;
  }
+
+  let pendingDeleteId = $state<number | null>(null);
+  let confirmOpen = $state(false);
+
+  function requestDelete(id: number, e: MouseEvent) {
+    e.stopPropagation();
+    pendingDeleteId = id;
+    confirmOpen = true;
+  }
+
+  function confirmDelete() {
+    if (pendingDeleteId !== null) {
+      projectManager.handleDeleteProject(pendingDeleteId);
+      pendingDeleteId = null;
+    }
+  }
 </script>

 <header class="flex justify-between px-4 h-[70px] border-b-1 border-outline items-center bg-layer-2">
  <h3>Project</h3>
-  <button
-    class="px-3 py-1 bg-layer-1 rounded"
-    onclick={() => (showNewProject = !showNewProject)}
-  >
-    New
-  </button>
+  <Button onclick={() => (showNewProject = !showNewProject)}>New</Button>
 </header>

 {#if showNewProject}
@@ -53,20 +64,11 @@
      onkeydown={(e) => e.key === 'Enter' && handleCreate()}
    />
    <InputSelect options={templates.map(t => t.name)} bind:value={selectedTemplateIndex} />
-    <button
-      class="cursor-pointer self-end px-3 py-1 bg-selected rounded"
-      onclick={() => handleCreate()}
-    >
-      Create
-    </button>
+    <Button variant="primary" class="self-end" onclick={() => handleCreate()}>Create</Button>
  </div>
 {/if}

 <div class="text-white min-h-screen">
-  {#if projectManager.loading}
-    <p>Loading...</p>
-  {/if}
-
  <ul>
    {#each projectManager.projects as project (project.id)}
      <li>
@@ -89,16 +91,35 @@
          <div class="flex justify-between items-center grow">
            <span>{project.meta?.title || 'Untitled'}</span>
            <button
-              class="text-layer-1! bg-red-500 w-7 text-xl rounded-sm cursor-pointer opacity-20 hover:opacity-80"
-              onclick={() => {
-                projectManager.handleDeleteProject(project.id!);
-              }}
+              class="opacity-20 hover:opacity-70 transition-opacity cursor-pointer p-1 rounded text-red-400"
+              onclick={(e) => requestDelete(project.id!, e)}
+              aria-label="Delete project"
            >
-              ×
+              <span class="i-[tabler--trash] w-4 h-4 block"></span>
            </button>
          </div>
        </div>
      </li>
+    {:else}
+      {#if projectManager.loading}
+        <div class="flex items-center gap-2 p-4">
+          <Spinner size={12} />
+          <p>Loading</p>
+        </div>
+      {:else}
+        <li class="px-4 py-8 text-center opacity-40 text-sm">
+          No projects yet.<br />Press <b>New</b> to create one.
+        </li>
+      {/if}
    {/each}
  </ul>
 </div>
+
+<ConfirmDialog
+  bind:open={confirmOpen}
+  title="Delete project?"
+  message="This cannot be undone. The project and all its data will be permanently removed."
+  confirmLabel="Delete"
+  cancelLabel="Cancel"
+  onconfirm={confirmDelete}
+/>
@@ -10,7 +10,9 @@ export class ProjectManager {
    'node.activeProjectId',
    undefined
  );
-  public readonly loading = $derived(this.graph?.id !== this.activeProjectId.value);
+  public readonly loading = $derived(
+    this.projects.length && this.graph?.id !== this.activeProjectId.value
+  );

  constructor() {
    this.init();
@@ -24,6 +24,10 @@
  let geometryPool: ReturnType<typeof createGeometryPool>;
  let instancePool: ReturnType<typeof createInstancedGeometryPool>;

+  export function invalidate() {
+    sceneComponent?.invalidate();
+  }
+
  export function updateGeometries(inputs: Int32Array[], group: Group) {
    geometryPool = geometryPool || createGeometryPool(group, material);
    instancePool = instancePool || createInstancedGeometryPool(group, material);
@@ -80,7 +80,6 @@ export function createGeometryPool(parentScene: Group, material: Material) {
    }

    const normals = new Float32Array(data.buffer, index * 4, vertexCount * 3);
-    index = index + vertexCount * 3;

    if (
      geometry.userData?.faceCount !== faceCount
@@ -1,39 +0,0 @@
-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);
-}
@@ -0,0 +1,164 @@
+import type { Graph } from '@nodarium/types';
+import { describe, expect, it } from 'vitest';
+import { expandGroups } from './runtime-executor';
+
+// Helpers to build minimal serialized nodes/edges
+function node(id: number, type: string, props?: Record<string, number>) {
+  return {
+    id,
+    type: type as Graph['nodes'][0]['type'],
+    position: [0, 0] as [number, number],
+    ...(props ? { props } : {})
+  };
+}
+
+function edge(
+  from: number,
+  fromSocket: number,
+  to: number,
+  toSocket: string
+): [number, number, number, string] {
+  return [from, fromSocket, to, toSocket];
+}
+
+describe('expandGroups', () => {
+  it('returns graph unchanged when there are no groups', () => {
+    const graph: Graph = {
+      id: 1,
+      nodes: [node(0, 'test/node/output'), node(1, 'test/node/input')],
+      edges: [edge(0, 0, 1, 'value')],
+      groups: []
+    };
+
+    const result = expandGroups(graph);
+
+    expect(result.nodes.length).toBe(2);
+    expect(result.edges.length).toBe(1);
+    expect(result).toBe(graph); // same reference — no copy needed
+  });
+
+  it('expands a simple group: A → [B] → C rewires to A → B → C', () => {
+    // IDs: A=1, B=2, C=3, groupNode=4, group.id=5, inputBoundary=6, outputBoundary=7
+    const groupId = 5;
+    const groupNodeId = 4;
+    const remappedB = (groupNodeId + 1) * 1_000_000 + 2; // 5_000_002
+
+    const graph: Graph = {
+      id: 1,
+      nodes: [
+        node(1, 'test/node/output'),
+        node(groupNodeId, '__internal/group/instance', { groupId }),
+        node(3, 'test/node/input')
+      ],
+      edges: [
+        edge(1, 0, groupNodeId, 'input_0'), // A → group
+        edge(groupNodeId, 0, 3, 'value') // group → C
+      ],
+      groups: [{
+        id: groupId,
+        nodes: [
+          node(6, '__internal/group/input'),
+          node(2, 'test/node/output'),
+          node(7, '__internal/group/output')
+        ],
+        edges: [
+          edge(6, 0, 2, 'input'), // inputBoundary → B
+          edge(2, 0, 7, 'Out') // B → outputBoundary
+        ],
+        inputs: { input_0: { type: 'float' } },
+        outputs: [{ type: 'float', label: 'Output 0' }]
+      }]
+    };
+
+    const result = expandGroups(graph);
+
+    const ids = result.nodes.map(n => n.id);
+    expect(ids).not.toContain(groupNodeId);
+    expect(ids).toContain(remappedB);
+    expect(ids).toContain(1); // A
+    expect(ids).toContain(3); // C
+    expect(result.nodes.length).toBe(3); // A, B(remapped), C
+
+    expect(result.edges).toContainEqual(edge(1, 0, remappedB, 'input')); // A → B
+    expect(result.edges).toContainEqual(edge(remappedB, 0, 3, 'value')); // B → C
+    expect(result.edges.length).toBe(2);
+  });
+
+  it('expands a group with two internal nodes (B→D) and preserves the internal edge', () => {
+    // A → [B → D] → C
+    const groupId = 10;
+    const groupNodeId = 5;
+    const remappedB = (groupNodeId + 1) * 1_000_000 + 1; // 6_000_001
+    const remappedD = (groupNodeId + 1) * 1_000_000 + 2; // 6_000_002
+
+    const graph: Graph = {
+      id: 1,
+      nodes: [
+        node(0, 'test/node/output'),
+        node(groupNodeId, '__internal/group/instance', { groupId }),
+        node(9, 'test/node/input')
+      ],
+      edges: [
+        edge(0, 0, groupNodeId, 'input_0'),
+        edge(groupNodeId, 0, 9, 'value')
+      ],
+      groups: [{
+        id: groupId,
+        nodes: [
+          node(3, '__internal/group/input'),
+          node(1, 'test/node/output'), // B
+          node(2, 'test/node/output'), // D
+          node(4, '__internal/group/output')
+        ],
+        edges: [
+          edge(3, 0, 1, 'input'), // inputBoundary → B
+          edge(1, 0, 2, 'input'), // B → D (internal)
+          edge(2, 0, 4, 'Out') // D → outputBoundary
+        ],
+        inputs: { input_0: { type: 'float' } },
+        outputs: [{ type: 'float' }]
+      }]
+    };
+
+    const result = expandGroups(graph);
+
+    expect(result.nodes.map(n => n.id)).not.toContain(groupNodeId);
+    expect(result.nodes.map(n => n.id)).toContain(remappedB);
+    expect(result.nodes.map(n => n.id)).toContain(remappedD);
+
+    expect(result.edges).toContainEqual(edge(0, 0, remappedB, 'input')); // A → B
+    expect(result.edges).toContainEqual(edge(remappedB, 0, remappedD, 'input')); // B → D (internal)
+    expect(result.edges).toContainEqual(edge(remappedD, 0, 9, 'value')); // D → C
+    expect(result.edges.length).toBe(3);
+  });
+
+  it('expands a group with no external connections (isolated)', () => {
+    const groupId = 20;
+    const groupNodeId = 1;
+    const remappedB = (groupNodeId + 1) * 1_000_000 + 2; // 2_000_002
+
+    const graph: Graph = {
+      id: 1,
+      nodes: [node(groupNodeId, '__internal/group/instance', { groupId })],
+      edges: [],
+      groups: [{
+        id: groupId,
+        nodes: [
+          node(3, '__internal/group/input'),
+          node(2, 'test/node/output'),
+          node(4, '__internal/group/output')
+        ],
+        edges: [
+          edge(3, 0, 2, 'input'),
+          edge(2, 0, 4, 'Out')
+        ]
+      }]
+    };
+
+    const result = expandGroups(graph);
+
+    expect(result.nodes.map(n => n.id)).not.toContain(groupNodeId);
+    expect(result.nodes.map(n => n.id)).toContain(remappedB);
+    expect(result.edges.length).toBe(0);
+  });
+});
@@ -1,5 +1,3 @@
-import type { SettingsToStore } from '$lib/settings/app-settings.svelte';
-import { RemoteNodeRegistry } from '@nodarium/registry';
 import type {
  Graph,
  NodeDefinition,
@@ -9,38 +7,131 @@ 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(); // Keep logging enabled for debug info
+log.mute();

-const remoteRegistry = new RemoteNodeRegistry('');
+export function expandGroups(graph: Graph): Graph {
+  if (!graph.groups || graph.groups.length === 0) return graph;

-type WasmExecute = (outputPos: number, args: number[]) => number;
+  function groupContainsSelf(groupId: number, visited = new Set<number>()): boolean {
+    if (visited.has(groupId)) return true;
+    visited.add(groupId);
+    const group = graph.groups!.find(g => g.id === groupId);
+    if (!group) return false;
+    for (const n of group.nodes) {
+      if (n.type === '__internal/group/instance') {
+        const nestedId = n.props?.groupId as number | undefined;
+        if (nestedId !== undefined && groupContainsSelf(nestedId, visited)) return true;
+      }
+    }
+    return false;
+  }

-function getValue(input: NodeInput, value?: unknown): number | number[] | Int32Array {
+  for (const group of graph.groups) {
+    if (groupContainsSelf(group.id)) {
+      throw new Error(`Circular group reference: group ${group.id} contains itself`);
+    }
+  }
+
+  const nodes = [...graph.nodes];
+  let edges = [...graph.edges];
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.type !== '__internal/group/instance') continue;
+
+      const groupId = node.props?.groupId as number | undefined;
+      if (groupId === undefined) continue;
+
+      const group = graph.groups.find(g => g.id === groupId);
+      if (!group) continue;
+
+      changed = true;
+
+      const ID_OFFSET = (node.id + 1) * 1_000_000;
+      const idMap = new Map<number, number>();
+
+      const inputBoundary = group.nodes.find(n => n.type === '__internal/group/input');
+      const outputBoundary = group.nodes.find(n => n.type === '__internal/group/output');
+
+      const realNodes = group.nodes.filter(
+        n => n.type !== '__internal/group/input' && n.type !== '__internal/group/output'
+      );
+
+      for (const n of realNodes) idMap.set(n.id, ID_OFFSET + n.id);
+
+      const incomingExternal = edges.filter(e => e[2] === node.id);
+      const outgoingExternal = edges.filter(e => e[0] === node.id);
+      const newEdges: Graph['edges'] = [];
+
+      // external_source → [inputBoundary →] internal_target
+      //
+      // External socket names are "input_N" where N equals the input boundary's
+      // output index. Match each external edge only to the internal edges that
+      // originate from that specific output slot — not a cartesian product of all.
+      if (inputBoundary) {
+        const fromInput = group.edges.filter(e => e[0] === inputBoundary.id);
+        for (const extEdge of incomingExternal) {
+          const inputIndex = parseInt((extEdge[3] as string).replace('input_', ''), 10);
+          const matchingIntEdges = fromInput.filter(e => e[1] === inputIndex);
+          for (const intEdge of matchingIntEdges) {
+            const toId = idMap.get(intEdge[2]);
+            if (toId !== undefined) newEdges.push([extEdge[0], extEdge[1], toId, intEdge[3]]);
+          }
+        }
+      }
+
+      // internal_source → [outputBoundary →] external_target
+      if (outputBoundary) {
+        const toOutput = group.edges.filter(e => e[2] === outputBoundary.id);
+        for (const extEdge of outgoingExternal) {
+          for (const intEdge of toOutput) {
+            const fromId = idMap.get(intEdge[0]);
+            if (fromId !== undefined) newEdges.push([fromId, intEdge[1], extEdge[2], extEdge[3]]);
+          }
+        }
+      }
+
+      // internal-to-internal edges (skip boundary edges)
+      for (const e of group.edges) {
+        if (e[0] === inputBoundary?.id || e[2] === outputBoundary?.id) continue;
+        const fromId = idMap.get(e[0]);
+        const toId = idMap.get(e[2]);
+        if (fromId !== undefined && toId !== undefined) newEdges.push([fromId, e[1], toId, e[3]]);
+      }
+
+      nodes.splice(i, 1);
+      for (const n of realNodes) nodes.push({ ...n, id: idMap.get(n.id)! });
+
+      edges = edges.filter(e => e[0] !== node.id && e[2] !== node.id);
+      edges.push(...newEdges);
+
+      break;
+    }
+  }
+
+  return { ...graph, nodes, edges };
+}
+
+function getValue(input: NodeInput, value?: unknown) {
  if (value === undefined && 'value' in input) {
    value = input.value;
  }

-  switch (input.type) {
-    case 'float':
+  if (input.type === '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)) {
@@ -56,26 +147,23 @@ function getValue(input: NodeInput, value?: unknown): number | number[] | Int32A
    return [0, value.length + 1, ...value, 1, 1] as number[];
  }

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

-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;
+  if (typeof value === 'number') {
+    return value;
  }

-export type Pointer = {
-  start: number;
-  end: number;
-  _title?: string;
-};
+  if (value instanceof Int32Array) {
+    return value;
+  }
+
+  throw new Error(`Unknown input type ${input.type}`);
+}
+
+export class MemoryRuntimeExecutor implements RuntimeExecutor {
+  private definitionMap: Map<string, NodeDefinition> = new Map();

  private seed = Math.floor(Math.random() * 100000000);
  private debugData: Record<number, { type: string; data: Int32Array }> = {};
@@ -83,55 +171,38 @@ export type Pointer = {
  perf?: PerformanceStore;

  constructor(
-    private readonly registry: NodeRegistry,
+    private 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(n => n.type));
-    log.info(`Loaded ${graph.nodes.length} node types from registry`);
+    // Only load non-virtual types (virtual nodes are resolved locally)
+    const nonVirtualTypes = graph.nodes
+      .map(node => node.type)
+      .filter(t => !t.startsWith('__internal/'));
+    await this.registry.load(nonVirtualTypes);

-    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`);
+    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);
        }
-
-    return this.map;
+      }
+    }
+    return typeMap;
  }

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

    const graphNodes = graph.nodes.map(node => {
      const n = node as RuntimeNode;
@@ -144,30 +215,36 @@ export type Pointer = {
      return n;
    });

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

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

    // 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) continue;
-
+      if (parent && child) {
        parent.state.children.push(child);
        child.state.parents.push(parent);
        child.state.inputNodes[childInput] = parent;
      }
+    }

    const nodes = new Map<number, RuntimeNode>();

    // 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()!;
+      const node = stack.pop();
+      if (!node) continue;
      for (const parent of node.state.parents) {
+        parent.state = parent.state || {};
        parent.state.depth = node.state.depth + 1;
        stack.push(parent);
      }
@@ -191,21 +268,20 @@ export type Pointer = {
    return [outputNode, _nodes] as const;
  }

-  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;
-    }
+  async execute(graph: Graph, settings: Record<string, unknown>) {
+    this.perf?.addPoint('runtime');

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

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

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

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

-    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}`)])
-    );
+    if (settings['randomSeed']) {
+      this.seed = Math.floor(Math.random() * 100000000);
+    }

    for (const node of sortedNodes) {
-      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();
+      const node_type = this.definitionMap.get(node.type)!;

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

-      this.inputPtrs[node.id] = inputs;
-      const args = inputs.map(s => [s.start, s.end]).flat();
-      console.log('ARGS', inputs);
+      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}#${inputNode.id}`
+              );
+            }
+            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.printMemory();
      try {
        a = performance.now();
        const encoded_inputs = concatEncodedArrays(inputs);
@@ -332,138 +391,28 @@ export type Pointer = {
        b = performance.now();

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

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

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

-    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);
+    if (this.cache) {
+      this.cache.size = sortedNodes.length * 2;
    }

-      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');
-    }
+
+    return res as unknown as Int32Array;
  }

  getDebugData() {
@@ -1,7 +1,7 @@
 <script lang="ts">
  import { localState } from '$lib/helpers/localState.svelte';
  import type { NodeInput } from '@nodarium/types';
-  import Input from '@nodarium/ui';
+  import Input, { Button as UiButton } from '@nodarium/ui';
  import { onMount } from 'svelte';
  import NestedSettings from './NestedSettings.svelte';

@@ -28,13 +28,14 @@
    key?: string;
    value: SettingsValue;
    type: SettingsType;
+    onButtonClick?: (id: string) => void;
    depth?: number;
  };

  // Local persistent state for <details> sections
  const openSections = localState<Record<string, boolean>>('open-details', {});

-  let { id, key = '', value = $bindable(), type, depth = 0 }: Props = $props();
+  let { id, key = '', value = $bindable(), type, onButtonClick, depth = 0 }: Props = $props();

  function isNodeInput(v: SettingsNode | undefined): v is InputType {
    return !!v && typeof v === 'object' && 'type' in v;
@@ -107,11 +108,6 @@
    }
  });

-  function handleClick() {
-    const callback = value[key] as unknown as () => void;
-    callback();
-  }
-
  onMount(() => {
    open = openSections.value[id];

@@ -130,9 +126,9 @@
  {@const inputType = type[key]}
  <div class="input input-{inputType.type}" class:first-level={depth === 1}>
    {#if inputType.type === 'button'}
-      <button onclick={handleClick}>
+      <UiButton onclick={() => onButtonClick?.(id)}>
        {inputType.label || key}
-      </button>
+      </UiButton>
    {:else}
      {#if inputType.label !== ''}
        <label for={id}>{inputType.label || key}</label>
@@ -143,6 +139,7 @@
 {:else if depth === 0}
  {#each Object.keys(type ?? {}).filter((k) => k !== 'title') as childKey (childKey)}
    <NestedSettings
+      {onButtonClick}
      id={`${id}.${childKey}`}
      key={childKey}
      bind:value
@@ -160,6 +157,7 @@
    <div class="content">
      {#each Object.keys(type[key] as SettingsGroup).filter((k) => k !== 'title') as childKey (childKey)}
        <NestedSettings
+          {onButtonClick}
          id={`${id}.${childKey}`}
          key={childKey}
          bind:value={value[key] as SettingsValue}
@@ -206,6 +204,13 @@

  .input-boolean > label {
    order: 2;
+    font-size: 1em;
+    opacity: 0.9;
+  }
+
+  label {
+    font-size: 0.8em;
+    opacity: 0.7;
  }

  .first-level.input {
@@ -219,10 +224,6 @@
    gap: 10px;
  }

-  button {
-    cursor: pointer;
-  }
-
  hr {
    margin: 0;
    left: 0;
@@ -28,6 +28,10 @@ export const AppSettingTypes = {
    label: 'Center Camera',
    value: true
  },
+  clippy: {
+    type: 'button',
+    label: '🌱 Open Planty'
+  },
  nodeInterface: {
    title: 'Node Interface',
    backgroundType: {
@@ -109,8 +113,7 @@ export const AppSettingTypes = {
  }
 } as const;

-type SettingsToStore<T> = T extends { type: 'button' } ? () => void
-  : T extends { value: infer V } ? V extends readonly string[] ? V[number]
+type SettingsToStore<T> = T extends { value: infer V } ? V extends readonly string[] ? V[number]
  : V
  : T extends object ? {
      -readonly [K in keyof T as T[K] extends object ? K : never]: SettingsToStore<T[K]>;
@@ -2,6 +2,7 @@
  import { type Snippet } from 'svelte';
  import { panelState as state } from './PanelState.svelte';

+  // eslint-disable-next-line no-useless-assignment
  let { children, open = $bindable(false) } = $props<{ children?: Snippet; open?: boolean }>();

  $effect(() => {
@@ -1,101 +0,0 @@
-<script lang="ts">
-  import type { GraphManager } from '$lib/graph-interface/graph-manager.svelte';
-  import NestedSettings from '$lib/settings/NestedSettings.svelte';
-  import type { NodeId, NodeInput, NodeInstance } from '@nodarium/types';
-
-  type InternalNodeInput = NodeInput & {
-    __node_type?: NodeId;
-    __node_input: string;
-  };
-
-  type Props = {
-    manager: GraphManager;
-    node: NodeInstance;
-  };
-
-  const { manager, node = $bindable() }: Props = $props();
-
-  function filterInputs(inputs?: Record<string, NodeInput>) {
-    const _inputs = $state.snapshot(
-      inputs as Record<string, InternalNodeInput>
-    );
-    return Object.fromEntries(
-      Object.entries(structuredClone(_inputs ?? {}))
-        .filter(([, value]) => {
-          return value.hidden === true;
-        })
-        .map(([key, value]) => {
-          value.__node_type = node.state.type?.id;
-          value.__node_input = key;
-          return [key, value];
-        })
-    );
-  }
-  const nodeDefinition = filterInputs(node.state.type?.inputs);
-
-  type Store = Record<string, number | number[]>;
-  let store = $state<Store>(createStore(node?.props, nodeDefinition));
-  function createStore(
-    props: NodeInstance['props'],
-    inputs: Record<string, NodeInput>
-  ): Store {
-    const store: Store = {};
-    Object.keys(inputs).forEach((key) => {
-      if (props) {
-        const value = props[key] !== undefined ? props[key] : inputs[key].value;
-        if (Array.isArray(value) || typeof value === 'number') {
-          store[key] = value;
-        } else if (typeof value === 'boolean') {
-          store[key] = value ? 1 : 0;
-        } else {
-          console.error('Wrong error', { value });
-        }
-      }
-    });
-    return store;
-  }
-
-  let lastPropsHash = '';
-  function updateNode() {
-    if (!node || !store) return;
-    let needsUpdate = false;
-    Object.keys(store).forEach((_key: string) => {
-      node.props = node.props || {};
-      const key = _key as keyof typeof store;
-      if (node && store) {
-        needsUpdate = true;
-        const value = store[key];
-        if (value !== undefined) {
-          node.props[key] = value;
-        }
-      }
-    });
-
-    let propsHash = JSON.stringify(node.props);
-    if (propsHash === lastPropsHash) {
-      return;
-    }
-    lastPropsHash = propsHash;
-
-    if (needsUpdate) {
-      manager.save();
-      manager.execute();
-    }
-  }
-
-  $effect(() => {
-    if (store) {
-      updateNode();
-    }
-  });
-</script>
-
-{#if Object.keys(nodeDefinition).length}
-  <NestedSettings
-    id="activeNodeSettings"
-    bind:value={store}
-    type={nodeDefinition}
-  />
-{:else}
-  <p class="mx-4 mt-4">Node has no settings</p>
-{/if}
@@ -1,26 +1,103 @@
 <script lang="ts">
  import type { GraphManager } from '$lib/graph-interface/graph-manager.svelte';
-  import type { NodeInstance } from '@nodarium/types';
-  import ActiveNodeSelected from './ActiveNodeSelected.svelte';
+  import NestedSettings from '$lib/settings/NestedSettings.svelte';
+  import type { NodeId, NodeInput, NodeInstance } from '@nodarium/types';
+
+  type InternalNodeInput = NodeInput & {
+    __node_type?: NodeId;
+    __node_input: string;
+  };

  type Props = {
    manager: GraphManager;
    node: NodeInstance | undefined;
  };

-  let { manager, node = $bindable() }: Props = $props();
+  const { manager, node = $bindable() }: Props = $props();
+
+  function filterInputs(inputs?: Record<string, NodeInput>) {
+    if (!node) return {};
+    return Object.fromEntries(
+      Object.entries(inputs ?? {})
+        .filter(([, value]) => {
+          return value.hidden === true;
+        })
+        .map(([key, value]) => {
+          const v = value as InternalNodeInput;
+          v.__node_type = node.state.type?.id;
+          v.__node_input = key;
+          return [key, v];
+        })
+    );
+  }
+  const nodeDefinition = node ? filterInputs(node.state.type?.inputs) : {};
+
+  type Store = Record<string, number | number[]>;
+  let store = $state<Store>(createStore(node?.props, nodeDefinition));
+  function createStore(
+    props: NodeInstance['props'],
+    inputs: Record<string, NodeInput>
+  ): Store {
+    const store: Store = {};
+    Object.keys(inputs).forEach((key) => {
+      if (props) {
+        const value = props[key] !== undefined ? props[key] : inputs[key].value;
+        if (Array.isArray(value) || typeof value === 'number') {
+          store[key] = value;
+        } else if (typeof value === 'boolean') {
+          store[key] = value ? 1 : 0;
+        } else {
+          console.error('Wrong error', { value });
+        }
+      }
+    });
+    return store;
+  }
+
+  let lastPropsHash = '';
+  function updateNode() {
+    if (!node || !store) return;
+    let needsUpdate = false;
+    Object.keys(store).forEach((_key: string) => {
+      node.props = node.props || {};
+      const key = _key as keyof typeof store;
+      if (node && store) {
+        needsUpdate = true;
+        const value = store[key];
+        if (value !== undefined) {
+          node.props[key] = value;
+        }
+      }
+    });
+
+    let propsHash = JSON.stringify(node.props);
+    if (propsHash === lastPropsHash) {
+      return;
+    }
+    lastPropsHash = propsHash;
+
+    if (needsUpdate) {
+      manager.save();
+      manager.execute();
+    }
+  }
+
+  const isGroupInstance = $derived(node?.type === '__internal/group/instance');
+
+  $effect(() => {
+    if (store) {
+      updateNode();
+    }
+  });
 </script>

+{#if !isGroupInstance && Object.keys(nodeDefinition).length}
  <div class='{node?"border-l-2 pl-3.5!":""} bg-layer-2 flex items-center h-[70px] border-b-1 border-l-selected border-b-outline pl-4'>
    <h3>Node Settings</h3>
  </div>
-
-{#if node}
-  {#key node.id}
-    {#if node}
-      <ActiveNodeSelected {manager} bind:node />
-    {/if}
-  {/key}
-{:else}
-  <p class="mx-4 mt-4">No node selected</p>
+  <NestedSettings
+    id="activeNodeSettings"
+    bind:value={store}
+    type={nodeDefinition}
+  />
 {/if}
@@ -8,7 +8,7 @@
  import { humanizeDuration } from '$lib/helpers';
  import { localState } from '$lib/helpers/localState.svelte';
  import Monitor from '$lib/performance/Monitor.svelte';
-  import { InputNumber } from '@nodarium/ui';
+  import { Button, InputNumber } from '@nodarium/ui';
  import { writable } from 'svelte/store';

  function calculateStandardDeviation(array: number[]) {
@@ -112,7 +112,7 @@
      onclick={() => copyContent(result?.stdev + '')}
    >(click to copy)</i>
    <div>
-      <button onclick={() => (isRunning = false)}>reset</button>
+      <Button onclick={() => (isRunning = false)}>reset</Button>
    </div>
  {:else if isRunning}
    <p>WarmUp ({$warmUp}/{warmUpAmount})</p>
@@ -126,7 +126,7 @@
  {:else}
    <label for="bench-samples">Samples</label>
    <InputNumber id="bench-sample" bind:value={amount.value} max={1000} step={1} />
-    <button onclick={benchmark} disabled={isRunning}>start</button>
+    <Button variant="primary" onclick={benchmark} disabled={isRunning}>start</Button>
  {/if}
 </div>

@@ -1,4 +1,5 @@
 <script lang="ts">
+  import { Button, toast } from '@nodarium/ui';
  import FileSaver from 'file-saver';
  import type { Group } from 'three';
  import type { GLTFExporter } from 'three/addons/exporters/GLTFExporter.js';
@@ -28,11 +29,12 @@
    exporter.parse(
      scene,
      (gltf) => {
-        // download .gltf file
        download(gltf as ArrayBuffer, 'plant', 'text/plain', 'gltf');
+        toast('Exported as GLTF', 'success');
      },
      (err) => {
-        console.log(err);
+        const msg = err instanceof Error ? err.message : String(err);
+        toast(`GLTF export failed: ${msg}`, 'error');
      }
    );
  }
@@ -45,13 +47,18 @@
        objExporter = new m.OBJExporter();
        return objExporter;
      }));
+    try {
      const result = exporter.parse(scene);
-    // download .obj file
      download(result, 'plant', 'text/plain', 'obj');
+      toast('Exported as OBJ', 'success');
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      toast(`OBJ export failed: ${msg}`, 'error');
+    }
  }
 </script>

-<div class="p-4">
-  <button onclick={exportObj}>export obj</button>
-  <button onclick={exportGltf}>export gltf</button>
+<div class="p-4 flex gap-2">
+  <Button onclick={exportObj}>export obj</Button>
+  <Button onclick={exportGltf}>export gltf</Button>
 </div>
@@ -1,20 +1,23 @@
 <script lang="ts">
  import type { Graph } from '$lib/types';
+  import { JsonViewer } from '@nodarium/ui';

  const { graph }: { graph?: Graph } = $props();

-  function convert(g: Graph): string {
-    return JSON.stringify(
-      {
-        ...g,
-        nodes: g.nodes.map((n: object) => ({ ...n, tmp: undefined, state: undefined }))
-      },
-      null,
-      2
-    );
+  const data = $derived(
+    graph
+      ? {
+        ...graph,
+        nodes: graph.nodes.map((n: object) => ({ ...n, state: undefined }))
      }
+      : null
+  );
 </script>

-<pre>
-  {graph ? convert(graph) : "No graph loaded"}
-</pre>
+<div class="overflow-auto p-2">
+  {#if data}
+    <JsonViewer value={data} path="graph" />
+  {:else}
+    <span class="font-mono text-xs text-neutral-500">No graph loaded</span>
+  {/if}
+</div>
@@ -0,0 +1,156 @@
+<script lang="ts">
+  import type { GraphManager } from '$lib/graph-interface/graph-manager.svelte';
+  import { GraphState } from '$lib/graph-interface/graph-state.svelte';
+  import type { NodeInstance } from '@nodarium/types';
+  import { SocketTable } from '@nodarium/ui';
+  import UnusedGroupsPanel from './UnusedGroupsPanel.svelte';
+
+  type Props = {
+    manager: GraphManager;
+    graphState: GraphState;
+    node?: NodeInstance;
+  };
+
+  const { manager, graphState, node = $bindable() }: Props = $props();
+
+  const activeGroup = $derived.by(() => {
+    if (node?.type === '__internal/group/instance') {
+      let group = manager.getGroup(node.props?.groupId as number);
+      if (group) return group;
+    }
+
+    if (manager?.isInsideGroup && manager.currentGroupId !== null) {
+      return manager.getGroup(manager.currentGroupId);
+    }
+  });
+
+  const groupName = $derived(activeGroup?.name ?? '');
+  function handleRename(e: Event) {
+    const name = (e.target as HTMLInputElement).value;
+    if (activeGroup) manager.renameGroup(activeGroup.id, name);
+  }
+
+  function handleRemoveInput(key: string) {
+    if (!activeGroup) return;
+    const group = manager.getGroup(activeGroup?.id);
+    const inputs = $state.snapshot(group?.inputs ?? {});
+    delete inputs[key];
+    activeGroup.inputs = inputs;
+    manager.nodes = manager.nodes;
+    manager.save();
+  }
+
+  const types = $derived(
+    Array.from(
+      new Set(
+        manager?.registry
+          ? manager.registry.getAllNodes()
+            .flatMap(n =>
+              Object.values(n.inputs ?? {})
+                .map(v => v.type)
+            )
+          : []
+      )
+    )
+  );
+
+  let outputType = $derived(activeGroup?.outputs?.[0]?.type ?? 'unknown');
+
+  $effect(() => {
+    if (!activeGroup) return;
+    const group = manager.getGroup(activeGroup?.id);
+    const outputs = $state.snapshot(group?.outputs ?? []);
+    if (outputs?.[0]?.type === outputType) return;
+    activeGroup.outputs = [
+      {
+        label: outputs[0]?.label ?? 'Output',
+        type: outputType
+      }
+    ];
+    manager.nodes = manager.nodes;
+    manager.save();
+  });
+</script>
+
+{#if activeGroup}
+  <div class='{node?"border-l-2 pl-3.5!":""} bg-layer-2 flex items-center h-[70px] border-b-1 border-l-selected border-b-outline pl-4'>
+    <h3>Group Settings</h3>
+  </div>
+{/if}
+
+{#if activeGroup}
+  {#key activeGroup.id}
+    <div class="p-4 group-settings">
+      <label for="group-name">Group name</label>
+      <input
+        id="group-name"
+        type="text"
+        placeholder="Group {activeGroup.id}"
+        value={groupName}
+        oninput={handleRename}
+      />
+
+      <label for="group-name">Group Inputs</label>
+      <div>
+        <SocketTable
+          {types}
+          onremove={handleRemoveInput}
+          bind:inputs={activeGroup.inputs}
+          colors={graphState?.colors?.getColors()}
+        />
+      </div>
+
+      <label for="group-name mb-2">Group output</label>
+      <div class="flex bg-layer-2 rounded-sm outline outline-outline w-min">
+        <span
+          style:background={graphState?.colors?.getColor(outputType)}
+          class="block opacity-50 min-w-2 ml-2 w-2 h-2 my-auto rounded-sm"
+        ></span>
+        <select
+          class="text-[0.9em] shrink-0 px-2 py-1 border-outline"
+          bind:value={outputType}
+        >
+          {#each types as type (type)}
+            <option>
+              <span
+                style="background: {graphState?.colors?.getColor(type)}; width: 5px; height: 5px; border-radius: 5px;"
+              ></span>
+              {type}
+            </option>
+          {/each}
+        </select>
+      </div>
+    </div>
+  {/key}
+{/if}
+
+{#if manager && !manager.isInsideGroup}
+  <UnusedGroupsPanel {manager} />
+{/if}
+
+<style>
+  .group-settings {
+    display: flex;
+    flex-direction: column;
+    gap: 0.4em;
+  }
+
+  label {
+    font-size: 0.8em;
+    opacity: 0.7;
+  }
+
+  .group-settings input {
+    background: var(--color-layer-1);
+    border: 1px solid var(--color-outline);
+    border-radius: 4px;
+    color: var(--color-text);
+    font-family: var(--font-family);
+    font-size: 0.9em;
+    padding: 0.4em 0.6em;
+  }
+
+  .group-settings input:focus {
+    outline: 1px solid var(--color-active);
+  }
+</style>
@@ -0,0 +1,122 @@
+<script lang="ts">
+  import type { GraphManager } from '$lib/graph-interface/graph-manager.svelte';
+  import type { GroupDefinition } from '@nodarium/types';
+  import { Button } from '@nodarium/ui';
+  import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+
+  type Props = { manager: GraphManager };
+  const { manager }: Props = $props();
+
+  type GroupNode = { group: GroupDefinition; children: GroupNode[] };
+
+  const unusedTree = $derived.by((): GroupNode[] => {
+    const unused = manager.getUnusedGroups();
+    if (!unused.length) return [];
+
+    const unusedIds = new Set(unused.map(g => g.id));
+
+    // Build child map: which unused groups reference which other unused groups
+    const childrenOf = new SvelteMap<number, number[]>();
+    const referencedBy = new SvelteSet<number>();
+
+    for (const group of unused) {
+      const refs: number[] = [];
+      for (const node of group.nodes) {
+        if (node.type === '__internal/group/instance' && node.props?.groupId !== undefined) {
+          const childId = node.props.groupId as number;
+          if (unusedIds.has(childId)) {
+            refs.push(childId);
+            referencedBy.add(childId);
+          }
+        }
+      }
+      childrenOf.set(group.id, refs);
+    }
+
+    const byId = new Map(unused.map(g => [g.id, g]));
+
+    function buildNode(g: GroupDefinition): GroupNode {
+      return {
+        group: g,
+        children: (childrenOf.get(g.id) ?? []).map(id => buildNode(byId.get(id)!))
+      };
+    }
+
+    return unused
+      .filter(g => !referencedBy.has(g.id))
+      .map(buildNode);
+  });
+</script>
+
+{#if unusedTree.length}
+  <div class="panel p-4">
+    <div class="header">
+      <span>Unused groups</span>
+      <Button size="sm" variant="destructive" onclick={() => manager.removeUnusedGroups()}>
+        Remove all
+      </Button>
+    </div>
+
+    <ul class="tree">
+      {#snippet treeNode(node: GroupNode)}
+        <li>
+          <span class="group-name">{node.group.name || `Group #${node.group.id}`}</span>
+          {#if node.children.length}
+            <ul>
+              {#each node.children as child (child.group.id)}
+                {@render treeNode(child)}
+              {/each}
+            </ul>
+          {/if}
+        </li>
+      {/snippet}
+      {#each unusedTree as node (node.group.id)}
+        {@render treeNode(node)}
+      {/each}
+    </ul>
+  </div>
+{/if}
+
+<style>
+  .panel {
+    border-top: 1px solid var(--color-outline);
+    margin-top: -1px;
+    border-bottom: 1px solid var(--color-outline);
+  }
+
+  .header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 0.5em;
+    font-size: 0.8em;
+    opacity: 0.7;
+  }
+
+
+  .tree {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+
+  .tree ul {
+    list-style: none;
+    margin: 0;
+    padding-left: 1.2em;
+    border-left: 1px solid var(--color-outline);
+  }
+
+  .tree li {
+    padding: 0.15em 0;
+  }
+
+  .group-name {
+    font-size: 0.85em;
+  }
+
+  .tree ul .group-name::before {
+    content: '└ ';
+    opacity: 0.4;
+  }
+</style>
@@ -0,0 +1,240 @@
+import type { PlantyConfig } from '@nodarium/planty';
+
+export const tutorialConfig: PlantyConfig = {
+  id: 'nodarium-tutorial',
+  avatar: {
+    name: 'Planty',
+    defaultPosition: 'bottom-right'
+  },
+  start: 'intro',
+  nodes: {
+    // ── Entry ──────────────────────────────────────────────────────────────
+    intro: {
+      position: 'center',
+      text:
+        "# Hi, I'm Planty! 🌱\nI'll show you around Nodarium — a tool for building 3D plants by connecting nodes together.\nHow much detail do you want?",
+      choices: [
+        { label: '🌱 Show me the basics', next: 'tour_canvas' },
+        { label: '🤓 I want the technical details', next: 'tour_canvas_nerd' },
+        { label: 'Skip the tour for now', next: null }
+      ]
+    },
+
+    // ── Simple path ────────────────────────────────────────────────────────
+
+    tour_canvas: {
+      position: 'bottom-left',
+      action: 'setup-default',
+      highlight: { selector: '.graph-wrapper', padding: 12 },
+      text:
+        'This is the **graph canvas**. Nodes connect together to build a plant — the 3D model updates automatically whenever you make a change.\nEach node does one specific job: grow stems, add noise, produce output.',
+      next: 'tour_viewer'
+    },
+
+    tour_viewer: {
+      position: 'top-left',
+      highlight: { selector: '.cell:first-child', padding: 8 },
+      text:
+        'This is the **3D viewer** — the live preview of your plant.\nLeft-click to rotate · right-click to pan · scroll to zoom.',
+      next: 'try_params'
+    },
+
+    try_params: {
+      position: 'bottom-right',
+      highlight: { selector: '.graph-wrapper', padding: 12 },
+      text:
+        'Click a node to select it. Its settings appear **directly on the node** — try changing a value and watch the plant update.\nThe sidebar shows extra hidden settings for the selected node.',
+      next: 'start_building'
+    },
+
+    start_building: {
+      position: 'center',
+      action: 'load-tutorial-template',
+      text:
+        "Now let's build your own plant from scratch!\nI've loaded a blank project — it only has an **Output** node. Your goal: connect nodes to make a plant.",
+      next: 'add_stem_node'
+    },
+
+    add_stem_node: {
+      position: 'bottom-right',
+      highlight: { selector: '.graph-wrapper', padding: 12 },
+      text:
+        "Open the **Add Menu** with **Shift+A** or **right-click** on the canvas.\nAdd a **Stem** node, then connect its output socket to the Output node's input.",
+      next: 'add_noise_node'
+    },
+
+    add_noise_node: {
+      position: 'bottom-right',
+      highlight: { selector: '.graph-wrapper', padding: 12 },
+      text:
+        'Add a **Noise** node the same way.\nConnect: Stem → Noise input, then Noise output → Output.\nThis makes the stems grow in organic, curved shapes.',
+      next: 'add_random_node'
+    },
+
+    add_random_node: {
+      position: 'bottom-right',
+      highlight: { selector: '.graph-wrapper', padding: 12 },
+      text:
+        "Let's add some randomness! Add a **Random** node and connect its output to the **thickness** or **length** input of the Stem node.\nThe default min/max range is small — **Ctrl+drag** any number field to exceed its normal limits.",
+      next: 'prompt_regenerate'
+    },
+
+    prompt_regenerate: {
+      position: 'bottom-right',
+      highlight: { selector: '.graph-wrapper', padding: 12 },
+      text:
+        'Now press **R** to regenerate. Each press gives the Random node a new value — your plant changes every run!',
+      next: 'tour_sidebar'
+    },
+
+    tour_sidebar: {
+      position: 'right',
+      highlight: { selector: '.tabs', padding: 4 },
+      text:
+        'The **sidebar** holds all your tools:\n⚙️ Settings · ⌨️ Shortcuts · 📦 Export · 📁 Projects · 📊 Graph Settings\nEnable **Advanced Mode** in Settings to unlock performance and benchmark panels.',
+      next: 'save_project'
+    },
+
+    save_project: {
+      position: 'right',
+      text:
+        'Your work is saved in the **Projects panel** — rename it, create new projects, or switch between them anytime.',
+      next: 'congrats'
+    },
+
+    congrats: {
+      position: 'center',
+      text:
+        "# You're all set! 🎉\nYou know how to build plants, tweak parameters, and save your work.\nWant to explore more?",
+      choices: [
+        { label: '🔗 How do node connections work?', next: 'connections_intro' },
+        { label: '💡 Ideas for improving this plant', next: 'improvements_hint' },
+        { label: '⌨️ Keyboard shortcuts', next: 'shortcuts_tour' },
+        { label: "I'm ready to build!", next: null }
+      ]
+    },
+
+    // ── Technical / nerd path ──────────────────────────────────────────────
+
+    tour_canvas_nerd: {
+      position: 'bottom-left',
+      action: 'setup-default',
+      highlight: { selector: '.graph-wrapper', padding: 12 },
+      text:
+        "The **graph canvas** renders a directed acyclic graph. Each node is an individual **WASM module** executed in isolation — inputs in, output out. The 3D model updates automatically on every change.\nI've loaded a starter graph so you can see it in action.",
+      choices: [
+        {
+          label: '🔍 Explore Node Sourcecode',
+          action: 'open-github-nodes'
+        }
+      ],
+      next: 'tour_viewer_nerd'
+    },
+
+    tour_viewer_nerd: {
+      position: 'top-left',
+      highlight: { selector: '.cell:first-child', padding: 8 },
+      text:
+        'The **3D viewer** uses `@threlte/core` (Svelte + Three.js). Mesh data streams from WASM execution results. OrbitControls: left-drag rotate, right-drag pan, scroll zoom.',
+      next: 'tour_runtime_nerd'
+    },
+
+    tour_runtime_nerd: {
+      position: 'bottom-right',
+      text:
+        'By default, nodes execute in a **WebWorker** for better performance. You can switch to main-thread execution by disabling **Debug → Execute in WebWorker** in Settings.\nEnable **Advanced Mode** to unlock the Performance and Benchmark panels.',
+      next: 'start_building'
+    },
+
+    // ── Deep dives (shared between paths) ─────────────────────────────────
+
+    connections_intro: {
+      position: 'bottom-right',
+      text:
+        'Node sockets are **type-checked**. The coloured dots tell you what kind of data flows through:\n🔵 `number` · 🟢 `vec3` · 🟣 `shape` · ⚪ `*` (wildcard)',
+      next: 'connections_rules'
+    },
+
+    connections_rules: {
+      position: 'right',
+      text:
+        'Drag from an output socket to an input socket to connect them.\n• Types must match (or use `*`)\n• No circular loops\n• Optional inputs can stay empty\nInvalid connections snap back automatically.',
+      choices: [
+        { label: '🔧 Node parameters', next: 'params_intro' },
+        { label: '🐛 Debug node', next: 'debug_intro' },
+        { label: 'Start building!', next: null }
+      ]
+    },
+
+    params_intro: {
+      position: 'bottom-right',
+      highlight: { selector: '.graph-wrapper', padding: 12 },
+      text:
+        'Click any node to select it. Basic settings are shown **on the node itself**.\nThe sidebar under *Graph Settings → Active Node* shows the full list:\n**Number** — drag or type · **Vec3** — X/Y/Z · **Select** — dropdown · **Color** — picker',
+      next: 'params_tip'
+    },
+
+    params_tip: {
+      position: 'right',
+      text:
+        'Pro tips:\n• Parameters can be connected from other nodes — drag an edge to the input socket\n• The **Random Seed** in Graph Settings gives you the same result every run\n• **f** key smart-connects two selected nodes · **Ctrl+Delete** removes a node and restores its edges',
+      choices: [
+        { label: '🔗 How connections work', next: 'connections_intro' },
+        { label: '💡 Plant improvement ideas', next: 'improvements_hint' },
+        { label: 'Start building!', next: null }
+      ]
+    },
+
+    debug_intro: {
+      position: 'bottom-right',
+      text:
+        'Add a **Debug node** from the Add Menu (Shift+A or right-click). It accepts `*` wildcard inputs — connect any socket to inspect the data flowing through.\nEnable **Advanced Mode** in Settings to also see Performance and Graph Source panels.',
+      next: 'debug_done'
+    },
+
+    debug_done: {
+      position: 'center',
+      text: 'The Debug node is your best friend when building complex graphs.\nAnything else?',
+      choices: [
+        { label: '🔗 Connection types', next: 'connections_intro' },
+        { label: '🔧 Node parameters', next: 'params_intro' },
+        { label: 'Start building!', next: null }
+      ]
+    },
+
+    shortcuts_tour: {
+      position: 'bottom-right',
+      text:
+        '**Essential shortcuts:**\n`R` — Regenerate\n`Shift+A` / right-click — Add node\n`f` — Smart-connect selected nodes\n`.` — Center camera\n`Ctrl+Z` / `Ctrl+Y` — Undo / Redo\n`Delete` — Remove selected · `Ctrl+Delete` — Remove and restore edges',
+      next: 'shortcuts_done'
+    },
+
+    shortcuts_done: {
+      position: 'right',
+      text:
+        'All shortcuts are also listed in the sidebar under the ⌨️ icon.\nReady to build something?',
+      choices: [
+        { label: '🔗 Node connections', next: 'connections_intro' },
+        { label: '🔧 Parameters', next: 'params_intro' },
+        { label: "Let's build! 🌿", next: null }
+      ]
+    },
+
+    export_tour: {
+      position: 'right',
+      text:
+        'Export your 3D model from the **📦 Export** panel:\n**GLB** — standard for 3D apps (Blender, Three.js)\n**OBJ** — legacy format · **STL** — 3D printing · **PNG** — screenshot',
+      next: 'congrats'
+    },
+
+    improvements_hint: {
+      position: 'center',
+      text:
+        '# Ideas to grow your plant 🌿\n• Add a **Vec3** node → connect to *origin* on the Stem to spread stems across 3D space\n• Use a **Random** node on a parameter so each run produces a unique shape\n• Chain **multiple Stem nodes** with different settings for complex branching\n• Add a **Gravity** or **Branch** node for even more organic results',
+      choices: [
+        { label: '⌨️ Keyboard shortcuts', next: 'shortcuts_tour' },
+        { label: "Let's build! 🌿", next: null }
+      ]
+    }
+  }
+};
@@ -4,7 +4,8 @@
  import Grid from '$lib/grid';
  import { debounceAsyncFunction } from '$lib/helpers';
  import { createKeyMap } from '$lib/helpers/createKeyMap';
-  import { debugNode } from '$lib/node-registry/debugNode.js';
+  import { debugNode } from '$lib/node-registry/debugNode';
+  import { groupNode } from '$lib/node-registry/groupNode.js';
  import { IndexDBCache, RemoteNodeRegistry } from '$lib/node-registry/index';
  import NodeStore from '$lib/node-store/NodeStore.svelte';
  import PerformanceViewer from '$lib/performance/PerformanceViewer.svelte';
@@ -21,20 +22,25 @@
  import Changelog from '$lib/sidebar/panels/Changelog.svelte';
  import ExportSettings from '$lib/sidebar/panels/ExportSettings.svelte';
  import GraphSource from '$lib/sidebar/panels/GraphSource.svelte';
+  import GroupSettings from '$lib/sidebar/panels/GroupSettings.svelte';
  import Keymap from '$lib/sidebar/panels/Keymap.svelte';
+  import { panelState } from '$lib/sidebar/PanelState.svelte';
  import Sidebar from '$lib/sidebar/Sidebar.svelte';
+  import { tutorialConfig } from '$lib/tutorial/tutorial-config';
+  import { Planty } from '@nodarium/planty';
  import type { Graph, NodeInstance } from '@nodarium/types';
+  import { Spinner, Toast, toast } from '@nodarium/ui';
  import { createPerformanceStore } from '@nodarium/utils';
-  import { onMount } from 'svelte';
  import type { Group } from 'three';

  let performanceStore = createPerformanceStore();
+  let planty = $state<ReturnType<typeof Planty>>();

  const { data } = $props();

  const registryCache = new IndexDBCache('node-registry');

-  const nodeRegistry = new RemoteNodeRegistry('', registryCache, [debugNode]);
+  const nodeRegistry = new RemoteNodeRegistry('', registryCache, [debugNode, groupNode]);
  const workerRuntime = new WorkerRuntimeExecutor();
  const runtimeCache = new MemoryRuntimeCache();
  const memoryRuntime = new MemoryRuntimeExecutor(nodeRegistry, runtimeCache);
@@ -64,6 +70,7 @@

  let activeNode = $state<NodeInstance | undefined>(undefined);
  let scene = $state<Group>(null!);
+  let isExecuting = $state(false);

  let sidebarOpen = $state(false);
  let graphInterface = $state<ReturnType<typeof GraphInterface>>(null!);
@@ -90,11 +97,22 @@
  let graphSettingTypes = $state({
    randomSeed: { type: 'boolean', value: false }
  });
+  $effect(() => {
+    if (graphSettings && graphSettingTypes && manager?.loaded) {
+      manager?.setSettings($state.snapshot(graphSettings));
+    }
+  });
+
+  let timeout: ReturnType<typeof setTimeout>;

  async function update(
    g: Graph,
    s: Record<string, unknown> = $state.snapshot(graphSettings)
  ) {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      isExecuting = true;
+    }, 100);
    performanceStore.startRun();
    try {
      let a = performance.now();
@@ -117,47 +135,131 @@
      }
      viewerComponent?.update(graphResult);
    } catch (error) {
-      console.log('errors', error);
+      const msg = error instanceof Error ? error.message : String(error);
+      toast(`Execution failed: ${msg}`, 'error');
    } finally {
+      clearTimeout(timeout);
+      isExecuting = false;
      performanceStore.stopRun();
    }
  }

  const handleUpdate = debounceAsyncFunction(update);

-  onMount(() => {
-    appSettings.value.debug.stressTest = {
-      ...appSettings.value.debug.stressTest,
-      loadGrid: () => {
+  function handleSettingsButton(id: string) {
+    switch (id) {
+      case 'general.clippy':
+        planty?.start();
+        break;
+      case 'general.debug.stressTest.loadGrid':
        manager.load(
          templates.grid(
            appSettings.value.debug.stressTest.amount,
            appSettings.value.debug.stressTest.amount
          )
        );
-      },
-      loadTree: () => {
+        break;
+      case 'general.debug.stressTest.loadTree':
        manager.load(templates.tree(appSettings.value.debug.stressTest.amount));
-      },
-      lottaFaces: () => {
+        break;
+      case 'general.debug.stressTest.lottaFaces':
        manager.load(templates.lottaFaces as unknown as Graph);
-      },
-      lottaNodes: () => {
+        break;
+      case 'general.debug.stressTest.lottaNodes':
        manager.load(templates.lottaNodes as unknown as Graph);
-      },
-      lottaNodesAndFaces: () => {
+        break;
+      case 'general.debug.stressTest.lottaNodesAndFaces':
        manager.load(templates.lottaNodesAndFaces as unknown as Graph);
+        break;
+      default:
+    }
  }
-    };
-  });
 </script>

 <svelte:document onkeydown={applicationKeymap.handleKeyboardEvent} />

+<Planty
+  bind:this={planty}
+  config={tutorialConfig}
+  actions={{
+    'setup-default': () => {
+      console.log('setup-default');
+      const ts = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+      pm.handleCreateProject(
+        structuredClone(templates.defaultPlant) as unknown as Graph,
+        `Tutorial Project (${ts})`
+      );
+    },
+    'load-tutorial-template': () => {
+      console.log('load-tutorial-template');
+      if (!pm.graph) return;
+      const g = structuredClone(templates.tutorial) as unknown as Graph;
+      g.id = pm.graph.id;
+      g.meta = { ...pm.graph.meta };
+      manager.load(g);
+      graphInterface.state.centerNode(graphInterface.manager.getAllNodes()[0]);
+    },
+    'open-github-nodes': () => {
+      console.log('open-github-nodes');
+      window.open(
+        'https://github.com/jim-fx/nodarium/tree/main/nodes/max/plantarium',
+        '__blank'
+      );
+    }
+  }}
+  hooks={{
+    'action:add_stem_node': (cb) => {
+      const unsub = manager.on('save', () => {
+        const allNodes = graphInterface.manager.getAllNodes();
+        const stemNode = allNodes.find(n => n.type === 'max/plantarium/stem');
+        if (stemNode && graphInterface.manager.edges.length) {
+          unsub();
+          (cb as () => void)();
+        }
+      });
+    },
+    'action:add_noise_node': (cb) => {
+      const unsub = manager.on('save', () => {
+        const allNodes = graphInterface.manager.getAllNodes();
+        const noiseNode = allNodes.find(n => n.type === 'max/plantarium/noise');
+        if (noiseNode && graphInterface.manager.edges.length > 1) {
+          unsub();
+          (cb as () => void)();
+        }
+      });
+    },
+    'action:add_random_node': (cb) => {
+      const unsub = manager.on('save', () => {
+        const allNodes = graphInterface.manager.getAllNodes();
+        const noiseNode = allNodes.find(n => n.type === 'max/plantarium/random');
+        if (noiseNode && graphInterface.manager.edges.length > 2) {
+          unsub();
+          (cb as () => void)();
+        }
+      });
+    },
+    'action:prompt_regenerate': (cb) => {
+      function handleKeydown(e: KeyboardEvent) {
+        if (e.key === 'r') {
+          window.removeEventListener('keydown', handleKeydown);
+          (cb as () => void)();
+        }
+      }
+      window.addEventListener('keydown', handleKeydown);
+    },
+    'before:save_project': () => panelState.setActivePanel('projects'),
+    'before:export_tour': () => panelState.setActivePanel('exports'),
+    'before:shortcuts_tour': () => panelState.setActivePanel('shortcuts'),
+    'after:save_project': () => panelState.setActivePanel('graph-settings'),
+    'before:tour_runtime_nerd': () => panelState.setActivePanel('general')
+  }}
+/>
+
 <div class="wrapper manager-{manager?.status}">
  <header></header>
  <Grid.Row>
    <Grid.Cell>
+      <div class="viewer-cell">
        <Viewer
          bind:scene
          bind:this={viewerComponent}
@@ -165,14 +267,21 @@
          debugData={debugData}
          centerCamera={appSettings.value.centerCamera}
        />
+        {#if isExecuting}
+          <div class="viewer-spinner" aria-label="Executing graph">
+            <Spinner size={28} />
+          </div>
+        {/if}
+      </div>
    </Grid.Cell>
    <Grid.Cell>
      {#if pm.graph}
+        {#key pm.graph.id}
          <GraphInterface
            graph={pm.graph}
            bind:this={graphInterface}
            registry={nodeRegistry}
-          addMenuPadding={{ right: sidebarOpen ? 330 : undefined }}
+            safePadding={{ right: sidebarOpen ? 321 : undefined }}
            backgroundType={appSettings.value.nodeInterface.backgroundType}
            snapToGrid={appSettings.value.nodeInterface.snapToGrid}
            bind:activeNode
@@ -182,11 +291,13 @@
            onsave={(g) => pm.saveGraph(g)}
            onresult={(result) => handleUpdate(result as Graph)}
          />
+        {/key}
      {/if}
      <Sidebar bind:open={sidebarOpen}>
        <Panel id="general" title="General" icon="i-[tabler--settings]">
          <NestedSettings
            id="general"
+            onButtonClick={handleSettingsButton}
            bind:value={appSettings.value}
            type={AppSettingTypes}
          />
@@ -206,6 +317,7 @@
        <Panel id="exports" title="Exporter" icon="i-[tabler--package-export]">
          <ExportSettings {scene} />
        </Panel>
+        {#if 0 > 1}
          <Panel
            id="node-store"
            title="Node Store"
@@ -213,6 +325,7 @@
          >
            <NodeStore registry={nodeRegistry} />
          </Panel>
+        {/if}
        <Panel
          id="performance"
          title="Performance"
@@ -232,7 +345,9 @@
          hidden={!appSettings.value.debug.advancedMode}
          icon="i-[tabler--code]"
        >
-          <GraphSource graph={pm.graph ?? manager?.serialize()} />
+          {#if manager?.status === 'idle'}
+            <GraphSource graph={manager.serialize()} />
+          {/if}
        </Panel>
        <Panel
          id="benchmark"
@@ -247,12 +362,16 @@
          title="Graph Settings"
          icon="i-[custom--graph] bg-blue-400"
        >
+          <span class="block h-[1px]"></span>
          <NestedSettings
            id="graph-settings"
            type={graphSettingTypes}
            bind:value={graphSettings}
          />
+          {#key activeNode}
            <ActiveNodeSettings {manager} bind:node={activeNode} />
+            <GroupSettings graphState={graphInterface?.state} {manager} bind:node={activeNode} />
+          {/key}
        </Panel>
        <Panel
          id="changelog"
@@ -266,9 +385,30 @@
  </Grid.Row>
 </div>

+<Toast />
+
 <style>
  header {
    background-color: var(--color-layer-1);
+    display: flex;
+    align-items: center;
+    padding: 0 8px;
+  }
+
+  .tutorial-btn {
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-size: 18px;
+    padding: 4px 6px;
+    border-radius: 6px;
+    opacity: 0.7;
+    transition: opacity 0.15s, background 0.15s;
+  }
+
+  .tutorial-btn:hover {
+    opacity: 1;
+    background: rgba(255, 255, 255, 0.08);
  }

  .wrapper {
@@ -279,6 +419,20 @@
    grid-template-rows: 0px 1fr;
  }

+  .viewer-cell {
+    position: relative;
+    height: 100%;
+  }
+
+  .viewer-spinner {
+    position: absolute;
+    bottom: 12px;
+    right: 12px;
+    color: var(--color-text, #cecece);
+    opacity: 0.6;
+    pointer-events: none;
+  }
+
  .wrapper :global(canvas) {
    transition: opacity 0.3s ease;
    opacity: 1;
@@ -3,6 +3,6 @@
  const { children } = $props<{ children?: Snippet }>();
 </script>

-<main class="w-screen h-screen overflow-x-hidden">
+<main class="w-screen overflow-x-hidden">
  {@render children()}
 </main>
@@ -44,9 +44,8 @@
    }
  }

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

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

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

 <Grid.Row>
  <Grid.Cell>
-    {#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}
+    <pre>
+      <code>
+        {JSON.stringify(nodeInstance?.props)}
+      </code>
+    </pre>
  </Grid.Cell>

  <Grid.Cell>
@@ -149,20 +82,6 @@
 </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"
@@ -1,74 +0,0 @@
-{
-  "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"
-    ]
-  ]
-}
@@ -1,48 +0,0 @@
-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));
-}
@@ -1,15 +0,0 @@
-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)
-);
@@ -1,6 +1,7 @@
 import { sveltekit } from '@sveltejs/kit/vite';
 import tailwindcss from '@tailwindcss/vite';
 import { playwright } from '@vitest/browser-playwright';
+import path from 'path';
 import comlink from 'vite-plugin-comlink';
 import glsl from 'vite-plugin-glsl';
 import wasm from 'vite-plugin-wasm';
@@ -19,6 +20,11 @@ export default defineConfig({
      comlink()
    ]
  },
+  resolve: {
+    alias: {
+      '@nodarium/planty': path.resolve(__dirname, '../packages/planty/src/lib/index.ts')
+    }
+  },
  ssr: {
    noExternal: ['three']
  },
@@ -4,19 +4,20 @@ 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) installed. Rust is the language we are going to develop our node in and cargo compiles our rust code into webassembly.
+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.

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

 ## Clone Template

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

 ## Setup Definition
@@ -0,0 +1,216 @@
+# Nodarium — LLM Reference
+
+## What It Is
+
+Nodarium is a **node-based visual programming editor**. Users wire together nodes on a 2D canvas; each node is a WebAssembly module that receives typed inputs and produces typed outputs. A live Three.js viewer renders the resulting 3D geometry/paths/instances.
+
+---
+
+## Repository Layout
+
+```
+/
+├── app/                        # SvelteKit web app
+│   └── src/
+│       ├── routes/+page.svelte # App entry point
+│       └── lib/
+│           ├── graph-interface/  # Canvas editor (UI + state)
+│           ├── runtime/          # WASM execution engine
+│           ├── node-registry/    # Fetch & cache node definitions
+│           ├── project-manager/  # IndexDB persistence
+│           ├── result-viewer/    # Three.js 3D output
+│           ├── sidebar/          # UI panels
+│           └── settings/         # App + graph settings
+├── packages/
+│   ├── types/    # Shared TypeScript types + Zod schemas
+│   ├── utils/    # Logging, hashing, WASM wrapping, perf
+│   ├── ui/       # Reusable Svelte UI components
+│   ├── planty/   # Tutorial system
+│   └── macros/   # Build-time macros
+└── docs/
+```
+
+---
+
+## Core Architecture
+
+```
+User Interaction
+  └── GraphInterface
+        ├── GraphState   ← UI: selection, camera, mouse, clipboard
+        └── GraphManager ← Logic: nodes, edges, history, serialization
+              ├── NodeRegistry   ← fetches WASM definitions (remote API + IndexDB cache)
+              ├── HistoryManager ← undo/redo (jsondiffpatch deltas)
+              └── emit('result') → RuntimeExecutor
+                                      └── node.execute(Int32Array) per node
+                                            └── ResultViewer (Three.js/Threlte)
+```
+
+**Event flow:**
+
+1. User edits graph → GraphManager mutates state
+2. GraphManager emits `save` → ProjectManager persists to IndexDB
+3. GraphManager emits `result` → Runtime executes graph → Viewer updates
+
+---
+
+## Critical Files
+
+| File                                                   | Role                                                                  |
+| ------------------------------------------------------ | --------------------------------------------------------------------- |
+| `app/src/routes/+page.svelte`                          | Wires all systems; creates GraphManager, runtime, registry            |
+| `app/src/lib/graph-interface/graph-manager.svelte.ts`  | Central graph logic: createNode, createEdge, serialize, load, history |
+| `app/src/lib/graph-interface/graph-state.svelte.ts`    | UI state: camera, selection, mouse, clipboard, groupSelectedNodes     |
+| `app/src/lib/graph-interface/graph/Graph.svelte`       | Canvas renderer                                                       |
+| `app/src/lib/graph-interface/node/Node.svelte`         | 3D mesh node (Three.js shader)                                        |
+| `app/src/lib/graph-interface/node/NodeHTML.svelte`     | HTML overlay: labels + parameters                                     |
+| `app/src/lib/graph-interface/node/NodeHeader.svelte`   | Node title bar                                                        |
+| `app/src/lib/graph-interface/keymaps.ts`               | Keyboard shortcuts                                                    |
+| `app/src/lib/graph-interface/helpers/nodeHelpers.ts`   | Node height calculations                                              |
+| `app/src/lib/graph-interface/graph/colors.svelte.ts`   | Socket type → color mapping                                           |
+| `app/src/lib/runtime/runtime-executor.ts`              | Executes nodes in DAG order; expandGroups()                           |
+| `app/src/lib/node-registry/index.ts`                   | RemoteNodeRegistry entry                                              |
+| `app/src/lib/node-registry/groupNode.ts`               | Built-in group node definition                                        |
+| `app/src/lib/node-registry/debugNode.ts`               | Built-in debug node                                                   |
+| `app/src/lib/sidebar/panels/ActiveNodeSettings.svelte` | Per-node settings panel                                               |
+| `packages/types/src/types.ts`                          | Graph, NodeInstance, NodeDefinition, Edge, GroupDefinition            |
+| `packages/types/src/inputs.ts`                         | NodeInput union types (float, vec3, geometry, path, …)                |
+| `packages/utils/src/wasm.ts`                           | createWasmWrapper() — wraps WASM bytes into a NodeDefinition          |
+
+---
+
+## Key Types
+
+```typescript
+// packages/types/src/types.ts
+
+type NodeId = `${string}/${string}/${string}`; // e.g. "max/plantarium/stem"
+
+type NodeInstance = {
+  id: number;
+  type: NodeId;
+  position: [number, number];
+  props?: Record<string, number | number[]>; // current parameter values
+  meta?: { title?: string; lastModified?: string };
+  state: NodeRuntimeState; // runtime-only, NOT serialized
+};
+
+type NodeRuntimeState = {
+  type?: NodeDefinition; // resolved definition
+  parents?: NodeInstance[];
+  children?: NodeInstance[];
+  x?: number;
+  y?: number; // interpolated position
+  mesh?: Mesh; // Three.js mesh reference
+  ref?: HTMLElement;
+};
+
+type NodeDefinition = {
+  id: NodeId;
+  inputs?: Record<string, NodeInput>;
+  outputs?: string[]; // output type names
+  meta?: { title?: string; description?: string };
+  execute(input: Int32Array): Int32Array; // WASM function
+};
+
+// Edge: [fromNode, outputIndex, toNode, inputSocketName]
+type Edge = [NodeInstance, number, NodeInstance, string];
+
+type Graph = {
+  nodes: NodeInstance[];
+  edges: [number, number, number, string][]; // serialized (IDs, not refs)
+  settings: Record<string, unknown>;
+  groups: GroupDefinition[];
+};
+
+type GroupDefinition = {
+  id: number;
+  nodes: NodeInstance[];
+  edges: Edge[];
+  inputs?: Record<string, NodeInput>;
+  outputs?: string[];
+};
+```
+
+### NodeInput socket types
+
+`float` | `integer` | `boolean` | `select` | `seed` | `vec3` | `geometry` | `path` | `shape` | `color` | `*` (wildcard)
+
+Each input can have: `value` (default), `label`, `hidden`, `external`, `setting` (link to graph setting), `accepts` (extra compatible types).
+
+---
+
+## Patterns & Conventions
+
+### Svelte 5 reactivity
+
+The codebase uses Svelte 5 runes throughout — `$state`, `$derived`, `$effect`. Collections use `SvelteMap<K,V>` and `SvelteSet<T>` (from `svelte/reactivity`) instead of plain Map/Set so that mutations trigger reactive updates.
+
+### Context API
+
+`GraphManager` and `GraphState` are provided via Svelte context (`setContext` / `getContext`) inside `GraphInterface`. All child components (Node, Edge, etc.) consume them via context rather than props.
+
+### Edge representation
+
+In memory, edges are `[NodeInstance, outputIndex, NodeInstance, inputSocketName]` — direct object references for fast traversal. On serialization (`Graph.edges`), they become `[nodeId, outputIndex, nodeId, inputSocketName]` (plain IDs).
+
+### Socket compatibility
+
+```typescript
+areSocketsCompatible(outputType: string, inputType: string | string[]): boolean
+// '*' wildcard matches any type; 'geometry' accepts ['geometry', 'instances']
+```
+
+### WASM execution interface
+
+Every node exposes a single function: `execute(input: Int32Array): Int32Array`.
+Data encoding (Plantarium):
+
+- `[0, stemDepth, ...x,y,z,thickness]` — path
+- `[1, vertexCount, faceCount, ...faces, ...vertices, ...normals]` — geometry
+- `[2, vertexCount, faceCount, instanceCount, stemDepth, ...]` — instances
+
+### Event emitter
+
+`GraphManager extends EventEmitter<{ save, result, settings }>`. Subscribe with `manager.on('result', cb)`. Used to decouple the editor UI from runtime execution and persistence.
+
+### History
+
+Every mutation goes through `HistoryManager`. Call `this.history.save(this.serialize())` before mutations; undo/redo replays jsondiffpatch deltas.
+
+### Internal node IDs
+
+Built-in nodes use the `__internal/` namespace: `__internal/group/instance`, `__internal/node/debug`. Virtual boundary nodes use `__virtual/`: `__virtual/group/input`, `__virtual/group/output`.
+
+---
+
+## In-Progress: Node Groups (`feat/group-node-own`)
+
+Group selected nodes with **Ctrl+G**. A `GroupDefinition` is stored in `Graph.groups[]`; a group instance node (`__internal/group/instance`) referencing it by `props.groupId` replaces the selected nodes.
+
+**Known gaps as of 2026-05-03:**
+
+| Issue                                                                                     | Location                                                           |
+| ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
+| `createGroupNode()` called but not defined                                                | `graph-state.svelte.ts:334` → missing in `graph-manager.svelte.ts` |
+| Runtime expects `group.graph.nodes/edges`; schema has flat `nodes/edges`                  | `runtime-executor.ts` vs `types.ts`                                |
+| Runtime expects `group.inputs` as array; schema defines it as `Record<string, NodeInput>` | Same mismatch                                                      |
+| `enterGroupNode()` is a stub — no group navigation                                        | `graph-state.svelte.ts`                                            |
+| `serialize()` writes parent-graph edges into group instead of group-internal edges        | `graph-manager.svelte.ts`                                          |
+
+---
+
+## Dev Commands
+
+Run from `app/`:
+
+```bash
+npm run dev          # start dev server (Vite)
+npm run build        # production build
+npm run check        # svelte-check + tsc
+npm run lint         # eslint
+npm run test         # unit (vitest) + e2e (playwright)
+npm run test:unit    # vitest only
+npm run test:e2e     # playwright only
+npm run bench        # benchmark runner
+```
@@ -0,0 +1,645 @@
+# Comprehensive UX Practices for Web Applications
+
+## Introduction
+
+This document consolidates many of the most important practical UX principles for modern web applications.
+
+---
+
+# 1. Core UX Principles
+
+## 1.1 Visibility of System Status
+
+Users should always understand:
+
+- What the system is doing
+- Whether an action succeeded
+- Whether work is still in progress
+- Whether an error occurred
+
+### Good Practices
+
+- Show loading indicators immediately
+- Show success confirmations after important actions
+- Show inline validation messages
+- Display progress for long-running tasks
+- Use skeleton loading states instead of blank screens
+- Prevent silent failures
+- Avoid ambiguous UI states
+
+### Bad Practices
+
+- Buttons with no feedback after clicking
+- Infinite spinners without explanation
+- Hidden background operations
+- Saving without visible confirmation
+
+---
+
+## 1.2 Predictability and Consistency
+
+Users build mental models quickly.
+
+Breaking established expectations increases cognitive load and causes mistakes.
+
+### Good Practices
+
+- Use consistent layouts
+- Keep interaction patterns stable
+- Reuse common UI conventions
+- Keep naming and terminology consistent
+- Use standard keyboard shortcuts
+- Make similar components behave similarly
+
+### Bad Practices
+
+- Different button styles for identical actions
+- Inconsistent navigation behavior
+- Custom controls that ignore platform conventions
+- Unexpected modal behavior
+
+---
+
+## 1.3 Recognition Over Recall
+
+Interfaces should minimize memory requirements.
+
+Users should recognize options instead of remembering information.
+
+### Good Practices
+
+- Show recent searches
+- Use autocomplete
+- Display contextual hints
+- Preserve previously entered values
+- Use visible labels
+- Keep important actions visible
+
+### Bad Practices
+
+- Placeholder-only labels
+- Hidden functionality
+- Requiring users to remember previous state
+- Removing useful context during workflows
+
+---
+
+## 1.4 Error Prevention
+
+Preventing mistakes is better than handling mistakes.
+
+### Good Practices
+
+- Disable impossible actions
+- Validate input early
+- Warn before destructive operations
+- Use constrained input formats
+- Use safe defaults
+- Prefer undo over confirmation dialogs
+
+### Bad Practices
+
+- Destructive actions near common actions
+- Easy accidental deletion
+- Poor validation timing
+- Irreversible operations without recovery
+
+---
+
+# 2. Input and Form UX
+
+Forms are one of the most important and failure-prone areas in web applications.
+
+---
+
+## 2.1 Input Focus Behavior
+
+### Good Practices
+
+- Autofocus the primary field when appropriate
+- Preserve focus during rerenders
+- Preserve cursor position
+- Support keyboard-first workflows
+- Use logical tab ordering
+
+### Auto-Selecting Input Text
+
+Auto-selecting text on focus is context-dependent.
+
+### Good Use Cases
+
+- Quantity fields
+- Rename dialogs
+- Editable defaults
+- Quick replacement workflows
+- Temporary values users often replace entirely
+
+### Bad Use Cases
+
+- Long textareas
+- Complex text editing
+- Fields users commonly partially edit
+- Rich text editing
+
+### Principle
+
+Only auto-select when full replacement is more likely than partial editing.
+
+---
+
+## 2.2 Labels and Placeholders
+
+### Good Practices
+
+- Always use visible labels
+- Use placeholders only as supplementary examples
+- Keep labels visible after typing
+- Associate labels correctly for accessibility
+
+### Bad Practices
+
+- Placeholder-only forms
+- Ambiguous labels
+- Labels that disappear during editing
+
+---
+
+## 2.3 Validation
+
+### Recommended Validation Timing
+
+| Validation Type     | Timing    |
+| ------------------- | --------- |
+| Format validation   | Immediate |
+| Semantic validation | On blur   |
+| Server validation   | On submit |
+
+### Good Practices
+
+- Show errors near the relevant field
+- Explain how to fix issues
+- Preserve entered values after errors
+- Validate incrementally
+- Use clear language
+
+### Bad Practices
+
+- Generic “Invalid input” messages
+- Clearing form data after errors
+- Delayed validation surprises
+- Validation that interrupts typing
+
+---
+
+## 2.4 Input Types
+
+### Good Practices
+
+Use appropriate HTML input types:
+
+- `email`
+- `tel`
+- `number`
+- `date`
+- `password`
+- `search`
+
+### Benefits
+
+- Better mobile keyboards
+- Native validation
+- Improved accessibility
+- Better autofill support
+
+---
+
+## 2.5 Form Submission
+
+### Good Practices
+
+- Enter submits forms when expected
+- Escape cancels dialogs
+- Show loading states during submission
+- Prevent duplicate submissions
+- Preserve draft state
+- Allow keyboard submission
+
+### Bad Practices
+
+- Disabled submit buttons without explanation
+- Hidden validation failures
+- Silent submission failures
+
+---
+
+## 2.6 Dropdowns and Selection UX
+
+### Good Practices
+
+- Use radio buttons for small option sets
+- Use searchable selects for large datasets
+- Prefer autocomplete for many options
+- Show selected state clearly
+
+### Bad Practices
+
+- Massive unsearchable dropdowns
+- Nested dropdown hierarchies
+- Multi-select controls without search
+
+---
+
+# 3. Navigation UX
+
+---
+
+## 3.1 Orientation
+
+Users should always know:
+
+- Where they are
+- How they got there
+- What they can do next
+- How to go back
+
+### Good Practices
+
+- Highlight active navigation
+- Use breadcrumbs when helpful
+- Use meaningful page titles
+- Preserve navigation consistency
+
+---
+
+## 3.2 Navigation Structure
+
+### Good Practices
+
+- Keep hierarchy shallow
+- Group related actions
+- Use descriptive names
+- Keep primary actions stable
+
+### Bad Practices
+
+- Deep nesting
+- Ambiguous navigation labels
+- Constantly moving actions
+
+---
+
+## 3.3 URL Design
+
+### Good Practices
+
+- Use readable URLs
+- Make URLs shareable
+- Preserve app state in URLs when useful
+- Support browser history correctly
+
+### Bad Practices
+
+- Opaque generated URLs
+- Broken back button behavior
+- Losing state during navigation
+
+---
+
+# 4. Interaction Design
+
+---
+
+## 4.1 Click Targets
+
+### Good Practices
+
+- Large clickable areas
+- Adequate spacing between actions
+- Clear hover/focus states
+- Touch-friendly sizing
+
+### Bad Practices
+
+- Tiny clickable regions
+- Overlapping interactive elements
+- Hidden hit areas
+
+---
+
+## 4.2 Feedback
+
+Every interaction should produce feedback.
+
+### Good Practices
+
+- Hover states
+- Active states
+- Loading indicators
+- Success states
+- Error states
+- Optimistic updates when appropriate
+
+### Bad Practices
+
+- Dead-feeling interfaces
+- Invisible processing
+- Delayed reactions
+
+---
+
+## 4.3 Destructive Actions
+
+### Good Practices
+
+- Require confirmation for dangerous actions
+- Prefer undo systems
+- Visually distinguish destructive buttons
+- Separate destructive actions spatially
+
+### Bad Practices
+
+- Immediate irreversible deletion
+- Dangerous actions near common actions
+- Ambiguous destructive wording
+
+---
+
+## 4.4 Modal UX
+
+### Good Practices
+
+- Trap keyboard focus
+- Support Escape to close
+- Restore focus after closing
+- Prevent background interaction
+- Keep modal purpose focused
+
+### Bad Practices
+
+- Nested modals
+- Full workflows inside modals
+- Losing unsaved work accidentally
+
+---
+
+# 5. Performance UX
+
+Performance is a UX feature.
+
+Users interpret slowness as unreliability.
+
+---
+
+## 5.1 Perceived Performance
+
+### Good Practices
+
+- Show immediate visual response
+- Use optimistic UI updates
+- Preload likely next content
+- Stream content progressively
+- Use skeleton loaders
+
+### Bad Practices
+
+- Blank screens during loading
+- Long blocking operations
+- Frozen interfaces
+
+---
+
+## 5.2 Layout Stability
+
+### Good Practices
+
+- Prevent layout shift
+- Reserve image dimensions
+- Avoid moving buttons during loading
+- Keep skeletons aligned with final layout
+
+### Bad Practices
+
+- Jumping content
+- Shifting controls
+- Reflow-heavy rendering
+
+---
+
+## 5.3 Responsiveness
+
+### Good Practices
+
+- Keep UI interactive during async operations
+- Avoid blocking the main thread
+- Debounce expensive operations
+- Virtualize large lists
+
+### Bad Practices
+
+- UI freezes
+- Excessive rerenders
+- Laggy typing experiences
+
+---
+
+# 6. Accessibility
+
+Accessibility improves usability for everyone.
+
+---
+
+## 6.1 Keyboard Accessibility
+
+### Good Practices
+
+- Full keyboard navigation
+- Visible focus indicators
+- Logical tab order
+- Keyboard shortcuts for power users
+
+### Bad Practices
+
+- Mouse-only workflows
+- Hidden focus state
+- Keyboard traps
+
+---
+
+## 6.2 Semantic HTML
+
+### Good Practices
+
+- Use proper semantic elements
+- Use buttons for actions
+- Use links for navigation
+- Use headings correctly
+
+### Bad Practices
+
+- Clickable divs without accessibility support
+- Fake buttons
+- Missing semantic structure
+
+---
+
+## 6.3 Visual Accessibility
+
+### Good Practices
+
+- Sufficient color contrast
+- Support reduced motion
+- Avoid color-only communication
+- Use scalable typography
+
+### Bad Practices
+
+- Tiny text
+- Low contrast interfaces
+- Flashing animations
+
+---
+
+## 6.4 Screen Reader Support
+
+### Good Practices
+
+- Proper labels
+- Meaningful alt text
+- ARIA only when necessary
+- Correct live regions for updates
+
+### Bad Practices
+
+- Unlabeled controls
+- Excessive ARIA misuse
+- Non-announced state changes
+
+---
+
+# 7. Enterprise Application UX
+
+Enterprise UX differs significantly from marketing-oriented consumer interfaces.
+
+Power users often prioritize efficiency over visual minimalism.
+
+---
+
+## 7.1 Dense Information Design
+
+### Good Practices
+
+- Efficient data density
+- Resizable tables
+- Sticky headers
+- Multi-column layouts
+- High information throughput
+
+### Bad Practices
+
+- Excessive whitespace
+- Oversimplified dashboards
+- Hidden operational controls
+
+---
+
+## 7.2 Table UX
+
+### Good Practices
+
+- Sorting
+- Filtering
+- Column resizing
+- Pagination or virtualization
+- Keyboard navigation
+- Export functionality
+- Persistent user preferences
+
+### Bad Practices
+
+- Non-sortable enterprise tables
+- Horizontal scrolling nightmares
+- Missing filtering
+
+---
+
+## 7.3 Power User Workflows
+
+### Good Practices
+
+- Keyboard shortcuts
+- Bulk actions
+- Batch editing
+- Command palettes
+- State persistence
+- Fast navigation
+
+### Bad Practices
+
+- Forced wizard workflows
+- Excessive confirmations
+- Repetitive manual work
+
+---
+
+# 8. Mobile UX
+
+---
+
+## 8.1 Touch Design
+
+### Good Practices
+
+- Large touch targets
+- Thumb-friendly layouts
+- Avoid hover dependencies
+- Mobile-friendly spacing
+
+### Bad Practices
+
+- Tiny controls
+- Hover-only interactions
+- Precision-dependent gestures
+
+---
+
+## 8.2 Mobile Forms
+
+### Good Practices
+
+- Mobile keyboard optimization
+- Minimal typing
+- Autofill support
+- Step-by-step flows when necessary
+
+### Bad Practices
+
+- Long complex forms
+- Tiny input fields
+- Excessive required typing
+
+---
+
+# 9. Cognitive Psychology and UX
+
+---
+
+## 9.1 Hick’s Law
+
+More choices increase decision time.
+
+### Applications
+
+- Reduce unnecessary options
+- Group related actions
+- Prioritize primary actions
+
+---
+
+## 9.2 Fitts’s Law
+
+Closer and larger targets are easier to use.
+
+### Applications
+
+- Large primary buttons
+- Edge/corner placement for important actions
@@ -1,18 +1,20 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
 use nodarium_utils::{
-    encode_float, evaluate_float, geometry::calculate_normals, wrap_arg,
-    read_i32_slice
+    encode_float, evaluate_float, geometry::calculate_normals,log,
+    split_args, wrap_arg,
 };

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

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

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

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

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

    let res = wrap_arg(&cube_geometry);

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

 }
@@ -1,6 +1,5 @@
 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::{
@@ -14,25 +13,15 @@ use std::f32::consts::PI;
 nodarium_definition_file!("src/input.json");

 #[nodarium_execute]
-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());
+pub fn execute(input: &[i32]) -> Vec<i32> {
+    let args = split_args(input);
+
+    let paths = split_args(args[0]);

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

-    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 resolution = evaluate_int(args[8]).max(4) as usize;
+    let depth = evaluate_int(args[6]);

    let mut max_depth = 0;
    for path_data in paths.iter() {
@@ -51,18 +40,18 @@ pub fn execute(

        let path = wrap_path(path_data);

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

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

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

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

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

            // check if diration contains NaN
            if orthogonal[0].is_nan() || orthogonal[1].is_nan() || orthogonal[2].is_nan() {
@@ -1,6 +0,0 @@
-/target
-**/*.rs.bk
-Cargo.lock
-bin/
-pkg/
-wasm-pack.log
@@ -1,12 +0,0 @@
-[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" }
@@ -1,22 +0,0 @@
-{
-  "id": "max/plantarium/debug",
-  "outputs": [],
-  "inputs": {
-    "input": {
-      "type": "float",
-      "accepts": [
-        "*"
-      ],
-      "external": true
-    },
-    "type": {
-      "type": "select",
-      "options": [
-        "float",
-        "vec3",
-        "geometry"
-      ],
-      "internal": true
-    }
-  }
-}
@@ -1,25 +0,0 @@
-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;
-}
@@ -2,14 +2,11 @@
 name = "float"
 version = "0.1.0"
 authors = ["Max Richter <jim-x@web.de>"]
-edition = "2021"
+edition = "2018"

 [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" }
@@ -1,10 +1,9 @@
 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(a: (i32, i32)) -> Vec<i32> {
-    vec![read_i32(a.0)]
+pub fn execute(args: &[i32]) -> Vec<i32> {
+    args.into()
 }
@@ -1,7 +1,6 @@
 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},
@@ -15,17 +14,13 @@ fn lerp_vec3(a: Vec3, b: Vec3, t: f32) -> Vec3 {
 }

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

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

    let mut max_depth = 0;
    for path_data in plants.iter() {
@@ -60,9 +55,9 @@ pub fn execute(

                let length = direction.length();

-                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;
+                let curviness = evaluate_float(args[2]);
+                let strength =
+                    evaluate_float(args[1]) / curviness.max(0.0001) * evaluate_float(args[1]);

                log!(
                    "length: {}, curviness: {}, strength: {}",
@@ -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 = read_i32_slice(geometry);
+    let mut geo_data = args[1].to_vec();
    let geo = wrap_geometry_data(&mut geo_data);

    let mut transforms: Vec<Mat4> = Vec::new();
@@ -1,15 +1,13 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
-use nodarium_utils::log;
-use nodarium_utils::{concat_arg_vecs, read_i32_slice};
-
-nodarium_definition_file!("src/input.json");
+use nodarium_utils::{
+    concat_args, split_args
+};

 #[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])
+pub fn execute(args: &[i32]) -> Vec<i32> {
+    let args = split_args(args);
+    concat_args(vec![&[0], args[0], args[1], args[2]])
 }
+
+nodarium_definition_file!("src/input.json");
@@ -2,7 +2,7 @@
 name = "noise"
 version = "0.1.0"
 authors = ["Max Richter <jim-x@web.de>"]
-edition = "2021"
+edition = "2018"

 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -10,12 +10,14 @@
    "scale": {
      "type": "float",
      "min": 0.1,
-      "max": 10
+      "max": 10,
+      "value": 1
    },
    "strength": {
      "type": "float",
      "min": 0.1,
-      "max": 10
+      "max": 10,
+      "value": 2
    },
    "fixBottom": {
      "type": "float",
@@ -1,8 +1,7 @@
 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, read_i32,
+    concat_args, evaluate_float, evaluate_int, evaluate_vec3, geometry::wrap_path_mut,
    reset_call_count, split_args,
 };
 use noise::{HybridMulti, MultiFractal, NoiseFn, OpenSimplex};
@@ -14,31 +13,23 @@ fn lerp(a: f32, b: f32, t: f32) -> f32 {
 }

 #[nodarium_execute]
-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> {
+pub fn execute(input: &[i32]) -> Vec<i32> {
    reset_call_count();

-    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 args = split_args(input);

-    let seed = read_i32(seed.0);
+    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 directional_strength = evaluate_vec3(read_i32_slice(directional_strength).as_slice());
+    let seed = args[4][0];

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

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

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

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

 #[nodarium_execute]
-pub fn execute(input: (i32, i32), _res: (i32, i32)) -> Vec<i32> {
-    let inp = read_i32_slice(input);
-    return inp;
+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())
 }
@@ -6,7 +6,7 @@
  "inputs": {
    "min": {
      "type": "float",
-      "value": 2
+      "value": 1
    },
    "max": {
      "type": "float",
@@ -1,17 +1,11 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
-use nodarium_utils::concat_arg_vecs;
-use nodarium_utils::read_i32_slice;
+use nodarium_utils::{concat_args, split_args};

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

 #[nodarium_execute]
-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),
-    ])
+pub fn execute(args: &[i32]) -> Vec<i32> {
+    let args = split_args(args);
+    concat_args(vec![&[1], args[0], args[1], args[2]])
 }
@@ -1,26 +1,23 @@
 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(
-    plant: (i32, i32),
-    axis: (i32, i32),
-    angle: (i32, i32),
-    spread: (i32, i32),
-) -> Vec<i32> {
-    log!("DEBUG args: {:?}", plant);
+pub fn execute(input: &[i32]) -> Vec<i32> {

-    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());
+    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 output: Vec<Vec<i32>> = plants
        .iter()
@@ -35,7 +32,7 @@ pub fn execute(

            let path = wrap_path_mut(&mut path_data);

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

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

@@ -3,29 +3,30 @@ 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,
-    read_i32_slice, read_i32, 
+    log, reset_call_count, split_args,
 };

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

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

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

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

    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(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 origin = evaluate_vec3(args[0]);
+        let length = evaluate_float(args[2]);
+        let thickness = evaluate_float(args[3]);
        let amount_points = stem.points.len() / 4;

        for i in 0..amount_points {
@@ -1,17 +1,21 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
-use nodarium_utils::read_i32_slice;
-use nodarium_utils::{decode_float, encode_float, evaluate_int, log, wrap_arg};
+use nodarium_utils::{
+    decode_float, encode_float, evaluate_int, split_args, wrap_arg, log
+};

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

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

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

    // [[1,3, x, y, z, x, y,z,x,y,z]];
    wrap_arg(&[
@@ -19,9 +23,7 @@ pub fn execute(size: (i32, i32)) -> Vec<i32> {
        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
@@ -35,14 +37,9 @@ pub fn execute(size: (i32, i32)) -> Vec<i32> {
        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,
    ])
+
 }
@@ -1,17 +1,13 @@
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
-use nodarium_utils::concat_args;
-use nodarium_utils::log;
-use nodarium_utils::read_i32_slice;
+use nodarium_utils::{concat_args, log, split_args};

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

 #[nodarium_execute]
-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(),
-    ])
+pub fn execute(input: &[i32]) -> Vec<i32> {
+    let args = split_args(input);
+    log!("vec3 input: {:?}", input);
+    log!("vec3 args: {:?}", args);
+    concat_args(args)
 }
@@ -1,15 +1,16 @@
 {
  "version": "0.0.4",
  "scripts": {
-    "postinstall": "pnpm run -r --filter 'ui' build",
+    "_postinstall": "pnpm run -r --filter 'ui' build && pnpm run -r --filter 'planty' build",
    "lint": "pnpm run -r --parallel lint",
    "qa": "pnpm lint && pnpm check && pnpm test",
    "format": "pnpm dprint fmt",
    "format:check": "pnpm dprint check",
-    "test": "pnpm run -r --parallel test",
+    "test:e2e": "pnpm run -r --parallel test:e2e",
+    "test:unit": "pnpm run -r --parallel test:unit",
    "check": "pnpm run -r --parallel check",
    "build": "pnpm build:nodes && pnpm build:app",
-    "build:app": "BASE_PATH=/ui pnpm -r --filter 'ui' build && pnpm -r --filter 'app' build",
+    "build:app": "BASE_PATH=/ui pnpm -r --filter 'ui' build && pnpm -r --filter 'app'... build",
    "build:nodes": "cargo build --workspace --target wasm32-unknown-unknown --release && rm -rf ./app/static/nodes/max/plantarium/ && mkdir -p ./app/static/nodes/max/plantarium/ && cp -R ./target/wasm32-unknown-unknown/release/*.wasm ./app/static/nodes/max/plantarium/",
    "dev:nodes": "chokidar './nodes/**' --initial -i '/pkg/' -c 'pnpm build:nodes'",
    "dev:app_ui": "pnpm -r --parallel --filter 'app' --filter './packages/ui' dev",
@@ -19,6 +20,6 @@
  "packageManager": "pnpm@10.28.1+sha512.7d7dbbca9e99447b7c3bf7a73286afaaf6be99251eb9498baefa7d406892f67b879adb3a1d7e687fc4ccc1a388c7175fbaae567a26ab44d1067b54fcb0d6a316",
  "devDependencies": {
    "chokidar-cli": "catalog:",
-    "dprint": "^0.51.1"
+    "dprint": "^0.54.0"
  }
 }
@@ -6,202 +6,96 @@ 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 {
-    input
+    return input
        .split('\n')
        .enumerate()
        .map(|(i, line)| format!("{:2}: {}", i + 1, line))
        .collect::<Vec<String>>()
-        .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())
-        )
-    })
+        .join("\n");
 }

 #[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 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 {
+    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 {
-                    Some(pat_ident.ident.clone())
+            &pat_ident.ident
        } else {
-                    None
+            panic!("Expected a simple identifier for the first argument");
        }
    } 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)
+        panic!("The execute function must have at least one argument (the input slice)");
    };
-        tuple_args.push(tuple_arg);
-    }

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

-        #[cfg(target_arch = "wasm32")]
-        fn init_panic_hook() {
-            std::panic::set_hook(Box::new(|_info| {
-                unsafe {
-                    __nodarium_log(b"PANIC\0".as_ptr(), 5);
-                }
+        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 init_allocator() {
-            nodarium_utils::allocator::ALLOCATOR.init();
-        }
-
-        #fn_vis fn #inner_fn_name(#( #input_param_names: (i32, i32) ),*) -> Vec<i32> {
-            #fn_body
+        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
        }

        #[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;
+        pub extern "C" fn __free(ptr: *mut i32, len: usize) {
            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);
+                let _ = Vec::from_raw_parts(ptr, 0, len);
+            }
        }

-            len_bytes as i32
+        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_body
        }
    };

    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);
@@ -211,23 +105,30 @@ 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)
@@ -0,0 +1,24 @@
+node_modules
+
+# Output
+.output
+.vercel
+.netlify
+.wrangler
+/.svelte-kit
+/build
+/dist
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Env
+.env
+.env.*
+!.env.example
+!.env.test
+
+# Vite
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
@@ -0,0 +1,65 @@
+# Svelte library
+
+Everything you need to build a Svelte library, powered by [`sv`](https://npmjs.com/package/sv).
+
+Read more about creating a library [in the docs](https://svelte.dev/docs/kit/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```sh
+# create a new project in the current directory
+npx sv create
+
+# create a new project in my-app
+npx sv create my-app
+```
+
+To recreate this project with the same configuration:
+
+```sh
+# recreate this project
+pnpm dlx sv@0.15.1 create --template library --types ts --add prettier eslint tailwindcss="plugins:none" --install pnpm planty
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```sh
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```sh
+npm pack
+```
+
+To create a production version of your showcase app:
+
+```sh
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```sh
+npm publish
+```
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
max	36f02cabd3	chore: format 📊 Benchmark the Runtime / benchmark (push) Successful in 1m21s Details 🚀 Lint & Test & Deploy / quality (push) Failing after 54s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 30s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m52s Details 🚀 Lint & Test & Deploy / deploy (push) Has been skipped Details	2026-05-07 17:40:41 +02:00
max	3a78ad5ee3	docs: add ux guidelines	2026-05-07 17:40:30 +02:00
max	9a7a7166b7	fix: pasting nodes	2026-05-07 17:39:58 +02:00
max	4aff3874d3	feat: show toast on some errors	2026-05-07 17:19:08 +02:00
max	f415edab57	fix: automatically update graph background on theme swtich	2026-05-07 17:03:02 +02:00
max	743959639f	feat: no results state in add menu	2026-05-07 17:02:47 +02:00
max	d9b8b36686	feat: update some inputs	2026-05-07 17:02:38 +02:00
max	ebf13967a4	feat: use new button component everyhwerre	2026-05-07 17:02:17 +02:00
max	a4f51efead	feat: add spinning icon	2026-05-07 17:01:54 +02:00
max	308626bcdc	feat: add toast component	2026-05-07 17:01:36 +02:00
max	73155dcb46	feat: show confirm when deleting project	2026-05-07 17:01:22 +02:00
max	84afd15746	feat: add #id to group name when duplicates exist	2026-05-07 17:00:57 +02:00
max	af40db3386	feat: add ZoomIndicator to graph	2026-05-07 17:00:30 +02:00
nodarium-bot	091c0f0a83	chore(release): v0.0.6	2026-05-05 21:15:25 +00:00
max	82c2f08a56	chore: cleanup changelog 📊 Benchmark the Runtime / benchmark (push) Successful in 1m34s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 2m7s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 47s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m28s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m59s Details	2026-05-05 22:58:42 +02:00
max	a00db400bb	fix: dont crash when no groups exist 📊 Benchmark the Runtime / benchmark (push) Successful in 1m24s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 48s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m24s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m59s Details 🚀 Lint & Test & Deploy / deploy (push) Has been cancelled Details	2026-05-05 22:52:24 +02:00
max	2d9eb0c087	fix: make planty work 📊 Benchmark the Runtime / benchmark (push) Successful in 1m18s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m9s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 33s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m54s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 2m4s Details	2026-05-05 22:45:20 +02:00
nodarium-bot	1e28ded99b	chore(release): v0.0.6	2026-05-05 20:33:26 +00:00
nodarium-bot	5fae518392	chore(release): v0.0.6	2026-05-05 20:23:21 +00:00
max	954f5726c3	Merge pull request 'feat: initial node groups' (#44 ) from feat/group-node-own into main 📊 Benchmark the Runtime / benchmark (push) Successful in 1m11s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m14s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 49s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 2m3s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 3m4s Details Reviewed-on: #44	2026-05-05 22:08:17 +02:00
max	63d5b8079d	chore: pnpm format 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m39s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m21s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 48s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 1m51s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Successful in 2m1s Details	2026-05-05 21:55:32 +02:00
max	3e32ca419a	feat: ungroup nodes 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m45s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m7s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 35s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 2m4s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-05 21:51:17 +02:00
max	f0cb12a088	chore: fix some type issues	2026-05-05 21:28:03 +02:00
max	1d60090ffe	chore: fixup graph manager tests	2026-05-05 21:27:53 +02:00
max	5b55056fc1	chore: remove graph element in graphManager	2026-05-05 21:27:42 +02:00
max	e2c2b1a4d7	chore: remove e2e test screenshots (too flaky)	2026-05-05 21:27:23 +02:00
max	7f082ad8f6	feat: implement node sockets ui 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m22s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m6s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Failing after 43s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 2m5s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-05 21:07:57 +02:00
max	ed11195327	chore: refactor graphStack to be simpler	2026-05-05 18:45:54 +02:00
max	8ad62cfc8e	feat: add node group breadcrumbs	2026-05-05 12:44:44 +02:00
max	bff140a764	feat: show different ui when inside group	2026-05-05 11:11:33 +02:00
max	85e2fd1a71	fix: use correct id for debug node	2026-05-04 23:54:43 +02:00
max	5beb03196d	fix: broken format command for @nodarium/planty	2026-05-04 23:47:29 +02:00
max	83e0e47082	refactor: only show group/node panel when selected	2026-05-04 23:47:03 +02:00
max	106797de32	feat: make group input/output node work 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m11s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m7s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 32s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 1m50s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Successful in 1m56s Details	2026-05-04 19:11:52 +02:00
max	1a56ba986d	damn dude 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m17s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m16s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 49s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 1m57s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Successful in 2m1s Details	2026-05-04 16:14:20 +02:00
max	703f531cd3	chore: make eslint and playwright happy 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m6s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m0s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 36s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 1m57s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 16:11:21 +02:00
max	0ed22f20b9	chore: pnpm upgrade 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m42s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 45s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 31s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 1m49s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 16:01:21 +02:00
max	733b0a2ceb	chore: sync sveltekit app before e2e 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m4s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m25s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 38s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 2m1s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:49:55 +02:00
max	8f60816c78	chore: sync sveltekit app before e2e 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m4s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m30s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 44s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 47s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:43:38 +02:00
max	cd7b51d86a	chore: sync sveltekit app before e2e 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m8s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m24s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 41s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 45s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:37:52 +02:00
max	6c9cd1505d	chore: sync sveltekit app before e2e 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m2s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m42s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 32s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 0s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:30:42 +02:00
max	db5ee8ba29	fix: make eslint happy 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m4s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m24s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 30s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 32s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:19:18 +02:00
max	a6b9ca4315	feat: capture system stats in benchmark 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m3s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 52s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 31s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 33s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:12:51 +02:00
max	d4910aba8c	chore: pnpm format 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m2s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m30s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 32s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 33s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:00:40 +02:00
max	e695c76490	chore: make eslint happy 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m6s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m7s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 31s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 32s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 14:50:11 +02:00
max	2a54fa7590	feat: add name to groups 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m8s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 45s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Failing after 29s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 34s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 14:12:30 +02:00
max	6d5cac65e8	feat(ui): click-to-copy on node values in jsonviewer	2026-05-04 14:12:17 +02:00
max	3ee074b11c	feat(ui): make inputselect also handle value+label options	2026-05-04 14:12:03 +02:00
max	59a1e63396	feat: add unit tests for graph state	2026-05-04 12:49:30 +02:00
max	317d1552ce	fix: graph correctly restore html refs after exiting node group	2026-05-04 12:49:23 +02:00
max	78439b19e9	fix: make benchmark work	2026-05-04 12:45:06 +02:00
max	ef217b1c40	feat: some updates 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m13s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 44s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Failing after 29s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 33s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 11:27:21 +02:00
max	7499b80789	fix: make the runtime work with groups	2026-05-03 17:49:14 +02:00
max	a5b663f6fc	feat(ci): split e2e and unit tests	2026-05-03 17:49:00 +02:00
max	05506704bf	feat: let claude fix ci 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m1s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 42s Details 🚀 Lint & Test & Deploy / test (pull_request) Failing after 39s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-03 17:12:49 +02:00
max	63188e57fd	feat: let claude fix ci 📊 Benchmark the Runtime / benchmark (pull_request) Failing after 1m0s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 41s Details 🚀 Lint & Test & Deploy / test (pull_request) Failing after 30s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-03 17:10:13 +02:00
max	4572d30005	feat: let claude refactor ci 📊 Benchmark the Runtime / benchmark (pull_request) Failing after 1s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1s Details 🚀 Lint & Test & Deploy / test (pull_request) Failing after 1s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-03 17:04:13 +02:00
max	ccc376d158	feat: store total vertices/faces in benchmarkl 📊 Benchmark the Runtime / release (pull_request) Successful in 1m19s Details 🚀 Lint & Test & Deploy / release (pull_request) Failing after 49s Details	2026-05-03 16:46:18 +02:00
max	7e432e9033	chore: update ci workflow 📊 Benchmark the Runtime / release (pull_request) Successful in 2m24s Details 🚀 Lint & Test & Deploy / release (pull_request) Failing after 50s Details	2026-05-03 16:44:02 +02:00
max	01f58377c2	feat: make more node group features work 📊 Benchmark the Runtime / release (pull_request) Successful in 4m32s Details 🚀 Lint & Test & Deploy / release (pull_request) Failing after 1m5s Details	2026-05-03 16:34:52 +02:00
max	6ef5dc28ed	chore: move jsonviewer into ui package	2026-05-03 16:28:40 +02:00
max	3450d70047	docs: add LLM.md	2026-05-03 13:51:33 +02:00
max	731b9e9b1e	feat: upgrade graph source panel	2026-05-03 13:51:17 +02:00
max	72f07d0a50	feat: initial node groups	2026-04-26 18:41:25 +02:00
max	a56e8f445e	feat(ci): install openssh client 📊 Benchmark the Runtime / release (push) Successful in 44s Details 🚀 Lint & Test & Deploy / release (push) Successful in 4m17s Details Build & Push CI Image / build-and-push (push) Successful in 11m54s Details	2026-04-24 13:56:07 +02:00
max	12572742eb	fix(planty): remove debug span 📊 Benchmark the Runtime / release (push) Successful in 1m4s Details 🚀 Lint & Test & Deploy / release (push) Successful in 3m52s Details	2026-04-21 01:01:37 +02:00
max	7aa9979e35	chore: update e2e tests 📊 Benchmark the Runtime / release (push) Successful in 1m0s Details 🚀 Lint & Test & Deploy / release (push) Successful in 3m47s Details	2026-04-21 00:51:09 +02:00
max	fc35a68826	fix: dont package ui library 📊 Benchmark the Runtime / release (push) Successful in 48s Details 🚀 Lint & Test & Deploy / release (push) Failing after 3m7s Details	2026-04-21 00:40:49 +02:00
max	aba6f03bcc	fix: dont package ui library 📊 Benchmark the Runtime / release (push) Successful in 57s Details 🚀 Lint & Test & Deploy / release (push) Failing after 1m53s Details	2026-04-21 00:33:56 +02:00
max	2d6fd00fd1	fix: dont package ui library 📊 Benchmark the Runtime / release (push) Successful in 50s Details 🚀 Lint & Test & Deploy / release (push) Failing after 2m8s Details	2026-04-21 00:09:49 +02:00
max	d231946e50	fix: remove unused imports 📊 Benchmark the Runtime / release (push) Successful in 47s Details 🚀 Lint & Test & Deploy / release (push) Failing after 1m45s Details	2026-04-20 23:57:07 +02:00
max	e2f4a24f75	fix(planty): make sure config is completely static 📊 Benchmark the Runtime / release (push) Successful in 54s Details 🚀 Lint & Test & Deploy / release (push) Failing after 57s Details	2026-04-20 21:34:24 +02:00
max	58d39cd101	feat: improve planty ux	2026-04-20 21:23:55 +02:00
max	7ebb1297ac	feat(app): make zoom in nicer	2026-04-20 19:45:34 +02:00
max	23f65a1c63	fix: remove unused header div	2026-04-20 19:45:23 +02:00
max	acdc582e95	feat: use ui and planty without build	2026-04-20 19:45:10 +02:00
max	7a3e9eb893	chore: update test screenshot 📊 Benchmark the Runtime / release (push) Successful in 1m20s Details 🚀 Lint & Test & Deploy / release (push) Successful in 4m48s Details	2026-04-20 02:06:13 +02:00
max	be82312ea0	chore: update test screenshot 📊 Benchmark the Runtime / release (push) Successful in 1m33s Details 🚀 Lint & Test & Deploy / release (push) Has been cancelled Details	2026-04-20 02:04:07 +02:00
max	84f67e9c33	fix: update planty types 📊 Benchmark the Runtime / release (push) Successful in 1m8s Details 🚀 Lint & Test & Deploy / release (push) Failing after 4m18s Details	2026-04-20 01:57:56 +02:00
max	491e345c2f	feat: build planty in post install 📊 Benchmark the Runtime / release (push) Successful in 1m24s Details 🚀 Lint & Test & Deploy / release (push) Failing after 1m41s Details	2026-04-20 01:53:40 +02:00
max	ba501b211d	fix: correct tsconfig for planty 📊 Benchmark the Runtime / release (push) Successful in 1m12s Details 🚀 Lint & Test & Deploy / release (push) Failing after 1m32s Details	2026-04-20 01:43:05 +02:00
max	7d76b9e1f7	fix: mark planty as type:module 📊 Benchmark the Runtime / release (push) Successful in 1m21s Details 🚀 Lint & Test & Deploy / release (push) Failing after 1m27s Details	2026-04-20 01:38:29 +02:00
max	5d4e2e9280	fix: make formatter happy 📊 Benchmark the Runtime / release (push) Successful in 1m3s Details 🚀 Lint & Test & Deploy / release (push) Failing after 1m32s Details	2026-04-20 01:32:30 +02:00
max	4de15b19c8	feat: wire up planty with nodarium/app 📊 Benchmark the Runtime / release (push) Successful in 3m55s Details 🚀 Lint & Test & Deploy / release (push) Failing after 56s Details	2026-04-20 01:08:52 +02:00
max	168e6fcc19	feat: update some node default settings	2026-04-20 01:08:41 +02:00
max	c0eb75d53c	feat: new planty package	2026-04-20 01:08:29 +02:00