chore: debug ci ssh

.gitea/workflows/benchmark.yaml

@@ -0,0 +1,87 @@
+name: 📊 Benchmark the Runtime
+
+on:
+  push:
+    branches: ["*"]
+  pull_request:
+    branches: ["*"]
+
+env:
+  PNPM_CACHE_FOLDER: .pnpm-store
+  CARGO_HOME: .cargo
+  CARGO_TARGET_DIR: target
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69
+
+    steps:
+      - name: 📑 Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN }}
+
+      - name: 💾 Setup pnpm Cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.PNPM_CACHE_FOLDER }}
+          key: ${{ runner.os }}-pnpm-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+
+      - name: 🦀 Cache Cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: 📦 Install Dependencies
+        run: pnpm install --frozen-lockfile --store-dir ${{ env.PNPM_CACHE_FOLDER }}
+
+      - name: 🛠️Build Nodes
+        run: pnpm build:nodes
+
+      - name: 🏃 Execute Runtime
+        run: pnpm run --filter @nodarium/app bench
+
+      - name: 🔑 Setup SSH key
+        run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.GIT_SSH_PRIVATE_KEY }}" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+          ssh-keyscan -p 2222 -H git.max-richter.dev >> ~/.ssh/known_hosts
+          ssh -vvv -p 2222 -i ~/.ssh/id_ed25519 -T git@git.max-richter.dev
+
+      - 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"
+
+          # 2. Clone the benchmarks repo into a temp folder
+          git config --global core.sshCommand "ssh -vv -p 2222 -i ~/.ssh/id_ed25519 -o IdentitiesOnly=yes"
+          git clone git@git.max-richter.dev:max/nodarium-benchmarks.git target_bench_repo
+          
+          # 3. Create a directory structure based on the branch
+          # This allows the UI to "switch between branches"
+          BRANCH_NAME="${{ github.ref_name }}"
+          DEST_DIR="target_bench_repo/data/$BRANCH_NAME/$(date +%s)"
+          mkdir -p "$DEST_DIR"
+
+          # 4. Copy the new results
+          # Assuming your bench tool outputs a file named 'results.json'
+          cp app/benchmark/out/*.json "$DEST_DIR/"
+
+          # 5. Commit and Push
+          cd target_bench_repo
+          git add .
+          git commit -m "Update benchmarks for $BRANCH_NAME: ${{ github.sha }}"
+          git push origin main

.gitea/workflows/release.yaml

@@ -15,7 +15,7 @@ env:
 jobs:
   release:
     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

CHANGELOG.md

@@ -1,3 +1,68 @@
+# v0.0.5 (2026-02-13)
+
+## Features
+
+- Implement debug node with full runtime integration, wildcard (`*`) inputs, variable-height nodes and parameters, and a quick-connect shortcut.
+- Add color-coded node sockets and edges to visually indicate data types.
+- Recursively merge `localState` with the initial state to safely handle outdated settings stored in `localStorage` when the settings schema changes.
+- Clamp the Add Menu to the viewport.
+- Add application favicon.
+- Consolidate all developer settings into a single **Advanced Mode** setting.
+
+## Fixes
+
+- Fix InputNumber arrow visibility in the light theme.
+- Correct changelog formatting issues.
+
+## Chores
+
+- Add `pnpm qa` pre-commit command.
+- Run linting and type checks before build in CI.
+- Sign release commits with a PGP key.
+- General formatting, lint/type cleanup, test snapshot updates, and `.gitignore` maintenance.
+
+---
+
+- [f16ba26](https://git.max-richter.dev/max/nodarium/commit/f16ba2601ff0e8f0f4454e24689499112a2a257a) fix(ci): still trying to get gpg to work
+- [cc6b832](https://git.max-richter.dev/max/nodarium/commit/cc6b832f1576356e5453ee4289b02f854152ff9a) fix(ci): trying to get gpg to work
+- [dd5fd5b](https://git.max-richter.dev/max/nodarium/commit/dd5fd5bf1715d371566bd40419b72ca05e63401e) fix(ci): better add updates to package.json
+- [38d0fff](https://git.max-richter.dev/max/nodarium/commit/38d0fffcf4ca0a346857c3658ccefdfcdf16e217) chore: update ci image
+- [bce06da](https://git.max-richter.dev/max/nodarium/commit/bce06da456e3c008851ac006033cfff256015a47) ci: add gpg-agent to ci image
+- [af585d5](https://git.max-richter.dev/max/nodarium/commit/af585d56ec825662961c8796226ed9d8cb900795) feat: use new ci image with gpg
+- [0aa73a2](https://git.max-richter.dev/max/nodarium/commit/0aa73a27c1f23bea177ecc66034f8e0384c29a8e) feat: install gpg in ci image
+- [c1ae702](https://git.max-richter.dev/max/nodarium/commit/c1ae70282cb5d58527180614a80823d80ca478c5) feat: add color to sockets
+- [4c7b03d](https://git.max-richter.dev/max/nodarium/commit/4c7b03dfb82174317d8ba01f4725af804201154d) feat: add gradient mesh line
+- [144e8cc](https://git.max-richter.dev/max/nodarium/commit/144e8cc797cfcc5a7a1fd9a0a2098dc99afb6170) fix: correctly highlight possible outputs
+- [12ff9c1](https://git.max-richter.dev/max/nodarium/commit/12ff9c151873d253ed2e54dcf56aa9c9c4716c7c) Merge pull request 'feat/debug-node' (#41) from feat/debug-node into main
+- [8d3ffe8](https://git.max-richter.dev/max/nodarium/commit/8d3ffe84ab9ca9e6d6d28333752e34da878fd3ea) Merge branch 'main' into feat/debug-node
+- [95ec93e](https://git.max-richter.dev/max/nodarium/commit/95ec93eeada9bf062e01e1e77b67b8f0343a51bf) feat: better handle ctrl+shift clicks and selections
+- [d39185e](https://git.max-richter.dev/max/nodarium/commit/d39185efafc360f49ab9437c0bad1f64665df167) feat: add "pnpm qa" command to check before commit
+- [81580cc](https://git.max-richter.dev/max/nodarium/commit/81580ccd8c1db30ce83433c4c4df84bd660d3460) fix: cleanup some type errors
+- [bf6f632](https://git.max-richter.dev/max/nodarium/commit/bf6f632d2772c3da812d5864c401f17e1aa8666a) feat: add shortcut to quick connect to debug
+- [e098be6](https://git.max-richter.dev/max/nodarium/commit/e098be60135f57cf863904a58489e032ed27e8b4) fix: also execute all nodes before debug node
+- [ec13850](https://git.max-richter.dev/max/nodarium/commit/ec13850e1c0ca5846da614d25887ff492cf8be04) fix: make debug node work with runtime
+- [15e08a8](https://git.max-richter.dev/max/nodarium/commit/15e08a816339bdf9de9ecb6a57a7defff42dbe8c) feat: implement debug node
+- [48cee58](https://git.max-richter.dev/max/nodarium/commit/48cee58ad337c1c6c59a0eb55bf9b5ecd16b99d0) chore: update test snapshots
+- [3235cae](https://git.max-richter.dev/max/nodarium/commit/3235cae9049e193c242b6091cee9f01e67ee850e) chore: fix lint and typecheck errors
+- [3f44072](https://git.max-richter.dev/max/nodarium/commit/3f440728fc8a94d59022bb545f418be049a1f1ba) feat: implement variable height for node shader
+- [da09f8b](https://git.max-richter.dev/max/nodarium/commit/da09f8ba1eda5ed347433d37064a3b4ab49e627e) refactor: move debug node into runtime
+- [ddc3b4c](https://git.max-richter.dev/max/nodarium/commit/ddc3b4ce357ef1c1e8066c0a52151713d0b6ed95) feat: allow variable height node parameters
+- [2690fc8](https://git.max-richter.dev/max/nodarium/commit/2690fc871291e73d3d028df9668e8fffb1e77476) chore: gitignore pnpm-store
+- [072ab90](https://git.max-richter.dev/max/nodarium/commit/072ab9063ba56df0673020eb639548f3a8601e04) feat: add initial debug node
+- [e23cad2](https://git.max-richter.dev/max/nodarium/commit/e23cad254d610e00f196b7fdb4532f36fd735a4b) feat: add "*" datatype for inputs for debug node
+- [5b5c63c](https://git.max-richter.dev/max/nodarium/commit/5b5c63c1a9c4ef757382bd4452149dc9777693ff) fix(ui): make arrows on inputnumber visible on lighttheme
+- [c9021f2](https://git.max-richter.dev/max/nodarium/commit/c9021f2383828f2e2b5594d125165bbc8f70b8e7) refactor: merge all dev settings into one setting
+- [9eecdd4](https://git.max-richter.dev/max/nodarium/commit/9eecdd4fb85dc60b8196101050334e26732c9a34) Merge pull request 'feat: merge localState recursively with initial' (#38) from feat/debug-node into main
+- [7e71a41](https://git.max-richter.dev/max/nodarium/commit/7e71a41e5229126d404f56598c624709961dbf3b) feat: merge localState recursively with initial
+- [07cd9e8](https://git.max-richter.dev/max/nodarium/commit/07cd9e84eb51bc02b7fed39c36cf83caba175ad7) feat: clamp AddMenu to viewport
+- [a31a49a](https://git.max-richter.dev/max/nodarium/commit/a31a49ad503d69f92f2491dd685729060ea49896) ci: lint and typecheck before build
+- [850d641](https://git.max-richter.dev/max/nodarium/commit/850d641a25cd0c781478c58c117feaf085bdbc62) chore: pnpm format
+- [ee5ca81](https://git.max-richter.dev/max/nodarium/commit/ee5ca817573b83cacfa3709e0ae88c6263bc39c1) ci: sign release commits with pgp key
+- [22a1183](https://git.max-richter.dev/max/nodarium/commit/22a11832b861ae8b44e2d374b55d12937ecab247) fix(ci): correctly format changelog
+- [b5ce572](https://git.max-richter.dev/max/nodarium/commit/b5ce5723fa4a35443df39a9096d0997f808f0b4f) chore: format favicon svg
+- [102130c](https://git.max-richter.dev/max/nodarium/commit/102130cc7777ceebcdb3de8466c90cef5b380111) feat: add favicon
+- [1668a2e](https://git.max-richter.dev/max/nodarium/commit/1668a2e6d59db071ab3da45204c2b7bfcd2150a2) chore: format changelog.md
+
 # v0.0.4 (2026-02-10)
 
 ## Features

app/benchmark/.gitignore

@@ -0,0 +1 @@
+out/

app/benchmark/benchmarkRegistry.ts

@@ -0,0 +1,47 @@
+import { NodeDefinition, NodeId, NodeRegistry } from '@nodarium/types';
+import { createWasmWrapper } from '@nodarium/utils';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+export class BenchmarkRegistry implements NodeRegistry {
+  status: 'loading' | 'ready' | 'error' = 'loading';
+
+  private nodes = new Map<string, NodeDefinition>();
+
+  async load(nodeIds: NodeId[]): Promise<NodeDefinition[]> {
+    const nodes = await Promise.all(nodeIds.map(async id => {
+      const p = resolve('static/nodes/' + id + '.wasm');
+      const file = await readFile(p);
+      const node = createWasmWrapper(file as unknown as ArrayBuffer);
+      const d = node.get_definition();
+      return {
+        ...d,
+        execute: node.execute
+      };
+    }));
+    for (const n of nodes) {
+      this.nodes.set(n.id, n);
+    }
+    this.status = 'ready';
+    return nodes;
+  }
+
+  async register(id: string, wasmBuffer: ArrayBuffer): Promise<NodeDefinition> {
+    const wasm = createWasmWrapper(wasmBuffer);
+    const d = wasm.get_definition();
+    const node = {
+      ...d,
+      execute: wasm.execute
+    };
+    this.nodes.set(id, node);
+    return node;
+  }
+
+  getNode(id: NodeId | string): NodeDefinition | undefined {
+    return this.nodes.get(id);
+  }
+
+  getAllNodes(): NodeDefinition[] {
+    return [];
+  }
+}

app/benchmark/index.ts

@@ -0,0 +1,56 @@
+import type { Graph, Graph as GraphType, NodeId } from '@nodarium/types';
+import { createLogger, createPerformanceStore } from '@nodarium/utils';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { MemoryRuntimeExecutor } from '../src/lib/runtime/runtime-executor.ts';
+import { BenchmarkRegistry } from './benchmarkRegistry.ts';
+import defaultPlantTemplate from './templates/default.json' assert { type: 'json' };
+import lottaFacesTemplate from './templates/lotta-faces.json' assert { type: 'json' };
+import plantTemplate from './templates/plant.json' assert { type: 'json' };
+
+const registry = new BenchmarkRegistry();
+const r = new MemoryRuntimeExecutor(registry);
+const perfStore = createPerformanceStore();
+
+const log = createLogger('bench');
+
+const templates: Record<string, Graph> = {
+  'plant': plantTemplate as unknown as GraphType,
+  'lotta-faces': lottaFacesTemplate as unknown as GraphType,
+  'default': defaultPlantTemplate as unknown as GraphType
+};
+
+async function run(g: GraphType, amount: number) {
+  await registry.load(plantTemplate.nodes.map(n => n.type) as NodeId[]);
+  log.log('loaded ' + g.nodes.length + ' nodes');
+
+  log.log('warming up');
+
+  // Warm up the runtime? maybe this does something?
+  for (let index = 0; index < 10; index++) {
+    await r.execute(g, { randomSeed: true });
+  }
+
+  log.log('executing');
+  r.perf = perfStore;
+  for (let i = 0; i < amount; i++) {
+    r.perf?.startRun();
+    await r.execute(g, { randomSeed: true });
+    r.perf?.stopRun();
+  }
+  log.log('finished');
+  return r.perf.get();
+}
+
+async function main() {
+  const outPath = resolve('benchmark/out/');
+  await mkdir(outPath, { recursive: true });
+  for (const key in templates) {
+    log.log('executing ' + key);
+    const perfData = await run(templates[key], 100);
+    await writeFile(resolve(outPath, key + '.json'), JSON.stringify(perfData));
+    await new Promise(res => setTimeout(res, 200));
+  }
+}
+
+main();

app/benchmark/templates/default.json

@@ -0,0 +1,95 @@
+{
+  "settings": { "resolution.circle": 26, "resolution.curve": 39 },
+  "nodes": [
+    { "id": 9, "position": [220, 80], "type": "max/plantarium/output", "props": {} },
+    {
+      "id": 10,
+      "position": [95, 80],
+      "type": "max/plantarium/stem",
+      "props": { "amount": 5, "length": 11, "thickness": 0.1 }
+    },
+    {
+      "id": 14,
+      "position": [195, 80],
+      "type": "max/plantarium/gravity",
+      "props": {
+        "strength": 0.38,
+        "scale": 39,
+        "fixBottom": 0,
+        "directionalStrength": [1, 1, 1],
+        "depth": 1,
+        "curviness": 1
+      }
+    },
+    {
+      "id": 15,
+      "position": [120, 80],
+      "type": "max/plantarium/noise",
+      "props": {
+        "strength": 4.9,
+        "scale": 2.2,
+        "fixBottom": 1,
+        "directionalStrength": [1, 1, 1],
+        "depth": 1,
+        "octaves": 1
+      }
+    },
+    {
+      "id": 16,
+      "position": [70, 80],
+      "type": "max/plantarium/vec3",
+      "props": { "0": 0, "1": 0, "2": 0 }
+    },
+    {
+      "id": 17,
+      "position": [45, 80],
+      "type": "max/plantarium/random",
+      "props": { "min": -2, "max": 2 }
+    },
+    {
+      "id": 18,
+      "position": [170, 80],
+      "type": "max/plantarium/branch",
+      "props": {
+        "length": 1.6,
+        "thickness": 0.69,
+        "amount": 36,
+        "offsetSingle": 0.5,
+        "lowestBranch": 0.46,
+        "highestBranch": 1,
+        "depth": 1,
+        "rotation": 180
+      }
+    },
+    {
+      "id": 19,
+      "position": [145, 80],
+      "type": "max/plantarium/gravity",
+      "props": {
+        "strength": 0.38,
+        "scale": 39,
+        "fixBottom": 0,
+        "directionalStrength": [1, 1, 1],
+        "depth": 1,
+        "curviness": 1
+      }
+    },
+    {
+      "id": 20,
+      "position": [70, 120],
+      "type": "max/plantarium/random",
+      "props": { "min": 0.073, "max": 0.15 }
+    }
+  ],
+  "edges": [
+    [14, 0, 9, "input"],
+    [10, 0, 15, "plant"],
+    [16, 0, 10, "origin"],
+    [17, 0, 16, "0"],
+    [17, 0, 16, "2"],
+    [18, 0, 14, "plant"],
+    [15, 0, 19, "plant"],
+    [19, 0, 18, "plant"],
+    [20, 0, 10, "thickness"]
+  ]
+}

app/benchmark/templates/lotta-faces.json

@@ -0,0 +1,44 @@
+{
+  "settings": { "resolution.circle": 64, "resolution.curve": 64, "randomSeed": false },
+  "nodes": [
+    { "id": 9, "position": [260, 0], "type": "max/plantarium/output", "props": {} },
+    {
+      "id": 18,
+      "position": [185, 0],
+      "type": "max/plantarium/stem",
+      "props": { "amount": 64, "length": 12, "thickness": 0.15 }
+    },
+    {
+      "id": 19,
+      "position": [210, 0],
+      "type": "max/plantarium/noise",
+      "props": { "scale": 1.3, "strength": 5.4 }
+    },
+    {
+      "id": 20,
+      "position": [235, 0],
+      "type": "max/plantarium/branch",
+      "props": { "length": 0.8, "thickness": 0.8, "amount": 3 }
+    },
+    {
+      "id": 21,
+      "position": [160, 0],
+      "type": "max/plantarium/vec3",
+      "props": { "0": 0.39, "1": 0, "2": 0.41 }
+    },
+    {
+      "id": 22,
+      "position": [130, 0],
+      "type": "max/plantarium/random",
+      "props": { "min": -2, "max": 2 }
+    }
+  ],
+  "edges": [
+    [18, 0, 19, "plant"],
+    [19, 0, 20, "plant"],
+    [20, 0, 9, "input"],
+    [21, 0, 18, "origin"],
+    [22, 0, 21, "0"],
+    [22, 0, 21, "2"]
+  ]
+}

app/benchmark/templates/plant.json

@@ -0,0 +1,71 @@
+{
+  "settings": { "resolution.circle": 26, "resolution.curve": 39 },
+  "nodes": [
+    { "id": 9, "position": [180, 80], "type": "max/plantarium/output", "props": {} },
+    {
+      "id": 10,
+      "position": [55, 80],
+      "type": "max/plantarium/stem",
+      "props": { "amount": 1, "length": 11, "thickness": 0.71 }
+    },
+    {
+      "id": 11,
+      "position": [80, 80],
+      "type": "max/plantarium/noise",
+      "props": {
+        "strength": 35,
+        "scale": 4.6,
+        "fixBottom": 1,
+        "directionalStrength": [1, 0.74, 0.083],
+        "depth": 1
+      }
+    },
+    {
+      "id": 12,
+      "position": [105, 80],
+      "type": "max/plantarium/branch",
+      "props": {
+        "length": 3,
+        "thickness": 0.6,
+        "amount": 10,
+        "rotation": 180,
+        "offsetSingle": 0.34,
+        "lowestBranch": 0.53,
+        "highestBranch": 1,
+        "depth": 1
+      }
+    },
+    {
+      "id": 13,
+      "position": [130, 80],
+      "type": "max/plantarium/noise",
+      "props": {
+        "strength": 8,
+        "scale": 7.7,
+        "fixBottom": 1,
+        "directionalStrength": [1, 0, 1],
+        "depth": 1
+      }
+    },
+    {
+      "id": 14,
+      "position": [155, 80],
+      "type": "max/plantarium/gravity",
+      "props": {
+        "strength": 0.11,
+        "scale": 39,
+        "fixBottom": 0,
+        "directionalStrength": [1, 1, 1],
+        "depth": 1,
+        "curviness": 1
+      }
+    }
+  ],
+  "edges": [
+    [10, 0, 11, "plant"],
+    [11, 0, 12, "plant"],
+    [12, 0, 13, "plant"],
+    [13, 0, 14, "plant"],
+    [14, 0, 9, "input"]
+  ]
+}

app/e2e/main.test.ts

@@ -23,9 +23,9 @@ test('test', async ({ page }) => {
       id: '10',
       type: 'max/plantarium/stem',
       props: {
-        amount: 50,
+        amount: 4,
         length: 4,
-        thickness: 1
+        thickness: 0.2
       }
     },
     {

app/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nodarium/app",
   "private": true,
-  "version": "0.0.4",
+  "version": "0.0.5",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
@@ -14,11 +14,13 @@
     "format": "dprint fmt -c '../.dprint.jsonc' .",
     "format:check": "dprint check -c '../.dprint.jsonc' .",
     "lint": "eslint .",
-    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json"
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "bench": "tsx ./benchmark/index.ts"
   },
   "dependencies": {
     "@nodarium/ui": "workspace:*",
     "@nodarium/utils": "workspace:*",
+    "@nodarium/planty": "workspace:*",
     "@sveltejs/kit": "^2.50.2",
     "@tailwindcss/vite": "^4.1.18",
     "@threlte/core": "8.3.1",
@@ -51,6 +53,7 @@
     "svelte": "^5.49.2",
     "svelte-check": "^4.3.6",
     "tslib": "^2.8.1",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.54.0",
     "vite": "^7.3.1",

app/src/app.css

@@ -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");

app/src/app.html

@@ -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>

app/src/lib/graph-interface/components/AddMenu.svelte

@@ -183,7 +183,7 @@
             activeNodeId = node.id;
           }}
         >
-          {node.id.split('/').at(-1)}
+          {node.meta?.title ?? node.id.split('/').at(-1)}
         </div>
       {/each}
     </div>

app/src/lib/graph-interface/graph-manager.svelte.ts

@@ -3,11 +3,14 @@ import { RemoteNodeRegistry } from '$lib/node-registry/index';
 import type {
   Edge,
   Graph,
+  GroupSocket,
   NodeDefinition,
+  NodeGroupDefinition,
   NodeId,
   NodeInput,
   NodeInstance,
   NodeRegistry,
+  SerializedNode,
   Socket
 } from '@nodarium/types';
 import { fastHashString } from '@nodarium/utils';
@@ -56,6 +59,14 @@ function areEdgesEqual(firstEdge: Edge, secondEdge: Edge) {
   return true;
 }
 
+function isVirtualType(type: string): boolean {
+  return type.startsWith('__virtual/');
+}
+
+function isGroupInstanceType(type: string): boolean {
+  return type === '__virtual/group/instance';
+}
+
 export class GraphManager extends EventEmitter<{
   save: Graph;
   result: unknown;
@@ -79,6 +90,12 @@ export class GraphManager extends EventEmitter<{
 
   currentUndoGroup: number | null = null;
 
+  // Group-related state
+  groups: Map<string, NodeGroupDefinition> = new Map();
+  groupNodeDefinitions: Map<string, NodeDefinition> = new Map();
+  currentGroupContext: string | null = null;
+  graphStack: { rootGraph: Graph; groupId: string; cameraPosition: [number, number, number] }[] = $state([]);
+
   inputSockets = $derived.by(() => {
     const s = new SvelteSet<string>();
     for (const edge of this.edges) {
@@ -88,37 +105,523 @@ export class GraphManager extends EventEmitter<{
   });
 
   history: HistoryManager = new HistoryManager();
+  private serializeFullGraph(): Graph {
+    if (this.graphStack.length === 0) return this.serialize();
+    // Merge the current internal state upward through every stack level.
+    // $state.snapshot strips Svelte reactive proxies so the result can cross
+    // the postMessage boundary to the worker.
+    let merged: Graph = this.serialize();
+    for (let i = this.graphStack.length - 1; i >= 0; i--) {
+      const { rootGraph, groupId } = $state.snapshot(this.graphStack[i]);
+      merged = {
+        ...rootGraph,
+        groups: {
+          ...rootGraph.groups,
+          [groupId]: {
+            ...rootGraph.groups?.[groupId]!,
+            graph: { nodes: merged.nodes, edges: merged.edges }
+          }
+        }
+      };
+    }
+    return merged;
+  }
+
   execute = throttle(() => {
     if (this.loaded === false) return;
-    this.emit('result', this.serialize());
+    this.emit('result', this.serializeFullGraph());
   }, 10);
 
   constructor(public registry: NodeRegistry) {
     super();
   }
 
+  // --- Group helpers ---
+
+  private buildGroupNodeDefinition(group: NodeGroupDefinition): NodeDefinition {
+    return {
+      id: `__virtual/group/${group.id}` as NodeId,
+      meta: { title: group.name },
+      inputs: Object.fromEntries(
+        group.inputs.map(s => [s.name, { type: s.type, external: true } as NodeInput])
+      ),
+      outputs: group.outputs.map(s => s.type),
+      execute(input: Int32Array): Int32Array { return input; }
+    };
+  }
+
+  buildGroupInputNodeDef(group: NodeGroupDefinition): NodeDefinition {
+    return {
+      id: '__virtual/group/input' as NodeId,
+      inputs: {},
+      outputs: group.inputs.map(s => s.type),
+      execute(input: Int32Array): Int32Array { return input; }
+    };
+  }
+
+  buildGroupOutputNodeDef(group: NodeGroupDefinition): NodeDefinition {
+    return {
+      id: '__virtual/group/output' as NodeId,
+      inputs: Object.fromEntries(
+        group.outputs.map(s => [s.name, { type: s.type }])
+      ) as Record<string, NodeInput>,
+      outputs: [],
+      execute(input: Int32Array): Int32Array { return input; }
+    };
+  }
+
+  private getNodeTypeWithContext(type: string, props?: Record<string, unknown>): NodeDefinition | undefined {
+    if (type === '__virtual/group/input' && this.currentGroupContext) {
+      const group = this.groups.get(this.currentGroupContext);
+      if (group) return this.buildGroupInputNodeDef(group);
+    }
+    if (type === '__virtual/group/output' && this.currentGroupContext) {
+      const group = this.groups.get(this.currentGroupContext);
+      if (group) return this.buildGroupOutputNodeDef(group);
+    }
+    if (type === '__virtual/group/instance') {
+      const groupId = props?.groupId as string | undefined;
+      if (groupId) return this.groupNodeDefinitions.get(`__virtual/group/${groupId}`);
+      return undefined;
+    }
+    return this.groupNodeDefinitions.get(type) || this.registry.getNode(type);
+  }
+
+  // --- Group creation ---
+
+  createGroup(nodeIds: number[]): NodeInstance | undefined {
+    if (nodeIds.length === 0) return;
+
+    const selectedNodes = nodeIds
+      .map(id => this.getNode(id))
+      .filter(Boolean) as NodeInstance[];
+    if (selectedNodes.length === 0) return;
+
+    const selectedSet = new Set(nodeIds);
+
+    // Snapshot boundary edges
+    const incomingEdges = this.edges.filter(e =>
+      !selectedSet.has(e[0].id) && selectedSet.has(e[2].id)
+    );
+    const outgoingEdges = this.edges.filter(e =>
+      selectedSet.has(e[0].id) && !selectedSet.has(e[2].id)
+    );
+
+    const inputs: GroupSocket[] = incomingEdges.map((e, i) => ({
+      name: `input_${i}`,
+      type: e[0].state.type?.outputs?.[e[1]] || '*'
+    }));
+
+    const outputs: GroupSocket[] = outgoingEdges.map((e, i) => ({
+      name: `output_${i}`,
+      type: e[0].state.type?.outputs?.[e[1]] || '*'
+    }));
+
+    const groupId = `grp_${Date.now().toString(36)}`;
+
+    const xs = selectedNodes.map(n => n.position[0]);
+    const ys = selectedNodes.map(n => n.position[1]);
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const avgY = ys.reduce((a, b) => a + b, 0) / ys.length;
+    const centroidX = xs.reduce((a, b) => a + b, 0) / xs.length;
+
+    // Find unique IDs for virtual nodes in the internal graph
+    const existingIds = new Set(selectedNodes.map(n => n.id));
+    let internalInputId = 1;
+    while (existingIds.has(internalInputId)) internalInputId++;
+    existingIds.add(internalInputId);
+    let internalOutputId = internalInputId + 1;
+    while (existingIds.has(internalOutputId)) internalOutputId++;
+
+    const internalNodes: SerializedNode[] = [
+      {
+        id: internalInputId,
+        type: '__virtual/group/input' as NodeId,
+        position: [minX - 25, avgY]
+      },
+      ...selectedNodes.map(n => {
+        // Use $state.snapshot to get plain values (no reactive proxies)
+        const props = n.props ? $state.snapshot(n.props) : undefined;
+        const meta = n.meta ? $state.snapshot(n.meta) : undefined;
+        return {
+          id: n.id,
+          type: n.type,
+          position: [n.position[0], n.position[1]] as [number, number],
+          ...(props !== undefined ? { props } : {}),
+          ...(meta ? { meta } : {})
+        };
+      }),
+      {
+        id: internalOutputId,
+        type: '__virtual/group/output' as NodeId,
+        position: [maxX + 25, avgY]
+      }
+    ];
+
+    const internalEdges: Graph['edges'] = [
+      ...this.getEdgesBetweenNodes(selectedNodes),
+      ...incomingEdges.map((e, i) =>
+        [internalInputId, i, e[2].id, e[3]] as [number, number, number, string]
+      ),
+      ...outgoingEdges.map((e, i) =>
+        [e[0].id, e[1], internalOutputId, `output_${i}`] as [number, number, number, string]
+      )
+    ];
+
+    const group: NodeGroupDefinition = {
+      id: groupId,
+      name: 'Group',
+      inputs,
+      outputs,
+      graph: { nodes: internalNodes, edges: internalEdges }
+    };
+
+    this.groups.set(groupId, group);
+    if (!this.graph.groups) this.graph.groups = {};
+    this.graph.groups[groupId] = group;
+
+    const groupNodeDef = this.buildGroupNodeDefinition(group);
+    this.groupNodeDefinitions.set(groupNodeDef.id, groupNodeDef);
+
+    this.startUndoGroup();
+
+    // Remove selected nodes and all their edges
+    for (const node of selectedNodes) {
+      const connectedEdges = this.edges.filter(
+        e => e[0].id === node.id || e[2].id === node.id
+      );
+      for (const e of connectedEdges) {
+        this.removeEdge(e, { applyDeletion: false });
+      }
+      this.nodes.delete(node.id);
+    }
+
+    // Place group instance node (plain object like _init — don't wrap in $state()
+    // to avoid Svelte 5 deeply-proxying the NodeDefinition execute function)
+    const groupNodeId = this.createNodeId();
+    const groupNode = {
+      id: groupNodeId,
+      type: '__virtual/group/instance' as NodeId,
+      position: [centroidX, avgY] as [number, number],
+      props: { groupId },
+      state: { type: groupNodeDef }
+    } as NodeInstance;
+    this.nodes.set(groupNodeId, groupNode);
+
+    // Reconnect boundary edges
+    for (let i = 0; i < incomingEdges.length; i++) {
+      const e = incomingEdges[i];
+      this.createEdge(e[0], e[1], groupNode, inputs[i].name, { applyUpdate: false });
+    }
+    for (let i = 0; i < outgoingEdges.length; i++) {
+      const e = outgoingEdges[i];
+      this.createEdge(groupNode, i, e[2], e[3], { applyUpdate: false });
+    }
+
+    this.saveUndoGroup();
+    this.execute();
+
+    return groupNode;
+  }
+
+  // --- Ungrouping ---
+
+  ungroup(nodeId: number) {
+    const groupNode = this.getNode(nodeId);
+    if (!groupNode || !isGroupInstanceType(groupNode.type)) return;
+
+    const groupId = groupNode.props?.groupId as string | undefined;
+    if (!groupId) return;
+    const group = this.groups.get(groupId);
+    if (!group) return;
+
+    const incomingEdges = this.getEdgesToNode(groupNode);
+    const outgoingEdges = this.getEdgesFromNode(groupNode);
+
+    const inputVirtualId = group.graph.nodes.find(
+      n => n.type === '__virtual/group/input'
+    )?.id;
+    const outputVirtualId = group.graph.nodes.find(
+      n => n.type === '__virtual/group/output'
+    )?.id;
+
+    this.startUndoGroup();
+
+    // Remove the group instance node (and its edges)
+    this.removeNode(groupNode, { restoreEdges: false });
+
+    // Re-insert internal nodes
+    const idMap = new Map<number, number>();
+    const realInternalNodes = group.graph.nodes.filter(
+      n => n.type !== '__virtual/group/input' && n.type !== '__virtual/group/output'
+    );
+
+    for (const n of realInternalNodes) {
+      const newId = this.createNodeId();
+      idMap.set(n.id, newId);
+      const nodeType = this.getNodeTypeWithContext(n.type, n.props as Record<string, unknown>);
+      const newNode: NodeInstance = $state({
+        id: newId,
+        type: n.type,
+        position: [...n.position] as [number, number],
+        ...(n.props ? { props: { ...n.props } } : {}),
+        state: nodeType ? { type: nodeType } : {}
+      });
+      this.nodes.set(newId, newNode);
+    }
+
+    // Re-wire edges
+    for (const e of group.graph.edges) {
+      const fromIsInput = e[0] === inputVirtualId;
+      const toIsOutput = e[2] === outputVirtualId;
+
+      if (fromIsInput) {
+        const inputIdx = e[1];
+        const parentEdge = incomingEdges.find(
+          pe => pe[3] === group.inputs[inputIdx]?.name
+        );
+        if (parentEdge) {
+          const toNode = this.getNode(idMap.get(e[2])!);
+          if (toNode) {
+            this.createEdge(parentEdge[0], parentEdge[1], toNode, e[3], {
+              applyUpdate: false
+            });
+          }
+        }
+      } else if (toIsOutput) {
+        const outputSocketName = e[3];
+        const outputIdx = group.outputs.findIndex(s => s.name === outputSocketName);
+        const parentEdge = outgoingEdges.find(pe => pe[1] === outputIdx);
+        if (parentEdge) {
+          const fromNode = this.getNode(idMap.get(e[0])!);
+          const toNode = this.getNode(parentEdge[2].id);
+          if (fromNode && toNode) {
+            this.createEdge(fromNode, e[1], toNode, parentEdge[3], {
+              applyUpdate: false
+            });
+          }
+        }
+      } else {
+        const fromNode = this.getNode(idMap.get(e[0])!);
+        const toNode = this.getNode(idMap.get(e[2])!);
+        if (fromNode && toNode) {
+          this.createEdge(fromNode, e[1], toNode, e[3], { applyUpdate: false });
+        }
+      }
+    }
+
+    // Remove group definition if no more instances
+    const hasOtherInstances = Array.from(this.nodes.values()).some(
+      n => n.type === '__virtual/group/instance' && (n.props?.groupId as string) === groupId
+    );
+    if (!hasOtherInstances) {
+      this.groups.delete(groupId);
+      this.groupNodeDefinitions.delete(`__virtual/group/${groupId}`);
+      if (this.graph.groups) {
+        delete this.graph.groups[groupId];
+      }
+    }
+
+    this.saveUndoGroup();
+    this.execute();
+  }
+
+  // --- Group socket management (called from inside a group) ---
+
+  addGroupSocket(kind: 'input' | 'output', socketType: string) {
+    if (!this.currentGroupContext) return;
+    const group = this.groups.get(this.currentGroupContext);
+    if (!group) return;
+
+    const arr = kind === 'input' ? group.inputs : group.outputs;
+    const name = `${kind}_${arr.length}`;
+    arr.push({ name, type: socketType });
+
+    this._refreshGroupContext(group);
+    this.save();
+  }
+
+  removeGroupSocket(kind: 'input' | 'output', index: number) {
+    if (!this.currentGroupContext) return;
+    const group = this.groups.get(this.currentGroupContext);
+    if (!group) return;
+
+    const arr = kind === 'input' ? group.inputs : group.outputs;
+    arr.splice(index, 1);
+
+    this._refreshGroupContext(group);
+    this.save();
+  }
+
+  private _refreshGroupContext(group: NodeGroupDefinition) {
+    const groupId = group.id;
+
+    // Keep graph.groups in sync
+    if (this.graph.groups?.[groupId]) {
+      this.graph.groups[groupId] = group;
+    }
+
+    // Rebuild the group node definition (used in parent graph)
+    const groupNodeDef = this.buildGroupNodeDefinition(group);
+    this.groupNodeDefinitions.set(groupNodeDef.id, groupNodeDef);
+
+    // Update virtual input/output nodes in the current internal graph,
+    // and any group instance nodes that reference this group
+    const inputDef = this.buildGroupInputNodeDef(group);
+    const outputDef = this.buildGroupOutputNodeDef(group);
+    for (const node of this.nodes.values()) {
+      if (node.type === '__virtual/group/input') node.state.type = inputDef;
+      if (node.type === '__virtual/group/output') node.state.type = outputDef;
+      if (node.type === '__virtual/group/instance' && (node.props?.groupId as string) === groupId) {
+        node.state.type = groupNodeDef;
+      }
+    }
+  }
+
+  // --- Group navigation ---
+
+  enterGroup(nodeId: number, cameraPosition: [number, number, number] = [0, 0, 4]): boolean {
+    const groupNode = this.getNode(nodeId);
+    if (!groupNode || !isGroupInstanceType(groupNode.type)) return false;
+
+    const groupId = groupNode.props?.groupId as string | undefined;
+    if (!groupId) return false;
+    const group = this.groups.get(groupId);
+    if (!group) return false;
+
+    const currentSerialized = this.serialize();
+    this.graphStack.push({ rootGraph: currentSerialized, groupId, cameraPosition });
+
+    this.currentGroupContext = groupId;
+
+    const internalGraph: Graph = {
+      id: this.graph.id,
+      nodes: group.graph.nodes,
+      edges: group.graph.edges,
+      groups: this.graph.groups
+    };
+
+    this.graph = internalGraph;
+    this._init(internalGraph);
+    this.history.reset();
+
+    return true;
+  }
+
+  exitGroup(): [number, number, number] | false {
+    if (this.graphStack.length === 0) return false;
+
+    const { rootGraph, groupId, cameraPosition } = this.graphStack[this.graphStack.length - 1];
+    this.graphStack.pop();
+
+    // Serialize current internal graph state
+    const internalState = this.serialize();
+
+    // Update the group definition in the root graph
+    const updatedRootGraph: Graph = {
+      ...rootGraph,
+      groups: {
+        ...rootGraph.groups,
+        [groupId]: {
+          ...rootGraph.groups?.[groupId]!,
+          graph: {
+            nodes: internalState.nodes,
+            edges: internalState.edges
+          }
+        }
+      }
+    };
+
+    this.currentGroupContext = this.graphStack.length > 0
+      ? this.graphStack[this.graphStack.length - 1].groupId
+      : null;
+
+    this.graph = updatedRootGraph;
+    this._init(updatedRootGraph);
+    this.history.reset();
+    this.save();
+
+    return cameraPosition;
+  }
+
+  get isInsideGroup(): boolean {
+    return this.graphStack.length > 0;
+  }
+
+  get breadcrumbs(): { name: string; groupId: string | null }[] {
+    const crumbs: { name: string; groupId: string | null }[] = [
+      { name: 'Root', groupId: null }
+    ];
+    for (const entry of this.graphStack) {
+      const group = this.groups.get(entry.groupId);
+      crumbs.push({ name: group?.name ?? entry.groupId, groupId: entry.groupId });
+    }
+    return crumbs;
+  }
+
+  // --- Serialization ---
+
+  private serializeGroups(): Graph['groups'] | undefined {
+    const src = this.graph.groups;
+    if (!src || Object.keys(src).length === 0) return undefined;
+    const result: NonNullable<Graph['groups']> = {};
+    for (const [id, group] of Object.entries(src)) {
+      result[id] = {
+        id: group.id,
+        name: group.name,
+        inputs: group.inputs.map(s => ({ name: s.name, type: s.type })),
+        outputs: group.outputs.map(s => ({ name: s.name, type: s.type })),
+        graph: {
+          nodes: group.graph.nodes.map(n => ({
+            id: n.id,
+            type: n.type,
+            position: [n.position[0], n.position[1]] as [number, number],
+            ...(n.props !== undefined ? {
+              props: Object.fromEntries(
+                Object.entries(n.props).map(([k, v]) => [
+                  k,
+                  Array.isArray(v) ? [...v] : v
+                ])
+              )
+            } : {}),
+            ...(n.meta ? { meta: { title: n.meta.title, lastModified: n.meta.lastModified } } : {})
+          })),
+          edges: group.graph.edges.map(
+            e => [e[0], e[1], e[2], e[3]] as [number, number, number, string]
+          )
+        }
+      };
+    }
+    return result;
+  }
+
   serialize(): Graph {
     const nodes = Array.from(this.nodes.values()).map((node) => ({
       id: node.id,
-      position: [...node.position],
+      position: [...node.position] as [number, number],
       type: node.type,
-      props: node.props
+      props: node.props ? $state.snapshot(node.props) : undefined
-    })) as NodeInstance[];
+    }));
     const edges = this.edges.map((edge) => [
       edge[0].id,
       edge[1],
       edge[2].id,
       edge[3]
     ]) as Graph['edges'];
+
+    const groups = this.serializeGroups();
+
     const serialized = {
       id: this.graph.id,
       settings: $state.snapshot(this.settings),
       meta: $state.snapshot(this.graph.meta),
       nodes,
-      edges
+      edges,
+      ...(groups ? { groups } : {})
     };
     logger.log('serializing graph', serialized);
-    return clone($state.snapshot(serialized));
+    return clone(serialized) as Graph;
   }
 
   private lastSettingsHash = 0;
@@ -133,7 +636,12 @@ export class GraphManager extends EventEmitter<{
   }
 
   getNodeDefinitions() {
-    return this.registry.getAllNodes();
+    const all = this.registry.getAllNodes();
+    // Only show the Group node in AddMenu when there's at least one group to assign
+    if (this.groups.size === 0) {
+      return all.filter(n => n.id !== '__virtual/group/instance');
+    }
+    return all;
   }
 
   getLinkedNodes(node: NodeInstance) {
@@ -209,19 +717,14 @@ export class GraphManager extends EventEmitter<{
     const draggedInputs = Object.values(draggedNode.state.type.inputs ?? {});
     const draggedOutputs = draggedNode.state.type.outputs ?? [];
 
-    // Optimization: Pre-calculate parents to avoid cycles
     const parentIds = new SvelteSet(this.getParentsOfNode(draggedNode).map(n => n.id));
 
     return this.edges.filter((edge) => {
       const [fromNode, fromSocketIdx, toNode, toSocketKey] = edge;
 
-      // 1. Prevent cycles: If the target node is already a parent, we can't drop here
       if (parentIds.has(toNode.id)) return false;
-
-      // 2. Prevent self-dropping: Don't drop on edges already connected to this node
       if (fromNode.id === nodeId || toNode.id === nodeId) return false;
 
-      // 3. Check if edge.source can plug into ANY draggedNode.input
       const edgeOutputSocketType = fromNode.state?.type?.outputs?.[fromSocketIdx];
       const canPlugIntoDragged = draggedInputs.some(input => {
         const acceptedTypes = [input.type, ...(input.accepts || [])];
@@ -230,7 +733,6 @@ export class GraphManager extends EventEmitter<{
 
       if (!canPlugIntoDragged) return false;
 
-      // 4. Check if ANY draggedNode.output can plug into edge.target
       const targetInput = toNode.state?.type?.inputs?.[toSocketKey];
       const targetAcceptedTypes = [targetInput?.type, ...(targetInput?.accepts || [])];
 
@@ -267,15 +769,35 @@ export class GraphManager extends EventEmitter<{
   }
 
   private _init(graph: Graph) {
+    // Rebuild group definitions from the graph
+    this.groups.clear();
+    this.groupNodeDefinitions.clear();
+    if (graph.groups) {
+      for (const [groupId, group] of Object.entries(graph.groups)) {
+        this.groups.set(groupId, group);
+        const def = this.buildGroupNodeDefinition(group);
+        this.groupNodeDefinitions.set(def.id, def);
+      }
+    }
+
     const nodes = new SvelteMap(
-      graph.nodes.map((node) => {
+      graph.nodes.map((serialized) => {
-        const nodeType = this.registry.getNode(node.type);
+        // Migration: old __virtual/group/{groupId} format → __virtual/group/instance with props.groupId
-        const n = node as NodeInstance;
+        let node = serialized;
-        if (nodeType) {
+        if (node.type.startsWith('__virtual/group/')
-          n.state = {
+            && node.type !== '__virtual/group/input'
-            type: nodeType
+            && node.type !== '__virtual/group/output'
-          };
+            && node.type !== '__virtual/group/instance') {
+          const oldGroupId = node.type.split('/')[2];
+          node = { ...node, type: '__virtual/group/instance' as NodeId, props: { ...node.props, groupId: oldGroupId } };
         }
+
+        // IMPORTANT: copy the node so we don't mutate the original SerializedNode
+        // (which may be stored in a group definition). Mutating it would add
+        // state.type (with an execute fn) making it non-cloneable.
+        const nodeType = this.getNodeTypeWithContext(node.type, node.props as Record<string, unknown>);
+        const n = { ...node } as NodeInstance;
+        n.state = nodeType ? { type: nodeType } : {};
         return [node.id, n];
       })
     );
@@ -311,7 +833,10 @@ export class GraphManager extends EventEmitter<{
 
     logger.info('loading graph', { nodes: graph.nodes, edges: graph.edges, id: graph.id });
 
-    const nodeIds = Array.from(new SvelteSet([...graph.nodes.map((n) => n.type)]));
+    // Filter out virtual group types — they are resolved locally, not fetched remotely
+    const nodeIds = Array.from(new SvelteSet([
+      ...graph.nodes.map((n) => n.type).filter(t => !isVirtualType(t))
+    ]));
     await this.registry.load(nodeIds);
 
     // Fetch all nodes from all collections of the loaded nodes
@@ -332,13 +857,13 @@ export class GraphManager extends EventEmitter<{
     logger.info('loaded node types', this.registry.getAllNodes());
 
     for (const node of this.graph.nodes) {
+      if (isVirtualType(node.type)) continue;
       const nodeType = this.registry.getNode(node.type);
       if (!nodeType) {
         logger.error(`Node type not found: ${node.type}`);
         this.status = 'error';
         return;
       }
-      // Turn into runtime node
       const n = node as NodeInstance;
       n.state = {};
       n.state.type = nodeType;
@@ -347,7 +872,6 @@ export class GraphManager extends EventEmitter<{
     // load settings
     const settingTypes: Record<
       string,
-      // Optional metadata to map settings to specific nodes
       NodeInput & { __node_type: string; __node_input: string }
     > = {};
     const settingValues = graph.settings || {};
@@ -376,6 +900,10 @@ export class GraphManager extends EventEmitter<{
     this.settings = settingValues;
     this.emit('settings', { types: settingTypes, values: settingValues });
 
+    // Reset navigation
+    this.graphStack = [];
+    this.currentGroupContext = null;
+
     this.history.reset();
     this._init(this.graph);
 
@@ -442,9 +970,7 @@ export class GraphManager extends EventEmitter<{
   }
 
   getNodesBetween(from: NodeInstance, to: NodeInstance): NodeInstance[] | undefined {
-    //  < - - - - from
     const toParents = this.getParentsOfNode(to);
-    //  < - - - - from - - - - to
     const fromParents = this.getParentsOfNode(from);
     if (toParents.includes(from)) {
       const fromChildren = this.getChildren(from);
@@ -453,7 +979,6 @@ export class GraphManager extends EventEmitter<{
       const toChildren = this.getChildren(to);
       return fromParents.filter((n) => toChildren.includes(n));
     } else {
-      // these two nodes are not connected
       return;
     }
   }
@@ -507,7 +1032,6 @@ export class GraphManager extends EventEmitter<{
   }
 
   createGraph(nodes: NodeInstance[], edges: [number, number, number, string][]) {
-    // map old ids to new ids
     const idMap = new SvelteMap<number, number>();
 
     let startId = this.createNodeId();
@@ -558,6 +1082,26 @@ export class GraphManager extends EventEmitter<{
     position: NodeInstance['position'];
     props: NodeInstance['props'];
   }) {
+    if (type === '__virtual/group/instance') {
+      const firstEntry = this.groups.entries().next();
+      if (firstEntry.done) {
+        logger.error('No groups available to create a group node');
+        return;
+      }
+      const [groupId] = firstEntry.value;
+      const groupNodeDef = this.groupNodeDefinitions.get(`__virtual/group/${groupId}`);
+      const node = {
+        id: this.createNodeId(),
+        type: '__virtual/group/instance' as NodeId,
+        position,
+        props: { groupId, ...props },
+        state: { type: groupNodeDef }
+      } as NodeInstance;
+      this.nodes.set(node.id, node);
+      this.save();
+      return node;
+    }
+
     const nodeType = this.registry.getNode(type);
     if (!nodeType) {
       logger.error(`Node type not found: ${type}`);
@@ -588,7 +1132,6 @@ export class GraphManager extends EventEmitter<{
   ): Edge | undefined {
     const existingEdges = this.getEdgesToNode(to);
 
-    // check if this exact edge already exists
     const existingEdge = existingEdges.find(
       (e) => e[0].id === from.id && e[1] === fromSocket && e[3] === toSocket
     );
@@ -597,7 +1140,6 @@ export class GraphManager extends EventEmitter<{
       return;
     }
 
-    // check if socket types match
     const fromSocketType = from.state?.type?.outputs?.[fromSocket];
     const toSocketType = [to.state?.type?.inputs?.[toSocket]?.type];
     if (to.state?.type?.inputs?.[toSocket]?.accepts) {
@@ -665,12 +1207,13 @@ export class GraphManager extends EventEmitter<{
     const state = this.serialize();
     this.history.save(state);
 
-    // This is some stupid race condition where the graph-manager emits a save event
-    // when the graph is not fully loaded
     if (this.nodes.size === 0 && this.edges.length === 0) {
       return;
     }
 
+    // Don't emit save event while navigating inside a group
+    if (this.graphStack.length > 0) return;
+
     this.emit('save', state);
     logger.log('saving graphs', state);
   }
@@ -729,9 +1272,7 @@ export class GraphManager extends EventEmitter<{
 
     const sockets: [NodeInstance, string | number][] = [];
 
-    // if index is a string, we are an input looking for outputs
     if (typeof index === 'string') {
-      // filter out self and child nodes
       const children = new SvelteSet(this.getChildren(node).map((n) => n.id));
       const nodes = this.getAllNodes().filter(
         (n) => n.id !== node.id && !children.has(n.id)
@@ -750,9 +1291,6 @@ export class GraphManager extends EventEmitter<{
         }
       }
     } else if (typeof index === 'number') {
-      // if index is a number, we are an output looking for inputs
-
-      // filter out self and parent nodes
       const parents = new SvelteSet(this.getParentsOfNode(node).map((n) => n.id));
       const nodes = this.getAllNodes().filter(
         (n) => n.id !== node.id && !parents.has(n.id)

app/src/lib/graph-interface/graph-state.svelte.ts

@@ -1,3 +1,4 @@
+import { animate, lerp } from '$lib/helpers';
 import type { NodeInstance, Socket } from '@nodarium/types';
 import { getContext, setContext } from 'svelte';
 import { SvelteMap, SvelteSet } from 'svelte/reactivity';
@@ -98,6 +99,9 @@ export class GraphState {
     edges: [number, number, number, string][];
   } = null;
 
+  // Saved camera position per group so re-entering restores where you left off
+  groupCameras = new Map<string, [number, number, number]>();
+
   cameraBounds = $derived([
     this.cameraPosition[0] - this.width / this.cameraPosition[2] / 2,
     this.cameraPosition[0] + this.width / this.cameraPosition[2] / 2,
@@ -124,6 +128,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(
@@ -236,6 +243,37 @@ export class GraphState {
     };
   }
 
+  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;
 

app/src/lib/graph-interface/graph/Graph.svelte

@@ -19,10 +19,10 @@
 
   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();
@@ -100,6 +100,9 @@
     if (typeof index === 'string') {
       return node.state.type?.inputs?.[index].type || 'unknown';
     }
+    if (node.type === '__virtual/group/instance') {
+      index += 1;
+    }
     return node.state.type?.outputs?.[index] || 'unknown';
   }
 </script>
@@ -172,10 +175,10 @@
       {#if graphState.addMenuPosition}
         <AddMenu
           onnode={handleNodeCreation}
-          paddingTop={addMenuPadding?.top}
+          paddingTop={safePadding?.top}
-          paddingRight={addMenuPadding?.right}
+          paddingRight={safePadding?.right}
-          paddingBottom={addMenuPadding?.bottom}
+          paddingBottom={safePadding?.bottom}
-          paddingLeft={addMenuPadding?.left}
+          paddingLeft={safePadding?.left}
         />
       {/if}
 

app/src/lib/graph-interface/graph/Wrapper.svelte

@@ -18,7 +18,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,7 +27,7 @@
   let {
     graph,
     registry,
-    addMenuPadding,
+    safePadding,
     settings = $bindable(),
     activeNode = $bindable(),
     backgroundType = $bindable('grid'),
@@ -44,29 +44,32 @@
   export const manager = new GraphManager(registry);
   setGraphManager(manager);
 
-  const graphState = new GraphState(manager);
+  export const state = new GraphState(manager);
   $effect(() => {
-    graphState.backgroundType = backgroundType;
+    if (safePadding) {
-    graphState.snapToGrid = snapToGrid;
+      state.safePadding = safePadding;
-    graphState.showHelp = showHelp;
+    }
+    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) {
+    if (state.activeNodeId !== -1) {
-      activeNode = manager.getNode(graphState.activeNodeId);
+      activeNode = manager.getNode(state.activeNodeId);
     } else if (activeNode) {
       activeNode = undefined;
     }
   });
 
   $effect(() => {
-    if (!graphState.addMenuPosition) {
+    if (!state.addMenuPosition) {
-      graphState.edgeEndPosition = null;
+      state.edgeEndPosition = null;
-      graphState.activeSocket = null;
+      state.activeSocket = null;
     }
   });
 
@@ -84,6 +87,95 @@
       manager.load(graph);
     }
   });
+
+  function navigateToBreadcrumb(index: number) {
+    const crumbs = manager.breadcrumbs;
+    const depth = crumbs.length - 1 - index;
+    let restoredCamera: [number, number, number] | false = false;
+    for (let i = 0; i < depth; i++) {
+      const groupId = manager.currentGroupContext;
+      if (groupId) {
+        state.groupCameras.set(groupId, [...state.cameraPosition] as [number, number, number]);
+      }
+      restoredCamera = manager.exitGroup();
+    }
+    state.activeNodeId = -1;
+    state.clearSelection();
+    if (restoredCamera !== false) {
+      state.cameraPosition[0] = restoredCamera[0];
+      state.cameraPosition[1] = restoredCamera[1];
+      state.cameraPosition[2] = restoredCamera[2];
+    } else {
+      state.centerNode();
+    }
+  }
 </script>
 
-<GraphEl {keymap} {addMenuPadding} />
+{#if manager.isInsideGroup}
+  <div class="breadcrumb-bar">
+    {#each manager.breadcrumbs as crumb, i}
+      {#if i > 0}
+        <span class="sep">›</span>
+      {/if}
+      <button
+        class="crumb"
+        class:active={i === manager.breadcrumbs.length - 1}
+        onclick={() => navigateToBreadcrumb(i)}
+      >
+        {crumb.name}
+      </button>
+    {/each}
+  </div>
+{/if}
+
+<GraphEl {keymap} {safePadding} />
+
+<style>
+  .breadcrumb-bar {
+    position: absolute;
+    top: 8px;
+    left: 50%;
+    transform: translateX(-50%);
+    z-index: 100;
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    background: rgba(10, 15, 28, 0.85);
+    border: 1px solid rgba(255, 255, 255, 0.12);
+    border-radius: 6px;
+    padding: 4px 10px;
+    font-size: 12px;
+    pointer-events: all;
+    backdrop-filter: blur(8px);
+  }
+
+  .sep {
+    opacity: 0.4;
+    font-size: 14px;
+  }
+
+  .crumb {
+    background: none;
+    border: none;
+    color: rgba(255, 255, 255, 0.6);
+    cursor: pointer;
+    padding: 2px 4px;
+    border-radius: 4px;
+    font-size: 12px;
+    transition: color 0.15s, background 0.15s;
+  }
+
+  .crumb:hover {
+    color: white;
+    background: rgba(255, 255, 255, 0.08);
+  }
+
+  .crumb.active {
+    color: white;
+    cursor: default;
+  }
+
+  .crumb.active:hover {
+    background: none;
+  }
+</style>

app/src/lib/graph-interface/helpers/nodeHelpers.ts

@@ -3,6 +3,9 @@ import type { NodeDefinition, NodeInstance } from '@nodarium/types';
 export function getParameterHeight(node: NodeDefinition, inputKey: string) {
   const input = node.inputs?.[inputKey];
   if (!input) {
+    if (inputKey.startsWith('__virtual')) {
+      return 50;
+    }
     return 0;
   }
 
@@ -53,7 +56,9 @@ export function getSocketPosition(
 
 const nodeHeightCache: Record<string, number> = {};
 export function getNodeHeight(node: NodeDefinition) {
-  if (node.id in nodeHeightCache) {
+  // Don't cache virtual nodes — their inputs can change dynamically
+  const isVirtual = (node.id as string).startsWith('__virtual/');
+  if (!isVirtual && node.id in nodeHeightCache) {
     return nodeHeightCache[node.id];
   }
   if (!node?.inputs) {
@@ -66,6 +71,8 @@ export function getNodeHeight(node: NodeDefinition) {
     height += h;
   }
 
-  nodeHeightCache[node.id] = height;
+  if (!isVirtual) {
+    nodeHeightCache[node.id] = height;
+  }
   return height;
 }

app/src/lib/graph-interface/keymaps.ts

@@ -1,4 +1,3 @@
-import { animate, lerp } from '$lib/helpers';
 import type { createKeyMap } from '$lib/helpers/createKeyMap';
 import { panelState } from '$lib/sidebar/PanelState.svelte';
 import FileSaver from 'file-saver';
@@ -46,8 +45,26 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
 
   keymap.addShortcut({
     key: 'Escape',
-    description: 'Deselect nodes',
+    description: 'Deselect nodes / Exit group',
     callback: () => {
+      if (graph.isInsideGroup) {
+        const groupId = graph.currentGroupContext;
+        if (groupId) {
+          graphState.groupCameras.set(
+            groupId,
+            [...graphState.cameraPosition] as [number, number, number]
+          );
+        }
+        const savedCamera = graph.exitGroup();
+        if (savedCamera !== false) {
+          graphState.activeNodeId = -1;
+          graphState.clearSelection();
+          graphState.cameraPosition[0] = savedCamera[0];
+          graphState.cameraPosition[1] = savedCamera[1];
+          graphState.cameraPosition[2] = savedCamera[2];
+          return;
+        }
+      }
       graphState.activeNodeId = -1;
       graphState.clearSelection();
       graphState.edgeEndPosition = null;
@@ -67,27 +84,7 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
     description: 'Center camera',
     callback: () => {
       if (!graphState.isBodyFocused()) return;
-
+      graphState.centerNode(graph.getNode(graphState.activeNodeId));
-      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;
-      });
     }
   });
 
@@ -180,4 +177,80 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
       if (!edge) graph.smartConnect(nodes[1], nodes[0]);
     }
   });
+
+  keymap.addShortcut({
+    key: 'g',
+    ctrl: true,
+    preventDefault: true,
+    description: 'Group selected nodes',
+    callback: () => {
+      if (!graphState.isBodyFocused()) return;
+      const nodeIds = Array.from(
+        new Set([
+          ...(graphState.selectedNodes.size > 0 ? graphState.selectedNodes.values() : []),
+          ...(graphState.activeNodeId !== -1 ? [graphState.activeNodeId] : [])
+        ])
+      );
+      if (nodeIds.length === 0) return;
+      const groupNode = graph.createGroup(nodeIds);
+      if (groupNode) {
+        graphState.selectedNodes.clear();
+        graphState.activeNodeId = groupNode.id;
+      }
+    }
+  });
+
+  keymap.addShortcut({
+    key: 'g',
+    alt: true,
+    shift: true,
+    preventDefault: true,
+    description: 'Ungroup selected node',
+    callback: () => {
+      if (!graphState.isBodyFocused()) return;
+      const nodeId = graphState.activeNodeId !== -1
+        ? graphState.activeNodeId
+        : graphState.selectedNodes.size === 1
+        ? [...graphState.selectedNodes.values()][0]
+        : -1;
+      if (nodeId === -1) return;
+      graph.ungroup(nodeId);
+      graphState.activeNodeId = -1;
+      graphState.clearSelection();
+    }
+  });
+
+  keymap.addShortcut({
+    key: 'Tab',
+    preventDefault: true,
+    description: 'Enter focused group node',
+    callback: () => {
+      if (!graphState.isBodyFocused()) return;
+      const entered = graph.enterGroup(
+        graphState.activeNodeId,
+        [...graphState.cameraPosition] as [number, number, number]
+      );
+      if (entered) {
+        graphState.activeNodeId = -1;
+        graphState.clearSelection();
+        // Restore group-specific camera if we've been here before, else snap to center
+        const groupId = graph.currentGroupContext;
+        const saved = groupId ? graphState.groupCameras.get(groupId) : undefined;
+        if (saved) {
+          graphState.cameraPosition[0] = saved[0];
+          graphState.cameraPosition[1] = saved[1];
+          graphState.cameraPosition[2] = saved[2];
+        } else {
+          const nodes = [...graph.nodes.values()];
+          if (nodes.length) {
+            const avgX = nodes.reduce((s, n) => s + n.position[0], 0) / nodes.length;
+            const avgY = nodes.reduce((s, n) => s + n.position[1], 0) / nodes.length;
+            graphState.cameraPosition[0] = avgX;
+            graphState.cameraPosition[1] = avgY;
+            graphState.cameraPosition[2] = 10;
+          }
+        }
+      }
+    }
+  });
 }

app/src/lib/graph-interface/node/NodeHTML.svelte

@@ -1,12 +1,13 @@
 <script lang="ts">
-  import type { NodeInstance } from '@nodarium/types';
+  import type { NodeDefinition, 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 graphState = getGraphState();
+  const manager = getGraphManager();
 
   type Props = {
     node: NodeInstance;
@@ -30,9 +31,37 @@
   const zOffset = Math.random() - 0.5;
   const zLimit = 2 - zOffset;
 
-  const parameters = Object.entries(node.state?.type?.inputs || {}).filter(
+  function buildParameters(node: NodeInstance, inputs: NodeDefinition['inputs']) {
-    (p) => p[1].type !== 'seed' && !('setting' in p[1]) && p[1]?.hidden !== true
+    let parameters = Object.entries(inputs || {}).filter(
-  );
+      (p) => p[1].type !== 'seed' && !('setting' in p[1]) && p[1]?.hidden !== true
+    );
+
+    if (node.type === '__virtual/group/instance') {
+      parameters = [['__virtual/groupId', {
+        type: 'select',
+        value: node.props?.groupId as string,
+        options: [...manager?.groups?.keys()]
+      }], ...parameters];
+    }
+
+    return parameters;
+  }
+
+  const parameters = $derived(buildParameters(node, node?.state?.type?.inputs || {}));
+
+  const currentGroupId = $derived((node.props?.groupId as string) ?? '');
+
+  function onGroupSelect(event: Event) {
+    const select = event.target as HTMLSelectElement;
+    const newGroupId = select.value;
+    if (!manager || newGroupId === currentGroupId) return;
+    const newGroupDef = manager.groupNodeDefinitions.get(`__virtual/group/${newGroupId}`);
+    if (!newGroupDef) return;
+    node.props = { ...(node.props ?? {}), groupId: newGroupId };
+    node.state = { type: newGroupDef };
+    manager.execute();
+    manager.save();
+  }
 
   $effect(() => {
     if ('state' in node && !node.state.ref) {
@@ -55,6 +84,22 @@
 >
   <NodeHeader {node} />
 
+  {#if false && node.type === '__virtual/group/instance'}
+    <div class="group-param">
+      <select
+        value={currentGroupId}
+        onchange={onGroupSelect}
+        onmousedown={(e) => e.stopPropagation()}
+        onclick={(e) => e.stopPropagation()}
+        onkeydown={(e) => e.stopPropagation()}
+      >
+        {#each manager?.groups?.entries() ?? [] as [gid, gdef]}
+          <option value={gid}>{gdef.name}</option>
+        {/each}
+      </select>
+    </div>
+  {/if}
+
   {#each parameters as [key, value], i (key)}
     <NodeParameter
       bind:node
@@ -66,6 +111,24 @@
 </div>
 
 <style>
+  .group-param {
+    padding: 5px 8px;
+    border-bottom: solid 1px var(--color-layer-2);
+    background: var(--color-layer-1);
+  }
+
+  .group-param select {
+    width: 100%;
+    background: var(--color-layer-2);
+    color: var(--color-text);
+    border: 1px solid rgba(255, 255, 255, 0.12);
+    border-radius: 4px;
+    padding: 4px 6px;
+    font-size: 0.8em;
+    cursor: pointer;
+    box-sizing: border-box;
+  }
+
   .node {
     box-sizing: border-box;
     user-select: none !important;

app/src/lib/graph-interface/node/NodeHeader.svelte

@@ -70,7 +70,7 @@
     {#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()}
+    {node.state?.type?.meta?.title ?? node.type.split('/').pop()}
   </div>
   <div
     class="target"

app/src/lib/graph-interface/node/NodeInput.svelte

@@ -45,7 +45,7 @@
 
   $effect(() => {
     const a = $state.snapshot(value);
-    const b = $state.snapshot(node?.props?.[id]);
+    const b = $state.snapshot(node?.props?.[id]) as number | number[] | undefined;
     const isDiff = Array.isArray(a) ? diffArray(a, b) : a !== b;
     if (value !== undefined && isDiff) {
       node.props = { ...node.props, [id]: a };

app/src/lib/graph-interface/node/NodeParameter.svelte

@@ -36,7 +36,7 @@
     });
   }
 
-  const leftBump = $derived(nodeType.inputs?.[id].internal !== true);
+  const leftBump = $derived(!id.startsWith('__virtual') && nodeType.inputs?.[id].internal !== true);
   const cornerBottom = $derived(isLast ? 5 : 0);
   const aspectRatio = 0.5;
 
@@ -83,7 +83,7 @@
 >
   {#key id && graphId}
     <div class="content" class:disabled={graph?.inputSockets?.has(socketId)}>
-      {#if inputType?.label !== ''}
+      {#if inputType?.label !== '' && !id.startsWith('__virtual')}
         <label for={elementId} title={input.description}>{input.label || id}</label>
       {/if}
       {#if inputType?.external !== true}

app/src/lib/graph-templates/index.ts

@@ -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';

app/src/lib/graph-templates/simple.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
       }
     },
     {

app/src/lib/graph-templates/tutorial.json

@@ -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": []
+}

app/src/lib/node-registry/groupNodes.ts

@@ -0,0 +1,25 @@
+import type { NodeDefinition } from '@nodarium/types';
+
+export const groupInputNode: NodeDefinition = {
+  id: '__virtual/group/input',
+  inputs: {},
+  outputs: [],
+  execute(_data: Int32Array): Int32Array { return _data; }
+} as unknown as NodeDefinition;
+
+export const groupOutputNode: NodeDefinition = {
+  id: '__virtual/group/output',
+  inputs: {},
+  outputs: [],
+  execute(_data: Int32Array): Int32Array { return _data; }
+} as unknown as NodeDefinition;
+
+// Stub registered in the registry so it appears in AddMenu.
+// Actual inputs/outputs are resolved from props.groupId at runtime.
+export const groupNode: NodeDefinition = {
+  id: '__virtual/group/instance',
+  meta: { title: 'Group' },
+  inputs: {},
+  outputs: [],
+  execute(_data: Int32Array): Int32Array { return _data; }
+} as unknown as NodeDefinition;

app/src/lib/result-viewer/Viewer.svelte

@@ -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);

app/src/lib/runtime/runtime-executor.ts

@@ -6,6 +6,142 @@ import type {
   RuntimeExecutor,
   SyncCache
 } from '@nodarium/types';
+
+function isGroupInstanceType(type: string): boolean {
+  return type === '__virtual/group/instance';
+}
+
+export function expandGroups(graph: Graph): Graph {
+  if (!graph.groups || Object.keys(graph.groups).length === 0) {
+    return graph;
+  }
+
+  let nodes = [...graph.nodes];
+  let edges = [...graph.edges];
+  const groups = graph.groups;
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (!isGroupInstanceType(node.type)) continue;
+
+      const groupId = (node.props as Record<string, unknown> | undefined)?.groupId as string | undefined;
+      if (!groupId) continue;
+      const group = groups[groupId];
+      if (!group) continue;
+
+      changed = true;
+
+      // Recursively expand nested groups inside this group's internal graph
+      const expandedInternal = expandGroups({
+        id: 0,
+        nodes: group.graph.nodes,
+        edges: group.graph.edges,
+        groups
+      });
+
+      const ID_PREFIX = node.id * 1000000;
+      const idMap = new Map<number, number>();
+
+      const inputVirtualNode = expandedInternal.nodes.find(
+        n => n.type === '__virtual/group/input'
+      );
+      const outputVirtualNode = expandedInternal.nodes.find(
+        n => n.type === '__virtual/group/output'
+      );
+
+      const realInternalNodes = expandedInternal.nodes.filter(
+        n => n.type !== '__virtual/group/input' && n.type !== '__virtual/group/output'
+      );
+
+      for (const n of realInternalNodes) {
+        idMap.set(n.id, ID_PREFIX + n.id);
+      }
+
+      const parentIncomingEdges = edges.filter(e => e[2] === node.id);
+      const parentOutgoingEdges = edges.filter(e => e[0] === node.id);
+
+      // Edges from/to virtual nodes in the expanded internal graph
+      const edgesFromInput = expandedInternal.edges.filter(
+        e => e[0] === inputVirtualNode?.id
+      );
+      const edgesToOutput = expandedInternal.edges.filter(
+        e => e[2] === outputVirtualNode?.id
+      );
+
+      const newEdges: Graph['edges'] = [];
+
+      // Short-circuit: parent source → internal target (via group input)
+      for (const parentEdge of parentIncomingEdges) {
+        const socketName = parentEdge[3];
+        const socketIdx = group.inputs.findIndex(s => s.name === socketName);
+        if (socketIdx === -1) continue;
+
+        for (const internalEdge of edgesFromInput.filter(e => e[1] === socketIdx)) {
+          const remappedId = idMap.get(internalEdge[2]);
+          if (remappedId !== undefined) {
+            newEdges.push([parentEdge[0], parentEdge[1], remappedId, internalEdge[3]]);
+          }
+        }
+      }
+
+      // Short-circuit: internal source → parent target (via group output)
+      for (const parentEdge of parentOutgoingEdges) {
+        const outputIdx = parentEdge[1];
+        const outputSocketName = group.outputs[outputIdx]?.name;
+        if (!outputSocketName) continue;
+
+        for (const internalEdge of edgesToOutput.filter(e => e[3] === outputSocketName)) {
+          const remappedId = idMap.get(internalEdge[0]);
+          if (remappedId !== undefined) {
+            newEdges.push([remappedId, internalEdge[1], parentEdge[2], parentEdge[3]]);
+          }
+        }
+      }
+
+      // Remap internal-to-internal edges
+      const internalEdges = expandedInternal.edges.filter(
+        e => e[0] !== inputVirtualNode?.id
+          && e[0] !== outputVirtualNode?.id
+          && e[2] !== inputVirtualNode?.id
+          && e[2] !== outputVirtualNode?.id
+      );
+
+      for (const e of internalEdges) {
+        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]]);
+        }
+      }
+
+      // Remove the group node
+      nodes.splice(i, 1);
+
+      // Add remapped internal nodes
+      for (const n of realInternalNodes) {
+        nodes.push({ ...n, id: idMap.get(n.id)! });
+      }
+
+      // Remove group node's edges and add short-circuit edges
+      const groupEdgeKeys = new Set([
+        ...parentIncomingEdges.map(e => `${e[0]}-${e[1]}-${e[2]}-${e[3]}`),
+        ...parentOutgoingEdges.map(e => `${e[0]}-${e[1]}-${e[2]}-${e[3]}`)
+      ]);
+      edges = edges.filter(
+        e => !groupEdgeKeys.has(`${e[0]}-${e[1]}-${e[2]}-${e[3]}`)
+      );
+      edges.push(...newEdges);
+
+      break; // Restart loop with updated nodes array
+    }
+  }
+
+  return { ...graph, nodes, edges };
+}
 import {
   concatEncodedArrays,
   createLogger,
@@ -75,7 +211,11 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
       throw new Error('Node registry is not ready');
     }
 
-    await this.registry.load(graph.nodes.map((node) => node.type));
+    // Only load non-virtual types (virtual nodes are resolved locally)
+    const nonVirtualTypes = graph.nodes
+      .map(node => node.type)
+      .filter(t => !t.startsWith('__virtual/'));
+    await this.registry.load(nonVirtualTypes as any);
 
     const typeMap = new Map<string, NodeDefinition>();
     for (const node of graph.nodes) {
@@ -163,6 +303,9 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
     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);
     let b = performance.now();

app/src/lib/runtime/worker-runtime-executor-backend.ts

@@ -1,12 +1,18 @@
 import { debugNode } from '$lib/node-registry/debugNode';
+import { groupInputNode, groupNode, groupOutputNode } from '$lib/node-registry/groupNodes';
 import { IndexDBCache, RemoteNodeRegistry } from '$lib/node-registry/index';
 import type { Graph } from '@nodarium/types';
 import { createPerformanceStore } from '@nodarium/utils';
-import { MemoryRuntimeExecutor } from './runtime-executor';
+import { expandGroups, MemoryRuntimeExecutor } from './runtime-executor';
 import { MemoryRuntimeCache } from './runtime-executor-cache';
 
 const indexDbCache = new IndexDBCache('node-registry');
-const nodeRegistry = new RemoteNodeRegistry('', indexDbCache, [debugNode]);
+const nodeRegistry = new RemoteNodeRegistry('', indexDbCache, [
+  debugNode,
+  groupInputNode,
+  groupOutputNode,
+  groupNode
+]);
 
 const cache = new MemoryRuntimeCache();
 const executor = new MemoryRuntimeExecutor(nodeRegistry, cache);
@@ -34,7 +40,13 @@ export async function executeGraph(
   graph: Graph,
   settings: Record<string, unknown>
 ): Promise<Int32Array> {
-  await nodeRegistry.load(graph.nodes.map((n) => n.type));
+  // Expand groups before loading types so we only load real (non-virtual) node types
+  const expandedGraph = expandGroups(graph);
+  await nodeRegistry.load(
+    expandedGraph.nodes
+      .map(n => n.type)
+      .filter(t => !t.startsWith('__virtual/')) as any
+  );
   performanceStore.startRun();
   const res = await executor.execute(graph, settings);
   performanceStore.stopRun();

app/src/lib/settings/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,7 +126,7 @@
   {@const inputType = type[key]}
   <div class="input input-{inputType.type}" class:first-level={depth === 1}>
     {#if inputType.type === 'button'}
-      <button onclick={handleClick}>
+      <button onclick={() => onButtonClick?.(id)}>
         {inputType.label || key}
       </button>
     {:else}
@@ -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}
@@ -221,6 +219,9 @@
 
   button {
     cursor: pointer;
+    background: var(--color-layer-2);
+    padding-block: 5px;
+    border-radius: 4px;
   }
 
   hr {

app/src/lib/settings/app-settings.svelte.ts

@@ -28,6 +28,10 @@ export const AppSettingTypes = {
     label: 'Center Camera',
     value: true
   },
+  clippy: {
+    type: 'button',
+    label: '🌱 Open Planty'
+  },
   nodeInterface: {
     title: 'Node Interface',
     backgroundType: {
@@ -109,9 +113,8 @@ export const AppSettingTypes = {
   }
 } as const;
 
-type SettingsToStore<T> = T extends { type: 'button' } ? () => void
+type SettingsToStore<T> = T extends { value: infer V } ? V extends readonly string[] ? V[number]
-  : T extends { value: infer V } ? V extends readonly string[] ? V[number]
+  : V
-    : V
   : T extends object ? {
       -readonly [K in keyof T as T[K] extends object ? K : never]: SettingsToStore<T[K]>;
     }

app/src/lib/sidebar/panels/ActiveNodeSelected.svelte

@@ -96,6 +96,4 @@
     bind:value={store}
     type={nodeDefinition}
   />
-{:else}
-  <p class="mx-4 mt-4">Node has no settings</p>
 {/if}

app/src/lib/sidebar/panels/ActiveNodeSettings.svelte

@@ -5,22 +5,27 @@
 
   type Props = {
     manager: GraphManager;
-    node: NodeInstance | undefined;
+    node: NodeInstance;
   };
 
   let { manager, node = $bindable() }: Props = $props();
+
+  const inputs = $derived(node?.state?.type?.inputs || {});
+
+  const hasSettings = $derived(
+    Object.values(inputs).find(entry => {
+      return entry.hidden === true;
+    }) !== undefined
+  );
+
+  $inspect({ inputs, hasSettings });
 </script>
 
-<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'>
+{#key node.id}
-  <h3>Node Settings</h3>
+  {#if node && hasSettings}
-</div>
+    <div class="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>
-{#if node}
+    </div>
-  {#key node.id}
+    <ActiveNodeSelected {manager} bind:node />
-    {#if node}
+  {/if}
-      <ActiveNodeSelected {manager} bind:node />
+{/key}
-    {/if}
-  {/key}
-{:else}
-  <p class="mx-4 mt-4">No node selected</p>
-{/if}

app/src/lib/sidebar/panels/GroupContextPanel.svelte

@@ -0,0 +1,148 @@
+<script lang="ts">
+  import type { GraphManager } from '$lib/graph-interface/graph-manager.svelte';
+  import { InputSelect } from '@nodarium/ui';
+
+  type Props = { manager: GraphManager; groupId: string };
+  const { manager, groupId }: Props = $props();
+
+  $inspect({ groupId });
+
+  const group = $derived(manager.groups.get(groupId));
+
+  const COMMON_TYPES = ['plant', 'float', 'int', 'vec3', 'bool'];
+  let selectedTypeIdx = $state(0);
+  let customType = $state('');
+
+  function rename(e: Event) {
+    if (!group) return;
+    const name = (e.target as HTMLInputElement).value.trim();
+    if (!name) return;
+    group.name = name;
+    if (manager.graph.groups?.[groupId]) manager.graph.groups[groupId].name = name;
+    const def = manager.groupNodeDefinitions.get(`__virtual/group/${groupId}`);
+    if (def?.meta) def.meta.title = name;
+    manager.save();
+  }
+
+  function addSocket() {
+    const type = customType.trim() || COMMON_TYPES[selectedTypeIdx];
+    if (!type) return;
+    manager.addGroupSocket('input', type);
+    customType = '';
+  }
+
+  function removeSocket(index: number) {
+    manager.removeGroupSocket('input', index);
+  }
+</script>
+
+<div class="bg-layer-2 flex items-center h-[70px] border-b-1 border-outline pl-4">
+  <h3>Group Settings</h3>
+</div>
+
+<div class="px-4 py-3 flex flex-col gap-4">
+  <div class="flex flex-col gap-1.5">
+    <span class="section-label">Group name</span>
+    <input
+      type="text"
+      value={group?.name ?? ''}
+      onchange={rename}
+      onkeydown={(e) => e.stopPropagation()}
+      placeholder="Group name"
+      class="bg-layer-2 text-text rounded-[5px] px-2 py-1.5 text-sm w-full box-border outline outline-1 outline-outline"
+    />
+  </div>
+
+  <div class="flex flex-col gap-1.5">
+    <span class="section-label">Inputs</span>
+
+    {#if (group?.inputs?.length ?? 0) === 0}
+      <p class="text-sm opacity-40 italic m-0">No inputs yet</p>
+    {:else}
+      <ul class="socket-list">
+        {#each group?.inputs ?? [] as socket, i}
+          <li class="socket-item">
+            <span class="flex-1 opacity-80 text-sm">{socket.name}</span>
+            <span class="text-xs opacity-45 italic">{socket.type}</span>
+            <button class="remove-btn" onclick={() => removeSocket(i)} title="Remove">×</button>
+          </li>
+        {/each}
+      </ul>
+    {/if}
+
+    <div class="flex gap-1.5 items-center">
+      <InputSelect options={COMMON_TYPES} bind:value={selectedTypeIdx} />
+      <input
+        type="text"
+        placeholder="custom type…"
+        bind:value={customType}
+        onkeydown={(e) => {
+          e.stopPropagation();
+          if (e.key === 'Enter') addSocket();
+        }}
+        class="bg-layer-2 text-text rounded-[5px] px-2 py-1 text-sm flex-1 min-w-0 outline outline-1 outline-outline"
+      />
+      <button class="add-btn" onclick={addSocket}>+ Add</button>
+    </div>
+  </div>
+</div>
+
+<style>
+  .section-label {
+    font-size: 0.72em;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    opacity: 0.5;
+  }
+
+  .socket-list {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 3px;
+  }
+
+  .socket-item {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    background: var(--color-layer-2);
+    border-radius: 5px;
+    padding: 4px 8px;
+    outline: 1px solid var(--color-outline);
+  }
+
+  .remove-btn {
+    background: none;
+    border: none;
+    color: var(--color-text);
+    cursor: pointer;
+    opacity: 0.4;
+    padding: 0 2px;
+    font-size: 1.1em;
+    line-height: 1;
+  }
+
+  .remove-btn:hover {
+    opacity: 1;
+  }
+
+  .add-btn {
+    background: var(--color-layer-2);
+    color: var(--color-text);
+    border: none;
+    outline: 1px solid var(--color-outline);
+    border-radius: 5px;
+    padding: 0.4em 0.7em;
+    font-size: 0.8em;
+    cursor: pointer;
+    white-space: nowrap;
+    font-family: var(--font-family);
+  }
+
+  .add-btn:hover {
+    outline-color: var(--color-selected);
+  }
+</style>

app/src/lib/tutorial/tutorial-config.ts

@@ -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 }
+      ]
+    }
+  }
+};

app/src/routes/+page.svelte

@@ -5,6 +5,7 @@
   import { debounceAsyncFunction } from '$lib/helpers';
   import { createKeyMap } from '$lib/helpers/createKeyMap';
   import { debugNode } from '$lib/node-registry/debugNode.js';
+  import { groupInputNode, groupNode, groupOutputNode } from '$lib/node-registry/groupNodes.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,29 @@
   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 GroupContextPanel from '$lib/sidebar/panels/GroupContextPanel.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 { 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,
+    groupInputNode,
+    groupOutputNode,
+    groupNode
+  ]);
   const workerRuntime = new WorkerRuntimeExecutor();
   const runtimeCache = new MemoryRuntimeCache();
   const memoryRuntime = new MemoryRuntimeExecutor(nodeRegistry, runtimeCache);
@@ -130,35 +140,113 @@
 
   const handleUpdate = debounceAsyncFunction(update);
 
-  onMount(() => {
+  function handleSettingsButton(id: string) {
-    appSettings.value.debug.stressTest = {
+    switch (id) {
-      ...appSettings.value.debug.stressTest,
+      case 'general.clippy':
-      loadGrid: () => {
+        planty?.start();
+        break;
+      case 'general.debug.stressTest.loadGrid':
         manager.load(
           templates.grid(
             appSettings.value.debug.stressTest.amount,
             appSettings.value.debug.stressTest.amount
           )
         );
-      },
+        break;
-      loadTree: () => {
+      case 'general.debug.stressTest.loadTree':
         manager.load(templates.tree(appSettings.value.debug.stressTest.amount));
-      },
+        break;
-      lottaFaces: () => {
+      case 'general.debug.stressTest.lottaFaces':
         manager.load(templates.lottaFaces as unknown as Graph);
-      },
+        break;
-      lottaNodes: () => {
+      case 'general.debug.stressTest.lottaNodes':
         manager.load(templates.lottaNodes as unknown as Graph);
-      },
+        break;
-      lottaNodesAndFaces: () => {
+      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': () => {
+      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': () => {
+      if (!pm.graph) return;
+      const g = structuredClone(templates.tutorial) as unknown as Graph;
+      g.id = pm.graph.id;
+      g.meta = { ...pm.graph.meta };
+      pm.graph = g;
+      pm.saveGraph(g);
+      graphInterface.state.centerNode(graphInterface.manager.getAllNodes()[0]);
+    },
+    '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>
@@ -177,7 +265,7 @@
           graph={pm.graph}
           bind:this={graphInterface}
           registry={nodeRegistry}
-          addMenuPadding={{ right: sidebarOpen ? 330 : undefined }}
+          safePadding={{ right: sidebarOpen ? 330 : undefined }}
           backgroundType={appSettings.value.nodeInterface.backgroundType}
           snapToGrid={appSettings.value.nodeInterface.snapToGrid}
           bind:activeNode
@@ -192,6 +280,7 @@
         <Panel id="general" title="General" icon="i-[tabler--settings]">
           <NestedSettings
             id="general"
+            onButtonClick={handleSettingsButton}
             bind:value={appSettings.value}
             type={AppSettingTypes}
           />
@@ -211,13 +300,15 @@
         <Panel id="exports" title="Exporter" icon="i-[tabler--package-export]">
           <ExportSettings {scene} />
         </Panel>
-        <Panel
+        {#if 0 > 1}
-          id="node-store"
+          <Panel
-          title="Node Store"
+            id="node-store"
-          icon="i-[tabler--database] bg-green-400"
+            title="Node Store"
-        >
+            icon="i-[tabler--database] bg-green-400"
-          <NodeStore registry={nodeRegistry} />
+          >
-        </Panel>
+            <NodeStore registry={nodeRegistry} />
+          </Panel>
+        {/if}
         <Panel
           id="performance"
           title="Performance"
@@ -257,7 +348,20 @@
             type={graphSettingTypes}
             bind:value={graphSettings}
           />
-          <ActiveNodeSettings {manager} bind:node={activeNode} />
+          {#if activeNode?.id}
+            <ActiveNodeSettings {manager} bind:node={activeNode} />
+          {/if}
+          {#if manager?.isInsideGroup}
+            <GroupContextPanel
+              {manager}
+              groupId={manager.currentGroupContext!}
+            />
+          {:else if activeNode?.type === '__virtual/group/instance'}
+            <GroupContextPanel
+              {manager}
+              groupId={activeNode?.props?.groupId as string}
+            />
+          {/if}
         </Panel>
         <Panel
           id="changelog"
@@ -274,6 +378,25 @@
 <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 {

app/vite.config.ts

@@ -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']
   },

docs/LLM.md

@@ -0,0 +1,312 @@
+# Nodarium - LLM Documentation
+
+## Overview
+
+Nodarium is a **WebAssembly-based visual programming language** for creating procedural 3D plants. The app features a node-based interface where users connect WASM modules to generate plant models in real-time. Currently used to develop https://nodes.max-richter.dev, a procedural modelling tool for 3D plants.
+
+## Architecture
+
+### Core Components
+
+#### 1. Node System (`app/static/nodes/`)
+
+WASM-based nodes that perform computations. All nodes must implement the NodeDefinition interface.
+
+- **Node Storage**: `app/static/nodes/max/plantarium/`
+  - `box.wasm` - Box geometry node
+  - `branch.wasm` - Branch generation
+  - `float.wasm` - Float value node
+  - `gravity.wasm` - Gravity/physics node
+  - `instance.wasm` - Instance rendering
+  - `leaf.wasm` - Leaf geometry
+  - `math.wasm` - Math operations
+  - `noise.wasm` - Noise generation
+  - `output.wasm` - Output node
+  - `random.wasm` - Random value generation
+  - `rotate.wasm` - Rotation node
+  - `shape.wasm` - Shape geometry
+  - `stem.wasm` - Stem generation
+  - `triangle.wasm` - Triangle geometry
+  - `vec3.wasm` - Vector3 node
+
+- **Node Registry**: `app/src/lib/node-registry.ts`
+  - Loads and manages WASM nodes
+  - `getNodeWasm()` - Creates WASM wrapper from bytes
+  - `getNode()` - Retrieves node definition
+
+- **Debug Node**: `app/src/lib/node-registry/debugNode.js`
+  - Special debug node with wildcard inputs
+  - Variable-height nodes and parameters
+  - Quick-connect shortcut
+
+#### 2. Graph Interface
+
+Visual node editor built with Svelte 5.
+
+- **Main Wrapper**: `app/src/lib/graph-interface/graph/Wrapper.svelte`
+  - Entry point for graph interface
+  - Manages GraphManager and GraphState
+
+- **GraphManager**: `app/src/lib/graph-interface/graph-manager.svelte.ts`
+  - Core entity managing the node graph
+  - Handles node connections and execution flow
+
+- **GraphState**: `app/src/lib/graph-interface/graph-state.svelte.ts`
+  - Tracks UI state (selection, snapping, help, active nodes)
+
+- **Graph Components**:
+  - `app/src/lib/graph-interface/graph/` - Graph rendering
+  - `app/src/lib/graph-interface/node/` - Node rendering
+  - `app/src/lib/graph-interface/edges/` - Edge rendering
+  - `app/src/lib/graph-interface/components/` - UI components (AddMenu, Socket, etc.)
+  - `app/src/lib/graph-interface/debug/` - Debug overlays
+  - `app/src/lib/graph-interface/background/` - Grid/dots backgrounds
+
+- **Helpers**:
+  - `app/src/lib/helpers/` - Utility functions
+  - `app/src/lib/helpers/createKeyMap.ts` - Keyboard shortcuts
+
+#### 3. Runtime Execution
+
+Performs graph execution via WASM nodes.
+
+- **Runtime Executors** (`app/src/lib/runtime/`):
+  - **MemoryRuntime**: Direct WASM execution in main thread
+  - **WorkerRuntime**: WebWorker-based execution for performance
+  - Both implement the RuntimeExecutor interface
+
+- **Runtime Cache**: `app/src/lib/runtime/cache.ts`
+  - Memory-based caching for graph execution
+
+- **Execution Flow**:
+  1. Graph serialized from graph interface
+  2. Runtime executes nodes in topological order
+  3. Results passed through connected edges
+  4. Final mesh output rendered
+
+#### 4. 3D Viewer (`app/src/lib/result-viewer/`)
+
+Three.js-based rendering for 3D output.
+
+- **Viewer**: `app/src/lib/result-viewer/Viewer.svelte`
+  - Renders generated 3D meshes
+  - Uses @threlte/core (Svelte-Three.js wrapper)
+
+#### 5. Application Structure (`app/src/routes/`)
+
+SvelteKit application routing.
+
+- **Main Page**: `app/src/routes/+page.svelte`
+  - Combines GraphInterface + 3D Viewer
+  - Manages runtime selection (memory vs worker)
+  - Handles settings and performance tracking
+
+- **Layout**: `app/src/routes/+layout.svelte`
+  - Application shell
+
+- **Server**: `app/src/routes/+layout.server.ts`
+  - Loads git metadata and changelog
+
+#### 6. Settings System (`app/src/lib/settings/`)
+
+Application and graph settings.
+
+- **App Settings**: `app/src/lib/settings/app-settings.svelte.ts`
+  - Debug mode, themes, node interface options
+
+- **NestedSettings**: `app/src/lib/settings/NestedSettings.svelte`
+  - Recursive settings UI component
+
+#### 7. Sidebar Panels (`app/src/lib/sidebar/`)
+
+- `app/src/lib/sidebar/Sidebar.svelte` - Main sidebar
+- `app/src/lib/sidebar/panels/` - Individual panels:
+  - `ActiveNodeSettings.svelte` - Selected node properties
+  - `BenchmarkPanel.svelte` - Performance benchmarking
+  - `Changelog.svelte` - Version history
+  - `ExportSettings.svelte` - Export options
+  - `GraphSource.svelte` - Graph JSON view
+  - `Keymap.svelte` - Keyboard shortcuts
+
+#### 8. Project Management (`app/src/lib/project-manager/`)
+
+- `app/src/lib/project-manager/project-manager.svelte` - Project save/load
+- Uses IndexedDB for persistence
+
+#### 9. Node Store (`app/src/lib/node-store/`)
+
+- `app/src/lib/node-store/NodeStore.svelte`
+- Remote node registry management
+- IndexDBCache for offline storage
+
+#### 10. Graph Templates (`app/src/lib/graph-templates/`)
+
+Pre-built graph templates for testing:
+
+- Grid, Tree, LottaFaces, LottaNodes, LottaNodesAndFaces
+
+## Key Types (`app/src/lib/types.ts`)
+
+```typescript
+interface NodeDefinition {
+  id: string;
+  name: string;
+  inputs: Socket[];
+  outputs: Socket[];
+  parameters: Parameter[];
+  execute: (inputs: any[], parameters: any[]) => any[];
+}
+
+interface Socket {
+  id: string;
+  name: string;
+  type: string; // datatype (e.g., "number", "vec3", "*")
+  defaultValue?: any;
+  optional?: boolean;
+}
+
+interface Parameter {
+  id: string;
+  name: string;
+  type: string;
+  defaultValue: any;
+  min?: number;
+  max?: number;
+  options?: string[];
+}
+
+interface Graph {
+  nodes: NodeInstance[];
+  edges: Edge[];
+}
+
+interface NodeInstance {
+  id: number;
+  nodeId: string;
+  position: { x: number; y: number };
+  parameters: Record<string, any>;
+}
+
+interface Edge {
+  id: number;
+  fromNode: number;
+  fromSocket: string;
+  toNode: number;
+  toSocket: string;
+}
+```
+
+## Development Workflow
+
+### Prerequisites
+
+- Node.js
+- pnpm
+- Rust
+- wasm-pack
+
+### Build Commands
+
+```bash
+# Install dependencies
+pnpm i
+
+# Build WASM nodes
+pnpm build:nodes
+
+# Start development server
+cd app && pnpm dev
+
+# Run tests
+cd app && pnpm test
+
+# Lint and typecheck
+cd app && pnpm lint
+cd app && pnpm check
+
+# Format code
+cd app && pnpm format
+```
+
+### Creating New Nodes
+
+See `docs/DEVELOPING_NODES.md` for detailed instructions on creating custom WASM nodes.
+
+## Features
+
+### Current Features
+
+- Visual node-based programming with real-time 3D preview
+- WebAssembly nodes for high-performance computation
+- Debug node with wildcard inputs and runtime integration
+- Color-coded node sockets and edges (indicating data types)
+- Variable-height nodes and parameters
+- Edge dragging with valid socket highlighting
+- InputNumber snapping to predefined values (Alt+click)
+- Project save/load with IndexedDB
+- Performance monitoring and benchmarking
+- Changelog viewer
+- Advanced mode settings
+
+### UI Components
+
+- **InputNumber**: Numeric input with arrow controls
+- **InputColor**: Color picker
+- **InputShape**: Shape selector with preview
+- **InputSelect**: Dropdown with options
+
+## File Structure
+
+```
+nodarium/
+├── app/
+│   ├── src/
+│   │   ├── lib/
+│   │   │   ├── config.ts
+│   │   │   ├── graph-interface/    # Node editor
+│   │   │   ├── graph-manager.svelte.ts
+│   │   │   ├── graph-state.svelte.ts
+│   │   │   ├── graph-templates/   # Test templates
+│   │   │   ├── grid/
+│   │   │   ├── helpers/
+│   │   │   ├── node-registry.ts
+│   │   │   ├── node-registry/     # Node loading
+│   │   │   ├── node-store/
+│   │   │   ├── performance/
+│   │   │   ├── project-manager/
+│   │   │   ├── result-viewer/       # 3D viewer
+│   │   │   ├── runtime/           # Execution
+│   │   │   ├── settings/         # App settings
+│   │   │   ├── sidebar/
+│   │   │   └── types.ts
+│   │   └── routes/
+│   │       ├── +page.svelte
+│   │       └── +layout.svelte
+│   ├── static/
+│   │   └── nodes/
+│   │       └── max/
+│   │           └── plantarium/    # WASM nodes
+│   └── package.json
+├── docs/
+│   ├── ARCHITECTURE.md
+│   ├── DEVELOPING_NODES.md
+│   ├── NODE_DEFINITION.md
+│   └── PLANTARIUM.md
+├── nodes/                        # WASM node source (Rust)
+└── package.json
+```
+
+## Release Process
+
+1. Create annotated tag:
+   ```bash
+   git tag -a v1.0.0 -m "Release notes"
+   git push origin v1.0.0
+   ```
+
+2. CI workflow:
+   - Runs lint, format check, type check
+   - Builds project
+   - Updates package.json versions
+   - Generates CHANGELOG.md
+   - Creates Gitea release

nodes/max/plantarium/noise/src/input.json

@@ -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",

nodes/max/plantarium/random/src/definition.json

@@ -6,7 +6,7 @@
   "inputs": {
     "min": {
       "type": "float",
-      "value": 2
+      "value": 1
     },
     "max": {
       "type": "float",

package.json

@@ -1,7 +1,7 @@
 {
   "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",
@@ -9,7 +9,7 @@
     "test": "pnpm run -r --parallel test",
     "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",

packages/planty/.gitignore

@@ -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-*

packages/planty/README.md

@@ -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
+```

packages/planty/eslint.config.js

@@ -0,0 +1,44 @@
+import { includeIgnoreFile } from '@eslint/compat';
+import js from '@eslint/js';
+import prettier from 'eslint-config-prettier';
+import svelte from 'eslint-plugin-svelte';
+import { defineConfig } from 'eslint/config';
+import globals from 'globals';
+import path from 'node:path';
+import ts from 'typescript-eslint';
+import svelteConfig from './svelte.config.js';
+
+const gitignorePath = path.resolve(import.meta.dirname, '.gitignore');
+
+export default defineConfig(
+  includeIgnoreFile(gitignorePath),
+  js.configs.recommended,
+  ts.configs.recommended,
+  svelte.configs.recommended,
+  prettier,
+  svelte.configs.prettier,
+  {
+    languageOptions: { globals: { ...globals.browser, ...globals.node } },
+    rules: {
+      // typescript-eslint strongly recommend that you do not use the no-undef lint rule on TypeScript projects.
+      // see: https://typescript-eslint.io/troubleshooting/faqs/eslint/#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors
+      'no-undef': 'off'
+    }
+  },
+  {
+    files: ['**/*.svelte', '**/*.svelte.ts', '**/*.svelte.js'],
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        extraFileExtensions: ['.svelte'],
+        parser: ts.parser,
+        svelteConfig
+      }
+    }
+  },
+  {
+    // Override or add rule settings here, such as:
+    // 'svelte/button-has-type': 'error'
+    rules: {}
+  }
+);

packages/planty/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@nodarium/planty",
+  "version": "0.0.1",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build",
+    "preview": "vite preview",
+    "prepare": "svelte-kit sync || echo ''",
+    "prepack": "svelte-kit sync && svelte-package && publint",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "lint": "eslint .",
+    "format": "dprint fmt -c '../.dprint.jsonc' .",
+    "format:check": "dprint check -c '../.dprint.jsonc' ."
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "svelte": "./src/lib/index.ts",
+  "types": "./src/lib/index.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/lib/index.ts",
+      "svelte": "./src/lib/index.ts"
+    }
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "devDependencies": {
+    "@nodarium/ui": "workspace:*",
+    "@eslint/compat": "^2.0.4",
+    "@eslint/js": "^10.0.1",
+    "@sveltejs/adapter-auto": "^7.0.1",
+    "@sveltejs/kit": "^2.57.0",
+    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "@tailwindcss/vite": "^4.2.2",
+    "@types/node": "^24",
+    "eslint": "^10.2.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-svelte": "^3.17.0",
+    "globals": "^17.4.0",
+    "prettier": "^3.8.1",
+    "prettier-plugin-svelte": "^3.5.1",
+    "prettier-plugin-tailwindcss": "^0.7.2",
+    "publint": "^0.3.18",
+    "svelte": "^5.55.2",
+    "svelte-check": "^4.4.6",
+    "tailwindcss": "^4.2.2",
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.1",
+    "vite": "^8.0.7"
+  },
+  "keywords": [
+    "svelte"
+  ]
+}

packages/planty/src/app.d.ts

@@ -0,0 +1,13 @@
+// See https://svelte.dev/docs/kit/types#app.d.ts
+// for information about these interfaces
+declare global {
+  namespace App {
+    // interface Error {}
+    // interface Locals {}
+    // interface PageData {}
+    // interface PageState {}
+    // interface Platform {}
+  }
+}
+
+export {};

packages/planty/src/app.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en" class="theme-dark">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" href="%sveltekit.assets%/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="text-scale" content="scale" />
+    %sveltekit.head%
+  </head>
+  <body data-sveltekit-preload-data="hover">
+    <div style="display: contents">%sveltekit.body%</div>
+  </body>
+</html>

packages/planty/src/lib/components/Highlight.svelte

@@ -0,0 +1,111 @@
+<script lang="ts">
+  import type { PlantyHook } from '../types.js';
+
+  interface Props {
+    selector?: string;
+    hookName?: string;
+    hooks?: Record<string, PlantyHook>;
+  }
+
+  let { selector, hookName, hooks = {} }: Props = $props();
+
+  let rect = $state<{ top: number; left: number; width: number; height: number } | null>(null);
+
+  $effect(() => {
+    let el: Element | null = null;
+    let ro: ResizeObserver | null = null;
+    let mo: MutationObserver | null = null;
+
+    function resolveEl(): Element | null {
+      if (selector) return document.querySelector(selector);
+      if (hookName && hooks[hookName]) {
+        const result = hooks[hookName]();
+        if (result instanceof Element) return result;
+      }
+      return null;
+    }
+
+    function updateRect() {
+      if (!el) {
+        rect = null;
+        return;
+      }
+      const raw = el.getBoundingClientRect();
+      const vw = window.innerWidth;
+      const vh = window.innerHeight;
+      const p = 4;
+      const top = Math.max(p, raw.top - p);
+      const left = Math.max(p, raw.left - p);
+      const right = Math.min(vw - p, raw.right + p);
+      const bottom = Math.min(vh - p, raw.bottom + p);
+      if (right <= left || bottom <= top) {
+        rect = null;
+        return;
+      }
+      rect = { top, left, width: right - left, height: bottom - top };
+    }
+
+    function attachEl(newEl: Element | null) {
+      if (newEl === el) return;
+      ro?.disconnect();
+      el = newEl;
+      if (!el) {
+        rect = null;
+        return;
+      }
+      updateRect();
+      ro = new ResizeObserver(updateRect);
+      ro.observe(el);
+    }
+
+    attachEl(resolveEl());
+
+    window.addEventListener('scroll', updateRect, { passive: true, capture: true });
+    window.addEventListener('resize', updateRect, { passive: true });
+
+    // For hook-based highlights, watch the DOM so we catch dynamically added elements
+    if (hookName) {
+      mo = new MutationObserver(() => attachEl(resolveEl()));
+      mo.observe(document.body, { childList: true, subtree: true });
+    }
+
+    return () => {
+      ro?.disconnect();
+      mo?.disconnect();
+      window.removeEventListener('scroll', updateRect, true);
+      window.removeEventListener('resize', updateRect);
+    };
+  });
+</script>
+
+{#if rect}
+  <div
+    class="highlight pointer-events-none fixed z-99999 rounded-md"
+    style:top="{rect.top}px"
+    style:left="{rect.left}px"
+    style:width="{rect.width}px"
+    style:height="{rect.height}px"
+  >
+  </div>
+{/if}
+
+<style>
+  @keyframes pulse {
+  	0%,
+  	100% {
+  		box-shadow:
+  			0 0 0 9999px rgba(0, 0, 0, 0.45),
+  			0 0 0 2px rgba(255, 255, 255, 0.9),
+  			0 0 16px rgba(255, 255, 255, 0.3);
+  	}
+  	50% {
+  		box-shadow:
+  			0 0 0 9999px rgba(0, 0, 0, 0.45),
+  			0 0 0 2px rgba(255, 255, 255, 1),
+  			0 0 28px rgba(255, 255, 255, 0.6);
+  	}
+  }
+  .highlight {
+  	animation: pulse 1.8s ease-in-out infinite;
+  }
+</style>

packages/planty/src/lib/components/Planty.svelte

@@ -0,0 +1,221 @@
+<script lang="ts">
+  import { DialogRunner } from '../dialog-runner.js';
+  import type { AvatarPosition, DialogNode, PlantyConfig, PlantyHook } from '../types.js';
+  import Highlight from './Highlight.svelte';
+  import PlantyAvatar from './PlantyAvatar.svelte';
+  import type { Mood } from './PlantyAvatar.svelte';
+  import SpeechBubble from './SpeechBubble.svelte';
+
+  interface Props {
+    config: PlantyConfig;
+    hooks?: Record<string, PlantyHook>;
+    actions?: Record<string, PlantyHook>;
+    onStepChange?: (nodeId: string, node: DialogNode) => void;
+    onComplete?: () => void;
+  }
+
+  let { config, actions = {}, hooks = {}, onStepChange, onComplete }: Props = $props();
+
+  const AVATAR_SIZE = 80;
+  const SCREEN_PADDING = 20;
+
+  // ── State ────────────────────────────────────────────────────────────
+  let isActive = $state(false);
+  let currentNodeId = $state<string | null>(null);
+  let bubbleVisible = $state(false);
+  let avatar = $state<PlantyAvatar>(null!);
+  let avatarX = $state(0);
+  let avatarY = $state(0);
+  let mood = $state<Mood>('idle');
+  let autoAdvanceTimer: ReturnType<typeof setTimeout> | null = null;
+  let actionCleanup: (() => void) | null = null;
+
+  // ── Derived ──────────────────────────────────────────────────────────
+  const runner = $derived(new DialogRunner(config));
+  const nextNode = $derived(
+    runner.getNextNode(currentNodeId ?? '')
+  );
+  const mainPath = $derived(runner.getMainPath());
+  const currentNode = $derived<DialogNode | null>(
+    currentNodeId ? runner.getNode(currentNodeId) : null
+  );
+  const showBubble = $derived(
+    isActive && bubbleVisible && currentNode !== null && !!currentNode.text
+  );
+  const highlight = $derived(currentNode?.highlight ?? null);
+  const stepIndex = $derived(currentNodeId ? mainPath.indexOf(currentNodeId) : -1);
+  const totalSteps = $derived(mainPath.length);
+
+  // ── Position helpers ─────────────────────────────────────────────────
+  function anchorToCoords(anchor: string): { x: number; y: number } {
+    const w = window.innerWidth;
+    const h = window.innerHeight;
+    switch (anchor) {
+      case 'top-left':
+        return { x: SCREEN_PADDING, y: SCREEN_PADDING };
+      case 'top-right':
+        return { x: w - AVATAR_SIZE - SCREEN_PADDING, y: SCREEN_PADDING };
+      case 'bottom-left':
+        return { x: SCREEN_PADDING, y: h - AVATAR_SIZE - SCREEN_PADDING };
+      case 'center':
+        return { x: (w - AVATAR_SIZE) / 2, y: (h - AVATAR_SIZE) / 2 };
+      case 'right':
+        return { x: w - AVATAR_SIZE - SCREEN_PADDING, y: (h - AVATAR_SIZE) / 2 };
+      case 'bottom-right':
+      default:
+        return { x: w - AVATAR_SIZE - SCREEN_PADDING, y: h - AVATAR_SIZE - SCREEN_PADDING };
+    }
+  }
+
+  function resolvePosition(pos: AvatarPosition): { x: number; y: number } {
+    return typeof pos === 'string' ? anchorToCoords(pos) : pos;
+  }
+
+  // ── Public API (exposed via bind:this) ───────────────────────────────
+  export function start() {
+    const defaultPos = config.avatar?.defaultPosition ?? 'bottom-right';
+    const pos = resolvePosition(defaultPos);
+    avatarX = pos.x;
+    avatarY = pos.y;
+    isActive = true;
+
+    const start = runner.getStartNode();
+    if (start) _enterNode(start.id, start.node);
+  }
+
+  export function stop() {
+    _clearAutoAdvance();
+    isActive = false;
+    bubbleVisible = false;
+    currentNodeId = null;
+    mood = 'idle';
+    onComplete?.();
+  }
+
+  export async function next() {
+    if (!currentNodeId) return;
+    await _runAfter(currentNodeId, currentNode);
+    const next = runner.getNextNode(currentNodeId);
+    if (next) _enterNode(next.id, next.node);
+    else stop();
+  }
+
+  export function registerHook(name: string, fn: PlantyHook) {
+    hooks = { ...hooks, [name]: fn };
+  }
+
+  // ── Internal ─────────────────────────────────────────────────────────
+
+  async function _runAfter(nodeId: string, node: DialogNode | null) {
+    if (!node) return;
+    if (actionCleanup) {
+      actionCleanup();
+      actionCleanup = null;
+    }
+    await node.after?.(nodeId, node);
+    await hooks[`after:${nodeId}`]?.(nodeId, node);
+  }
+
+  async function _enterNode(id: string, node: DialogNode) {
+    _clearAutoAdvance();
+    bubbleVisible = false;
+    currentNodeId = id;
+    onStepChange?.(id, node);
+
+    // Before hooks — run before movement starts
+    await node.before?.(id, node);
+    await hooks[`before:${id}`]?.(id, node);
+
+    // Fly to position first, then talk
+    if (node.position) {
+      mood = 'moving';
+      const pos = resolvePosition(node.position);
+      const hasChanges = pos.x !== avatarX || pos.y !== avatarY;
+      avatarX = pos.x;
+      avatarY = pos.y;
+      if (hasChanges) await _wait(900);
+    }
+
+    mood = 'talking';
+    bubbleVisible = true;
+
+    // App hook
+    if (node.action && actions[node.action]) {
+      const result = await actions[node.action]();
+      if (typeof result === 'function') actionCleanup = result as () => void;
+    }
+
+    const actionHook = hooks[`action:${id}`];
+    if (actionHook) {
+      const advance = () => {
+        avatar.flash('happy', 2000);
+        next();
+      };
+      const result = await actionHook(advance);
+      if (typeof result === 'function') actionCleanup = result as () => void;
+    }
+
+    if (!node.choices && !node.next) {
+      setTimeout(() => stop(), 3000);
+    }
+
+    // Stay in talking mood until the typewriter finishes (26 ms/char + buffer)
+    const talkMs = (node.text?.length ?? 0) * 26 + 200;
+    setTimeout(() => {
+      mood = 'idle';
+    }, talkMs);
+  }
+
+  function _wait(ms: number) {
+    return new Promise<void>((r) => setTimeout(r, ms));
+  }
+
+  function _clearAutoAdvance() {
+    if (autoAdvanceTimer !== null) {
+      clearTimeout(autoAdvanceTimer);
+      autoAdvanceTimer = null;
+    }
+  }
+</script>
+
+{#if isActive}
+  <div class="pointer-events-none fixed inset-0 z-99999">
+    {#if highlight}
+      <Highlight selector={highlight.selector} hookName={highlight.hookName} {hooks} />
+    {/if}
+
+    <PlantyAvatar bind:this={avatar} bind:x={avatarX} bind:y={avatarY} {mood} />
+
+    {#if showBubble && currentNode}
+      <SpeechBubble
+        text={currentNode.text ?? ''}
+        {avatarX}
+        {avatarY}
+        choices={currentNode.choices || []}
+        showNext={nextNode !== null}
+        {stepIndex}
+        {totalSteps}
+        onNext={next}
+        onClose={stop}
+        onChoose={async (choice) => {
+          await _runAfter(currentNodeId!, currentNode);
+          if (choice && choice.action) {
+            if (choice.action in actions) {
+              actions[choice.action]();
+            } else {
+              console.warn(`Planty: No action found for ${choice.action}`);
+            }
+            return;
+          }
+          if (!choice.next) {
+            stop();
+            return;
+          }
+          const n = runner.followChoice(choice);
+          if (n) _enterNode(n.id, n.node);
+          else stop();
+        }}
+      />
+    {/if}
+  </div>
+{/if}

packages/planty/src/lib/components/PlantyAvatar.svelte

@@ -0,0 +1,435 @@
+<script lang="ts">
+  import { scale } from 'svelte/transition';
+  export type Mood = 'idle' | 'talking' | 'happy' | 'thinking' | 'moving';
+
+  interface Props {
+    x: number;
+    y: number;
+    mood?: Mood;
+  }
+
+  let { x = $bindable(0), y = $bindable(0), mood = 'idle' }: Props = $props();
+
+  // ── Drag ─────────────────────────────────────────────────────────────
+  let dragging = $state(false);
+  let dragOffsetX = 0;
+  let dragOffsetY = 0;
+
+  function onPointerDown(e: PointerEvent) {
+    if (e.button !== 0) return;
+    dragging = true;
+    dragOffsetX = e.clientX - x;
+    dragOffsetY = e.clientY - y;
+    (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+    e.preventDefault();
+    e.stopPropagation();
+  }
+
+  function onPointerMove(e: PointerEvent) {
+    if (!dragging) return;
+    x = Math.max(Math.min(e.clientX - dragOffsetX, window.innerWidth - 45), 5);
+    y = Math.max(Math.min(e.clientY - dragOffsetY, window.innerHeight - 75), 5);
+  }
+
+  function onPointerUp() {
+    dragging = false;
+  }
+
+  const displayMood = $derived(dragging ? 'moving' : mood);
+
+  let mouthOpen = $state(false);
+
+  $effect(() => {
+    if (displayMood !== 'talking') {
+      mouthOpen = false;
+      return;
+    }
+    const id = setInterval(() => {
+      mouthOpen = !mouthOpen;
+    }, 180);
+    return () => clearInterval(id);
+  });
+
+  const MOUTH_DOWN =
+    'M29.5 55L28 63L23 68.5L14 70.5L6.5 66L4 58.5L10.5 29L15 24H24L28 29.5L28.5 34L23 58L16.5 61.5L10.5 59.5L8.5 53.5';
+  const MOUTH_UP =
+    'M29.5 55L28 63L23 68.5L14 70.5L6.5 66L4 58.5L10.5 29L15 24H24L28 29.5L28.5 34L24 56.5L17.5 60L11.5 58L9.5 52';
+
+  const bodyPath = $derived(
+    (displayMood === 'talking' && mouthOpen) || displayMood === 'happy' ? MOUTH_DOWN : MOUTH_UP
+  );
+
+  // ── Cursor-tracking pupils ────────────────────────────────────────────
+  // Avatar screen positions of each eye centre (SVG natural size 46×74)
+  let cursorX = $state(-9999);
+  let cursorY = $state(-9999);
+
+  function onMouseMove(e: MouseEvent) {
+    cursorX = e.clientX;
+    cursorY = e.clientY;
+  }
+
+  export function flash(flashMood: Mood, duration = 500) {
+    const prev = displayMood;
+    mood = flashMood;
+    setTimeout(() => (mood = prev), duration);
+  }
+
+  function pupilOffset(cx: number, cy: number, eyeSvgX: number, eyeSvgY: number, maxPx = 2.8) {
+    const ex = x + eyeSvgX;
+    const ey = y + eyeSvgY;
+    const dx = cx - ex;
+    const dy = cy - ey;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    if (dist < 1) return { px: 0, py: 0 };
+    // Ramp up to full offset over 120px of distance
+    const t = Math.min(dist, 120) / 120;
+    return { px: (dx / dist) * maxPx * t, py: (dy / dist) * maxPx * t };
+  }
+
+  const left = $derived(
+    displayMood === 'talking' ? { px: 0, py: 0 } : pupilOffset(cursorX, cursorY, 9.5, 30.5)
+  );
+  const right = $derived(
+    displayMood === 'talking' ? { px: 0, py: 0 } : pupilOffset(cursorX, cursorY, 31.5, 35.5)
+  );
+</script>
+
+<svelte:window onmousemove={onMouseMove} />
+
+<div
+  class="avatar"
+  role="button"
+  tabindex="0"
+  in:scale={{ duration: 400, delay: 300 }}
+  class:mood-idle={displayMood === 'idle'}
+  class:mood-thinking={displayMood === 'thinking'}
+  class:mood-talking={displayMood === 'talking'}
+  class:mood-happy={displayMood === 'happy'}
+  class:mood-moving={displayMood === 'moving'}
+  class:dragging
+  style:left="{x}px"
+  style:top="{y}px"
+  onpointerdown={onPointerDown}
+  onpointermove={onPointerMove}
+  onpointerup={onPointerUp}
+>
+  <svg
+    width="46"
+    height="74"
+    viewBox="0 0 46 74"
+    fill="none"
+    xmlns="http://www.w3.org/2000/svg"
+    overflow="visible"
+  >
+    <!--
+			Leaf hinge points (transform-box: fill-box):
+			  leave-right  →  origin 0% 100%   (bottom-left of bbox)
+			  leave-left   →  origin 100% 100% (bottom-right of bbox)
+		-->
+    <g class="leave-right">
+      <path
+        d="M26.9781 16.5596L22.013 23.2368L22.8082 25.306L35.2985 25.3849L43.7783 20.6393L45.8723 14.8213L35.7374 14.0864L26.9781 16.5596Z"
+        fill="#4F7B41"
+      />
+      <path
+        d="M27 16.5L22.013 23.2368L22.8082 25.306L29 21L36.5 17L45.8723 14.8213L36 14L27 16.5Z"
+        fill="#406634"
+      />
+    </g>
+
+    <g class="leave-left">
+      <path
+        d="M11.3107 19.2204L17.7636 24.7215L20.3207 25.3703L22.8257 13.0024L19.0993 2.99176L12.5794 1.95314e-05L10.0997 9.77364L11.3107 19.2204Z"
+        fill="#4F7B41"
+      />
+      <path
+        d="M11.3107 19.2204L17.7636 24.7215L20.3207 25.3703L16 17L13.5 8L12.5794 1.95314e-05L10.0997 9.77364L11.3107 19.2204Z"
+        fill="#5E8751"
+      />
+    </g>
+
+    <path class="body" d={bodyPath} stroke="#4F7B41" stroke-width="3" />
+
+    <!-- Left eye — pupils translated toward cursor -->
+    <g class="eye-left">
+      <circle cx="9.5" cy="30.5" r="9.5" fill="white" />
+      <g transform="translate({left.px} {left.py})">
+        <circle class="pupil" cx="9.5" cy="30.5" r="6.5" fill="black" />
+        <circle cx="10.5" cy="27.5" r="2.5" fill="white" />
+      </g>
+    </g>
+
+    <!-- Right eye — pupils translated toward cursor -->
+    <g class="eye-right">
+      <circle cx="31.5" cy="35.5" r="9.5" fill="white" />
+      <g transform="translate({right.px} {right.py})">
+        <circle class="pupil" cx="30.5" cy="34.5" r="6.5" fill="black" />
+        <circle cx="30.5" cy="31.5" r="2.5" fill="white" />
+      </g>
+    </g>
+  </svg>
+</div>
+
+<style>
+  /* ── Wrapper ─────────────────────────────────────────────────────── */
+  .avatar {
+  	position: absolute;
+  	cursor: grab;
+  	user-select: none;
+  	pointer-events: auto;
+  	filter: drop-shadow(0px 0px 10px black);
+  	transition:
+  		left 0.85s cubic-bezier(0.33, 1, 0.68, 1),
+  		top 0.85s cubic-bezier(0.33, 1, 0.68, 1);
+  }
+
+  .dragging {
+  	cursor: grabbing;
+  	transition: none;
+  }
+
+  /* idle: steady vertical bob */
+  @keyframes bob {
+  	0%,
+  	100% {
+  		transform: translateY(0);
+  	}
+  	50% {
+  		transform: translateY(-5px);
+  	}
+  }
+  .mood-idle {
+  	animation: bob 2.6s ease-in-out infinite;
+  }
+  .mood-happy {
+  	animation: bob 1.8s ease-in-out infinite;
+  }
+
+  /* thinking: head tilted to the side — clearly different from idle */
+  @keyframes think {
+  	0%,
+  	100% {
+  		transform: rotate(-12deg) translateY(0);
+  	}
+  	50% {
+  		transform: rotate(-12deg) translateY(-3px);
+  	}
+  }
+  .mood-thinking {
+  	animation: think 2.8s ease-in-out infinite;
+  }
+
+  /* talking: subtle head waggle */
+  @keyframes waggle {
+  	0%,
+  	100% {
+  		transform: rotate(0deg);
+  	}
+  	25% {
+  		transform: rotate(-2deg) translateY(-1px);
+  	}
+  	75% {
+  		transform: rotate(2deg) translateY(1px);
+  	}
+  }
+  .mood-talking {
+  	animation: waggle 0.3s ease-in-out infinite;
+  }
+
+  /* moving: forward-lean glide */
+  @keyframes glide {
+  	0%,
+  	100% {
+  		transform: translateY(0) rotate(-6deg);
+  	}
+  	50% {
+  		transform: translateY(-8px) rotate(-4deg);
+  	}
+  }
+  .mood-moving {
+  	animation: glide 0.4s ease-in-out infinite;
+  }
+
+  /* ── Drop shadows ────────────────────────────────────────────────── */
+  .body {
+  	filter: drop-shadow(1px 1px 0 rgba(0, 0, 0, 0.5));
+  	transition: d 0.12s ease-in-out;
+  }
+  .eye-left,
+  .eye-right {
+  	filter: drop-shadow(1px 1px 0 rgba(0, 0, 0, 0.5));
+  }
+
+  .mood-talking {
+  	.eye-left,
+  	.eye-right {
+  		> g {
+  			transition: transform 0.5s ease-in-out;
+  		}
+  	}
+  }
+
+  /* ── Leaves ──────────────────────────────────────────────────────── */
+  .leave-right {
+  	transform-box: fill-box;
+  	transform-origin: 0% 100%;
+  }
+  .leave-left {
+  	transform-box: fill-box;
+  	transform-origin: 100% 100%;
+  }
+
+  /* idle: slow gentle breathing wave */
+  @keyframes idle-right {
+  	0%,
+  	100% {
+  		transform: rotate(0deg);
+  	}
+  	50% {
+  		transform: rotate(-9deg);
+  	}
+  }
+  @keyframes idle-left {
+  	0%,
+  	100% {
+  		transform: rotate(0deg);
+  	}
+  	50% {
+  		transform: rotate(7deg);
+  	}
+  }
+  .mood-idle .leave-right {
+  	animation: idle-right 3s ease-in-out infinite;
+  }
+  .mood-idle .leave-left {
+  	animation: idle-left 3s ease-in-out infinite 0.15s;
+  }
+
+  /* thinking: wings held raised, minimal drift */
+  @keyframes think-right {
+  	0%,
+  	100% {
+  		transform: rotate(-14deg);
+  	}
+  	50% {
+  		transform: rotate(-10deg);
+  	}
+  }
+  @keyframes think-left {
+  	0%,
+  	100% {
+  		transform: rotate(10deg);
+  	}
+  	50% {
+  		transform: rotate(7deg);
+  	}
+  }
+  .mood-thinking .leave-right {
+  	animation: think-right 4s ease-in-out infinite;
+  }
+  .mood-thinking .leave-left {
+  	animation: think-left 4s ease-in-out infinite 0.3s;
+  }
+
+  /* talking: nearly still — tiny passive counter-sway */
+  @keyframes talk-right {
+  	0%,
+  	100% {
+  		transform: rotate(-2deg);
+  	}
+  	50% {
+  		transform: rotate(2deg);
+  	}
+  }
+  @keyframes talk-left {
+  	0%,
+  	100% {
+  		transform: rotate(2deg);
+  	}
+  	50% {
+  		transform: rotate(-2deg);
+  	}
+  }
+  .mood-talking .leave-right {
+  	animation: talk-right 0.6s ease-in-out infinite;
+  }
+  .mood-talking .leave-left {
+  	animation: talk-left 0.6s ease-in-out infinite 0.1s;
+  }
+
+  /* happy: light casual flap */
+  @keyframes happy-right {
+  	0%,
+  	100% {
+  		transform: rotate(0deg);
+  	}
+  	50% {
+  		transform: rotate(-18deg);
+  	}
+  }
+  @keyframes happy-left {
+  	0%,
+  	100% {
+  		transform: rotate(0deg);
+  	}
+  	50% {
+  		transform: rotate(13deg);
+  	}
+  }
+  .mood-happy .leave-right {
+  	animation: happy-right 1.4s ease-in-out infinite;
+  }
+  .mood-happy .leave-left {
+  	animation: happy-left 1.4s ease-in-out infinite 0.1s;
+  }
+
+  /* moving: vigorous wing flap — full range, fast */
+  @keyframes flap-right {
+  	0%,
+  	100% {
+  		transform: rotate(0deg);
+  	}
+  	40% {
+  		transform: rotate(-40deg);
+  	}
+  }
+  @keyframes flap-left {
+  	0%,
+  	100% {
+  		transform: rotate(0deg);
+  	}
+  	40% {
+  		transform: rotate(26deg);
+  	}
+  }
+  .mood-moving .leave-right {
+  	animation: flap-right 0.34s ease-in-out infinite;
+  }
+  .mood-moving .leave-left {
+  	animation: flap-left 0.34s ease-in-out infinite 0.04s;
+  }
+
+  /* ── Eye blink (on pupil so it doesn't fight cursor translate) ───── */
+  @keyframes blink {
+  	0%,
+  	93%,
+  	100% {
+  		transform: scaleY(1);
+  	}
+  	96% {
+  		transform: scaleY(0.05);
+  	}
+  }
+  .pupil {
+  	transform-box: fill-box;
+  	transform-origin: center;
+  	animation: blink 4s ease-in-out infinite;
+  }
+  .eye-left .pupil {
+  	animation-delay: 0s;
+  }
+  .eye-right .pupil {
+  	animation-delay: 0.07s;
+  }
+</style>

packages/planty/src/lib/components/SpeechBubble.svelte

@@ -0,0 +1,172 @@
+<script lang="ts">
+  import { fade } from 'svelte/transition';
+  import type { Choice } from '../types.js';
+
+  interface Props {
+    text: string;
+    avatarX: number;
+    avatarY: number;
+    choices?: Choice[];
+    showNext?: boolean;
+    stepIndex?: number;
+    totalSteps?: number;
+    onNext?: () => void;
+    onClose?: () => void;
+    onChoose?: (choice: Choice) => void;
+  }
+
+  let {
+    text,
+    avatarX,
+    avatarY,
+    choices = [],
+    showNext = false,
+    stepIndex = -1,
+    totalSteps = 0,
+    onNext,
+    onClose,
+    onChoose
+  }: Props = $props();
+
+  const showProgress = $derived(stepIndex >= 0 && totalSteps > 0);
+
+  const BUBBLE_WIDTH = 268;
+  const AVATAR_SIZE = 80;
+  const GAP = 10;
+
+  const isAvatarNearTop = $derived(avatarY < BUBBLE_WIDTH + GAP + 8);
+
+  const left = $derived(Math.max(8, Math.min(avatarX, window.innerWidth - BUBBLE_WIDTH - 8)));
+  const bottom = $derived(isAvatarNearTop ? null : `${window.innerHeight - avatarY + GAP}px`);
+  const top = $derived(isAvatarNearTop ? `${avatarY + AVATAR_SIZE + GAP}px` : null);
+
+  // Typewriter
+  let displayed = $state('');
+  const finished = $derived(displayed.length === text.length);
+  let typeTimer: ReturnType<typeof setTimeout> | null = null;
+
+  function renderMarkdown(raw: string): string {
+    return raw
+      .replaceAll(/^# (.+)$/gm, '<strong class="block text-sm font-bold mb-1">$1</strong>')
+      .replaceAll(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+      .replaceAll(/\*(.+?)\*/g, '<em>$1</em>')
+      .replaceAll(
+        /`(.+?)`/g,
+        '<code class="text-[11px] rounded px-1 font-mono" style="background: var(--color-layer-3); color: var(--color-text);">$1</code>'
+      )
+      .replaceAll(/\*/g, '')
+      .replaceAll(/_/g, '')
+      .replaceAll(/\n+/g, '<br>');
+  }
+
+  $effect(() => {
+    // Track only `text` as a dependency.
+    // Never read `displayed` inside the effect — += would add it as a dep
+    // and cause an infinite loop. Use slice(0, i) for pure writes instead.
+    const target = text;
+
+    displayed = '';
+    if (typeTimer) clearTimeout(typeTimer);
+
+    let i = 0;
+    function tick() {
+      if (i < target.length) {
+        displayed = target.slice(0, ++i);
+        typeTimer = setTimeout(tick, 26);
+      }
+    }
+    // Defer first tick so no reads happen during the synchronous effect body
+    typeTimer = setTimeout(tick, 0);
+
+    return () => {
+      if (typeTimer) clearTimeout(typeTimer);
+    };
+  });
+</script>
+
+<div
+  class="pointer-events-auto fixed z-99999 rounded-md border p-2"
+  style:width="{BUBBLE_WIDTH}px"
+  style:left="{left}px"
+  style:bottom
+  style:top
+  style:background="var(--color-layer-0)"
+  style:border-color="var(--color-outline)"
+>
+  {#if isAvatarNearTop}
+    <!-- Tail pointing up toward avatar -->
+    <div
+      class="absolute -top-2 h-3.5 w-3.5 rotate-45 border-t border-l"
+      style:left="{Math.min(
+				Math.max(avatarX - left + AVATAR_SIZE / 2 - 25, 12),
+				BUBBLE_WIDTH - 28
+			)}px"
+      style:background="var(--color-layer-0)"
+      style:border-color="var(--color-outline)"
+    >
+    </div>
+  {:else}
+    <!-- Tail pointing down toward avatar -->
+    <div
+      class="absolute -bottom-2 h-3.5 w-3.5 rotate-45 border-r border-b"
+      style:left="{Math.min(
+				Math.max(avatarX - left + AVATAR_SIZE / 2 - 25, 12),
+				BUBBLE_WIDTH - 28
+			)}px"
+      style:background="var(--color-layer-0)"
+      style:border-color="var(--color-outline)"
+    >
+    </div>
+  {/if}
+
+  <div class="mb-2 min-h-[1.4em] text-sm leading-relaxed" style="color: var(--color-text)">
+    <!-- eslint-disable-next-line svelte/no-at-html-tags -->
+    {@html renderMarkdown(displayed)}
+  </div>
+
+  {#if choices.length > 0}
+    <div class="flex flex-col gap-1.5">
+      {#each choices as choice, i (choice.label)}
+        {#if finished}
+          <button
+            in:fade={{ duration: 200, delay: i * 250 }}
+            class="cursor-pointer rounded-lg px-3 py-1.5 text-left text-sm font-medium transition-colors"
+            style:background="var(--color-layer-1)"
+            style:border-color="var(--color-outline)"
+            style:color="var(--color-text)"
+            onclick={() => onChoose?.(choice)}
+          >
+            {choice.label}
+          </button>
+        {/if}
+      {/each}
+    </div>
+  {/if}
+
+  <div class="mt-2 flex items-center justify-between gap-2">
+    <button
+      class="cursor-pointer text-xs transition-colors"
+      style="color: var(--color-outline)"
+      onclick={onClose}
+    >
+      ✕ close
+    </button>
+    <div class="flex items-center gap-2">
+      {#if showProgress}
+        <span class="text-xs tabular-nums" style="color: var(--color-outline)">
+          {stepIndex + 1} / {totalSteps}
+        </span>
+      {/if}
+      {#if showNext && finished}
+        <button
+          class="cursor-pointer rounded-lg px-3 py-1 text-xs font-semibold transition-colors"
+          style:background="var(--color-outline)"
+          style:color="var(--color-layer-0)"
+          onclick={onNext}
+        >
+          Next →
+        </button>
+      {/if}
+    </div>
+  </div>
+</div>

packages/planty/src/lib/dialog-runner.ts

@@ -0,0 +1,52 @@
+import type { Choice, DialogNode, PlantyConfig } from './types.js';
+
+export class DialogRunner {
+  private config: PlantyConfig;
+
+  constructor(config: PlantyConfig) {
+    this.config = config;
+  }
+
+  getNode(id: string): DialogNode | null {
+    return this.config.nodes[id] ?? null;
+  }
+
+  getStartNode(): { id: string; node: DialogNode } | null {
+    const node = this.getNode(this.config.start);
+    if (!node) return null;
+    return { id: this.config.start, node };
+  }
+
+  getNextNode(currentId: string): { id: string; node: DialogNode } | null {
+    const current = this.getNode(currentId);
+    if (!current) return null;
+    if (!current.next) return null;
+    const next = this.getNode(current.next);
+    if (!next) return null;
+    return { id: current.next, node: next };
+  }
+
+  followChoice(choice: Choice): { id: string; node: DialogNode } | null {
+    if (!choice.next) return null;
+    const node = this.getNode(choice.next);
+    if (!node) return null;
+    return { id: choice.next, node };
+  }
+
+  /** Walk the main path (first choice for choice nodes) and return all node IDs. */
+  getMainPath(): string[] {
+    const path: string[] = [];
+    const visited = new Set<string>();
+    let id: string | null = this.config.start;
+    while (id && !visited.has(id)) {
+      visited.add(id);
+      path.push(id);
+      const node = this.getNode(id);
+      if (!node) break;
+      const next = node.choices?.[0]?.next ?? node.next;
+      if (next) id = next;
+      else break;
+    }
+    return path;
+  }
+}

packages/planty/src/lib/index.ts

@@ -0,0 +1,11 @@
+export { default as Planty } from './components/Planty.svelte';
+export type {
+  AvatarAnchor,
+  AvatarPosition,
+  Choice,
+  DialogNode,
+  HighlightTarget,
+  PlantyConfig,
+  PlantyHook,
+  StepCallback
+} from './types.js';

packages/planty/src/lib/planty-steps.ts

@@ -0,0 +1,66 @@
+import type { DialogNode, StepCallback } from './types.js';
+
+/**
+ * Cross-module step hook registry.
+ *
+ * Create one shared instance and import it wherever you need to react to
+ * Planty steps — no reference to the <Planty> component required.
+ *
+ * @example
+ * // tutorial-steps.ts
+ * export const steps = createPlantySteps();
+ *
+ * // graph-editor.ts
+ * steps.before('highlight_graph', () => graphEditor.setHighlight(true));
+ * steps.after ('highlight_graph', () => graphEditor.setHighlight(false));
+ *
+ * // +page.svelte
+ * <Planty {config} {steps} />
+ */
+export class PlantySteps {
+  private _before = new Map<string, StepCallback[]>();
+  private _after = new Map<string, StepCallback[]>();
+
+  /** Register a handler to run before `nodeId` becomes active. Chainable. */
+  before(nodeId: string, fn: StepCallback): this {
+    const list = this._before.get(nodeId) ?? [];
+    this._before.set(nodeId, [...list, fn]);
+    return this;
+  }
+
+  /** Register a handler to run after the user leaves `nodeId`. Chainable. */
+  after(nodeId: string, fn: StepCallback): this {
+    const list = this._after.get(nodeId) ?? [];
+    this._after.set(nodeId, [...list, fn]);
+    return this;
+  }
+
+  /** Remove all handlers for a node (or all nodes if omitted). */
+  clear(nodeId?: string) {
+    if (nodeId) {
+      this._before.delete(nodeId);
+      this._after.delete(nodeId);
+    } else {
+      this._before.clear();
+      this._after.clear();
+    }
+  }
+
+  /** @internal — called by Planty */
+  async runBefore(nodeId: string, node: DialogNode): Promise<void> {
+    for (const fn of this._before.get(nodeId) ?? []) {
+      await fn(nodeId, node);
+    }
+  }
+
+  /** @internal — called by Planty */
+  async runAfter(nodeId: string, node: DialogNode): Promise<void> {
+    for (const fn of this._after.get(nodeId) ?? []) {
+      await fn(nodeId, node);
+    }
+  }
+}
+
+export function createPlantySteps(): PlantySteps {
+  return new PlantySteps();
+}

packages/planty/src/lib/types.ts

@@ -0,0 +1,55 @@
+export type AvatarAnchor =
+  | 'top-left'
+  | 'top-right'
+  | 'bottom-left'
+  | 'bottom-right'
+  | 'center'
+  | 'right';
+
+export type AvatarPosition = { x: number; y: number } | AvatarAnchor;
+
+export interface HighlightTarget {
+  /** CSS selector for the element to highlight */
+  selector?: string;
+  /** Name of an app-registered hook that returns Element | null */
+  hookName?: string;
+  /** Extra space around the element in px */
+  padding?: number;
+}
+
+export interface DialogNode {
+  text?: string;
+  position?: AvatarPosition;
+  highlight?: HighlightTarget;
+  /** App hook to call on entering this node */
+  action?: string;
+  next?: string | null;
+  choices?: Choice[];
+  /** Called (and awaited) just before the avatar starts moving to this node */
+  before?: StepCallback;
+  /** Called (and awaited) just before the user leaves this node */
+  after?: StepCallback;
+}
+
+export interface Choice {
+  label: string;
+  next?: string | null;
+  action?: string;
+}
+
+export interface PlantyConfig {
+  id: string;
+  avatar?: {
+    name?: string;
+    defaultPosition?: AvatarPosition;
+  };
+  start: string;
+  nodes: Record<string, DialogNode>;
+}
+
+export type PlantyHook = (
+  ...args: unknown[]
+) => void | Element | null | Promise<void> | (() => void);
+
+/** Called before/after a node becomes active. Async-safe. */
+export type StepCallback = (nodeId: string, node: DialogNode) => void | Promise<void>;

packages/planty/src/routes/+layout.svelte

@@ -0,0 +1,7 @@
+<script lang="ts">
+  import '@nodarium/ui/app.css';
+  import './layout.css';
+  const { children } = $props();
+</script>
+
+{@render children()}

packages/planty/src/routes/+page.svelte

@@ -0,0 +1,147 @@
+<script lang="ts">
+  import Planty from '$lib/components/Planty.svelte';
+  import PlantyAvatar, { type Mood } from '$lib/components/PlantyAvatar.svelte';
+  import type { PlantyConfig } from '$lib/types.js';
+  import { onMount } from 'svelte';
+  import ThemeSelector from './ThemeSelector.svelte';
+
+  let plantyConfig = $state<PlantyConfig | null>(null);
+  let planty: ReturnType<typeof Planty> | undefined = $state();
+  let started = $state(false);
+
+  // Avatar preview state
+  const moods: Mood[] = ['idle', 'talking', 'happy', 'thinking', 'moving'];
+  let previewMood = $state<Mood>('idle');
+
+  onMount(async () => {
+    const res = await fetch('/demo-tutorial.json');
+    plantyConfig = await res.json();
+  });
+
+  function startTour() {
+    planty?.start();
+    started = true;
+  }
+</script>
+
+<svelte:head>
+  <title>Planty — Demo</title>
+</svelte:head>
+
+<div
+  class="grid min-h-screen grid-rows-[auto_1fr]"
+  style="background-color: var(--color-layer-0); color: var(--color-text);"
+>
+  <!-- Header -->
+  <header
+    class="flex h-12 items-center gap-4 px-8 py-5"
+    style="border-color: var(--color-outline);"
+  >
+    <h1 class="text-xl font-semibold">🌿 Planty</h1>
+    <span
+      class="rounded-full px-2 py-0.5 text-xs font-bold"
+      style="background: var(--color-layer-3); color: var(--color-layer-0);"
+    >demo</span>
+
+    <ThemeSelector />
+
+    <button
+      class="ml-auto rounded-xl px-5 py-2 text-sm font-bold transition hover:scale-95 active:scale-95"
+      style="background: var(--color-layer-3); color: var(--color-layer-0);"
+      onclick={startTour}
+      disabled={started || !plantyConfig}
+    >
+      {started ? 'Tour running…' : 'Start tutorial'}
+    </button>
+  </header>
+
+  <!-- App layout -->
+  <main class="grid grid-cols-[1fr_280px]">
+    <!-- Graph canvas -->
+    <div
+      id="graph-canvas"
+      class="relative flex min-h-125 items-center justify-center"
+      style="background-color: var(--color-layer-1); background-image: radial-gradient(circle, var(--color-outline) 1px, transparent 1px); background-size: 24px 24px;"
+    >
+      <p class="text-center text-sm" style="color: var(--color-outline);">
+        Node graph canvas<br />
+        <span style="opacity: 0.6;">(click "Start tutorial" above)</span>
+      </p>
+
+      <!-- Avatar mood preview (bottom of canvas) -->
+      <div class="absolute bottom-6 left-1/2 flex -translate-x-1/2 flex-col items-center gap-4">
+        <!-- Static preview at fixed position inside the canvas -->
+        <div class="relative h-20 w-12">
+          <PlantyAvatar x={0} y={0} mood={previewMood} />
+        </div>
+        <div class="flex gap-2">
+          {#each moods as m (m)}
+            <button
+              class="rounded-lg border px-3 py-1 text-xs transition"
+              onclick={() => (previewMood = m)}
+              style="border-color: {previewMood === m
+  ? 'var(--color-selected)'
+  : 'var(--color-outline)'}; color: {previewMood === m
+  ? 'var(--color-selected)'
+  : 'var(--color-text)'}; background: {previewMood === m
+  ? 'var(--color-layer-2)'
+  : 'transparent'};"
+            >
+              {m}
+            </button>
+          {/each}
+        </div>
+      </div>
+    </div>
+
+    <!-- Sidebar -->
+    <aside
+      id="sidebar"
+      class="flex flex-col gap-3 p-5"
+      style="border-color: var(--color-outline); background-color: var(--color-layer-0);"
+    >
+      <span
+        class="text-xs font-semibold tracking-widest uppercase"
+        style="color: var(--color-outline);"
+      >Parameters</span>
+      <div
+        class="rounded-lg px-3 py-2 text-sm"
+        style="background: var(--color-layer-1); color: var(--color-text);"
+      >
+        Branch length: 1.0
+      </div>
+      <div
+        class="rounded-lg px-3 py-2 text-sm"
+        style="background: var(--color-layer-1); color: var(--color-text);"
+      >
+        Segments: 8
+      </div>
+      <div
+        class="rounded-lg px-3 py-2 text-sm"
+        style="background: var(--color-layer-1); color: var(--color-text);"
+      >
+        Leaf density: 0.6
+      </div>
+      <span
+        class="mt-2 text-xs font-semibold tracking-widest uppercase"
+        style="color: var(--color-outline);"
+      >Export</span>
+      <div
+        class="rounded-lg px-3 py-2 text-sm"
+        style="background: var(--color-layer-1); color: var(--color-text);"
+      >
+        .obj / .glb
+      </div>
+    </aside>
+  </main>
+</div>
+
+{#if plantyConfig}
+  <Planty
+    bind:this={planty}
+    config={plantyConfig}
+    onComplete={() => {
+      started = false;
+    }}
+  />
+{/if}

packages/planty/src/routes/ThemeSelector.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+  import { InputSelect } from '@nodarium/ui';
+  const themes = [
+    'dark',
+    'light',
+    'solarized',
+    'catppuccin',
+    'high-contrast',
+    'high-contrast-light',
+    'nord',
+    'dracula',
+    'custom'
+  ];
+
+  let themeIndex = $state(0);
+  $effect(() => {
+    const classList = document.documentElement.classList;
+    for (const c of classList) {
+      if (c.startsWith('theme-')) document.documentElement.classList.remove(c);
+    }
+    document.documentElement.classList.add(`theme-${themes[themeIndex]}`);
+  });
+</script>
+
+<InputSelect bind:value={themeIndex} options={themes}></InputSelect>

packages/planty/src/routes/layout.css

@@ -0,0 +1,7 @@
+@import 'tailwindcss';
+
+body {
+	color: var(--color-text);
+	background-color: var(--color-layer-0);
+	margin: 0;
+}

packages/planty/static/demo-tutorial.json

@@ -0,0 +1,87 @@
+{
+  "id": "demo-tutorial",
+  "avatar": {
+    "name": "Planty",
+    "defaultPosition": "bottom-right"
+  },
+  "start": "welcome",
+  "nodes": {
+    "welcome": {
+      "type": "choice",
+      "position": "bottom-right",
+      "text": "👋 Hey! I'm Planty — your guide to this app. How would you like me to explain things?",
+      "choices": [
+        { "label": "🤓 Technical — give me the details", "next": "intro_nerd" },
+        { "label": "🌱 Simple — keep it friendly", "next": "intro_simple" },
+        { "label": "No thanks, skip the tour", "next": null }
+      ]
+    },
+
+    "intro_nerd": {
+      "type": "step",
+      "position": "bottom-right",
+      "text": "This is a WebAssembly-powered node graph. Each node is a compiled .wasm module executed in a sandboxed runtime.",
+      "next": "highlight_graph_nerd"
+    },
+    "intro_simple": {
+      "type": "step",
+      "position": "bottom-right",
+      "text": "Think of this like a recipe card — each block does one thing, and you connect them to build a plant!",
+      "next": "highlight_graph_simple"
+    },
+
+    "highlight_graph_nerd": {
+      "type": "step",
+      "position": "bottom-left",
+      "highlight": { "selector": "#graph-canvas", "padding": 12 },
+      "text": "The graph canvas renders edges as Bézier curves. Node execution is topologically sorted before each WASM call.",
+      "next": "highlight_sidebar_nerd"
+    },
+    "highlight_graph_simple": {
+      "type": "step",
+      "position": "bottom-left",
+      "highlight": { "selector": "#graph-canvas", "padding": 12 },
+      "text": "This is the main canvas — drag nodes around and connect them to create your plant!",
+      "next": "highlight_sidebar_simple"
+    },
+
+    "highlight_sidebar_nerd": {
+      "type": "step",
+      "position": "bottom-right",
+      "highlight": { "selector": "#sidebar", "padding": 8 },
+      "text": "The sidebar exposes node parameters, export settings, and the raw graph JSON for debugging.",
+      "next": "tip_nerd"
+    },
+    "highlight_sidebar_simple": {
+      "type": "step",
+      "position": "bottom-right",
+      "highlight": { "selector": "#sidebar", "padding": 8 },
+      "text": "The sidebar lets you tweak settings and export your creation.",
+      "next": "tip_simple"
+    },
+
+    "tip_nerd": {
+      "type": "step",
+      "position": "center",
+      "text": "Press Space or double-click the canvas to open node search. Nodes are fetched from the WASM registry at runtime.",
+      "next": "done_nerd"
+    },
+    "tip_simple": {
+      "type": "step",
+      "position": "center",
+      "text": "Press Space anywhere on the canvas to add a new block — try it!",
+      "next": "done_simple"
+    },
+
+    "done_nerd": {
+      "type": "end",
+      "position": "bottom-right",
+      "text": "You're all set. Check the docs for the full NodeDefinition interface. Happy hacking! 🌿"
+    },
+    "done_simple": {
+      "type": "end",
+      "position": "bottom-right",
+      "text": "That's the tour! Have fun building your plant. 🌱"
+    }
+  }
+}

packages/planty/static/favicon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="107" height="128" viewBox="0 0 107 128">
+  <title>svelte-logo</title><path
+    d="M94.157 22.819c-10.4-14.885-30.94-19.297-45.792-9.835L22.282 29.608A29.92 29.92 0 0 0 8.764 49.65a31.5 31.5 0 0 0 3.108 20.231 30 30 0 0 0-4.477 11.183 31.9 31.9 0 0 0 5.448 24.116c10.402 14.887 30.942 19.297 45.791 9.835l26.083-16.624A29.92 29.92 0 0 0 98.235 78.35a31.53 31.53 0 0 0-3.105-20.232 30 30 0 0 0 4.474-11.182 31.88 31.88 0 0 0-5.447-24.116"
+    style="fill:#ff3e00"
+  /><path
+    d="M45.817 106.582a20.72 20.72 0 0 1-22.237-8.243 19.17 19.17 0 0 1-3.277-14.503 18 18 0 0 1 .624-2.435l.49-1.498 1.337.981a33.6 33.6 0 0 0 10.203 5.098l.97.294-.09.968a5.85 5.85 0 0 0 1.052 3.878 6.24 6.24 0 0 0 6.695 2.485 5.8 5.8 0 0 0 1.603-.704L69.27 76.28a5.43 5.43 0 0 0 2.45-3.631 5.8 5.8 0 0 0-.987-4.371 6.24 6.24 0 0 0-6.698-2.487 5.7 5.7 0 0 0-1.6.704l-9.953 6.345a19 19 0 0 1-5.296 2.326 20.72 20.72 0 0 1-22.237-8.243 19.17 19.17 0 0 1-3.277-14.502 17.99 17.99 0 0 1 8.13-12.052l26.081-16.623a19 19 0 0 1 5.3-2.329 20.72 20.72 0 0 1 22.237 8.243 19.17 19.17 0 0 1 3.277 14.503 18 18 0 0 1-.624 2.435l-.49 1.498-1.337-.98a33.6 33.6 0 0 0-10.203-5.1l-.97-.294.09-.968a5.86 5.86 0 0 0-1.052-3.878 6.24 6.24 0 0 0-6.696-2.485 5.8 5.8 0 0 0-1.602.704L37.73 51.72a5.42 5.42 0 0 0-2.449 3.63 5.79 5.79 0 0 0 .986 4.372 6.24 6.24 0 0 0 6.698 2.486 5.8 5.8 0 0 0 1.602-.704l9.952-6.342a19 19 0 0 1 5.295-2.328 20.72 20.72 0 0 1 22.237 8.242 19.17 19.17 0 0 1 3.277 14.503 18 18 0 0 1-8.13 12.053l-26.081 16.622a19 19 0 0 1-5.3 2.328"
+    style="fill:#fff"
+  />
+</svg>

packages/planty/svelte.config.js

@@ -0,0 +1,17 @@
+import adapter from '@sveltejs/adapter-auto';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+  compilerOptions: {
+    // Force runes mode for the project, except for libraries. Can be removed in svelte 6.
+    runes: ({ filename }) => (filename.split(/[/\\]/).includes('node_modules') ? undefined : true)
+  },
+  kit: {
+    // adapter-auto only supports some environments, see https://svelte.dev/docs/kit/adapter-auto for a list.
+    // If your environment is not supported, or you settled on a specific environment, switch out the adapter.
+    // See https://svelte.dev/docs/kit/adapters for more information about adapters.
+    adapter: adapter()
+  }
+};
+
+export default config;

packages/planty/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "rewriteRelativeImportExtensions": true,
+    "allowJs": true,
+    "checkJs": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "module": "NodeNext",
+    "moduleResolution": "bundler"
+  }
+}

packages/planty/vite.config.ts

@@ -0,0 +1,5 @@
+import { sveltekit } from '@sveltejs/kit/vite';
+import tailwindcss from '@tailwindcss/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({ plugins: [tailwindcss(), sveltekit()] });

packages/types/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@nodarium/types",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "",
+  "type": "module",
   "main": "src/index.ts",
   "scripts": {
     "format": "dprint fmt -c '../../.dprint.jsonc' .",

packages/types/src/index.ts

@@ -4,7 +4,9 @@ export type {
   Box,
   Edge,
   Graph,
+  GroupSocket,
   NodeDefinition,
+  NodeGroupDefinition,
   NodeId,
   NodeInstance,
   SerializedNode,

packages/types/src/types.ts

@@ -51,7 +51,7 @@ export const NodeSchema = z.object({
   id: z.number(),
   type: NodeIdSchema,
   props: z
-    .record(z.string(), z.union([z.number(), z.array(z.number())]))
+    .record(z.string(), z.union([z.number(), z.array(z.number()), z.string()]))
     .optional(),
   meta: z
     .object({
@@ -76,6 +76,33 @@ export type Socket = {
 
 export type Edge = [NodeInstance, number, NodeInstance, string];
 
+export type GroupSocket = {
+  name: string;
+  type: string;
+};
+
+export type NodeGroupDefinition = {
+  id: string;
+  name: string;
+  inputs: GroupSocket[];
+  outputs: GroupSocket[];
+  graph: {
+    nodes: SerializedNode[];
+    edges: [number, number, number, string][];
+  };
+};
+
+const NodeGroupDefinitionSchema: z.ZodType<NodeGroupDefinition> = z.object({
+  id: z.string(),
+  name: z.string(),
+  inputs: z.array(z.object({ name: z.string(), type: z.string() })),
+  outputs: z.array(z.object({ name: z.string(), type: z.string() })),
+  graph: z.object({
+    nodes: z.array(NodeSchema),
+    edges: z.array(z.tuple([z.number(), z.number(), z.number(), z.string()]))
+  })
+});
+
 export const GraphSchema = z.object({
   id: z.number(),
   meta: z
@@ -86,7 +113,8 @@ export const GraphSchema = z.object({
     .optional(),
   settings: z.record(z.string(), z.any()).optional(),
   nodes: z.array(NodeSchema),
-  edges: z.array(z.tuple([z.number(), z.number(), z.number(), z.string()]))
+  edges: z.array(z.tuple([z.number(), z.number(), z.number(), z.string()])),
+  groups: z.record(z.string(), NodeGroupDefinitionSchema).optional()
 });
 
 export type Graph = z.infer<typeof GraphSchema>;

packages/ui/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@nodarium/ui",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "scripts": {
     "dev": "vite",
-    "build": "vite build && npm run package",
+    "build": "vite build",
     "preview": "vite preview",
     "package": "svelte-kit sync && svelte-package && publint",
     "prepublishOnly": "npm run package",
@@ -16,10 +16,10 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./src/lib/index.ts",
-      "svelte": "./dist/index.js"
+      "svelte": "./src/lib/index.ts"
     },
-    "./app.css": "./dist/app.css"
+    "./app.css": "./src/lib/app.css"
   },
   "files": [
     "dist",
@@ -64,6 +64,7 @@
   "types": "./dist/index.d.ts",
   "type": "module",
   "dependencies": {
+    "@nodarium/ui": "workspace:*",
     "@iconify-json/tabler": "^1.2.26",
     "@iconify/tailwind4": "^1.2.1",
     "@tailwindcss/vite": "^4.1.18",

packages/utils/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@nodarium/utils",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "",
-  "main": "src/index.ts",
+  "main": "./src/index.ts",
+  "type": "module",
   "scripts": {
     "test": "vitest",
     "format": "dprint fmt -c '../../.dprint.jsonc' .",

pnpm-workspace.yaml

@@ -7,3 +7,6 @@ packages:
 
 catalog:
   chokidar-cli: github:open-cli-tools/chokidar-cli#semver:v4.0.0
+onlyBuiltDependencies:
+  - "@tailwindcss/oxide"
+  - esbuild